Grundlagen der Programmierung 3 A
|
|
|
- Ralf Gerber
- vor 6 Jahren
- Abrufe
Transkript
1 Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017
2 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln Typ-Berechnung Milners Typcheck (Robin Milner) Grundlagen der Programmierung 2 (Typen-A) 2/37
3 Einige andere Programmiersprachen ab Java 5: generische Typen verwandt mit polymorphen Typen ML (und CAML, OCAML) hat parametrisch polymorphes Typsystem JavaScript Nachteile: Es fehlt eine statische Typisierung TypeScript (Microsoft): Neue JavaScript Variante mit statischer Typisierung und Typinferenz. Google Ankündigung: Angular 2 (JavaScript-Webframework) zukünftig auf Basis von TypeScript Grundlagen der Programmierung 2 (Typen-A) 3/37
4 Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mit parametrisch polymorphen Typen. jeder Ausdruck muss einen Typ haben Der Typchecker berechnet Typen aller Ausdrücke und prüft Typen zur Compilezeit Es gibt keine Typfehler zur Laufzeit d.h. kein dynamischer Typcheck nötig. Grundlagen der Programmierung 2 (Typen-A) 4/37
5 Überladung und Konversion in Haskell Haskell: keine Typkonversion Es gibt Überladung: z.b. arithmetische Operatoren: +,., / Zahlkonstanten für ganze Zahlen sind überladen Grundlagen der Programmierung 2 (Typen-A) 5/37
6 Überladung und Konversion in Haskell Haskell: keine Typkonversion Es gibt Überladung: z.b. arithmetische Operatoren: +,., / Zahlkonstanten für ganze Zahlen sind überladen Typcheck erstmal ohne Überladung ohne Kinds und ohne Typen höherer Ordnung Grundlagen der Programmierung 2 (Typen-A) 5/37
7 Typisierung, Begriffe polymorph: parametrisch polymorph: Ein Ausdruck kann viele Typen haben (vielgestaltig, polymorph). Die (i.a. unendliche) Menge der Typen entspricht einem schematischen Typausdruck Beispiel Schema: length [a]->int Instanzen: [Int]->Int, [Char]->Int, [[Char]]->Int usw. Grundlagen der Programmierung 2 (Typen-A) 6/37
8 Syntax von Typen in Haskell (ohne Typklassen) Typ ::= Basistyp ( Typ ) Typvariable Typkonstruktor n { Typ } n (n = Stelligkeit) Basistyp ::= Int Integer Float Rational Char... Grundlagen der Programmierung 2 (Typen-A) 7/37
9 Syntax von Typen Typkonstruktoren können benutzerdefiniert sein (z.b. Baum a) Vordefinierte Liste [ ] Typkonstruktoren: Tupel (.,...,.) Funktionen (Stelligkeit 2, Infix) Konvention zu Funktionstypen mit a b c d bedeutet: a (b (c d)). Grundlagen der Programmierung 2 (Typen-A) 8/37
10 Interpretation der Typen length :: [a] -> Int Interpretation: Für alle Typen typ ist length eine Funktion, die vom Typ [typ] Int ist. Grundlagen der Programmierung 2 (Typen-A) 9/37
11 Komposition Beispiel: Komposition von Funktionen: komp::(a -> b) -> (c -> a) -> c -> b komp f g x = f (g x) In Haskell ist komp vordefiniert und wird als. geschrieben: Beispielaufruf: *Main> suche_nullstelle (sin. quadrat) (sin. quadrat) entspricht sin(x 2 ) und quadrat. sin entspricht (sin(x)) 2. Grundlagen der Programmierung 2 (Typen-A) 10/37
12 Typ der Komposition Erklärung zum Typ von komp, wobei {a,b,c} Typvariablen sind. Ausdruck: f komp g bzw. f. g (a->b) -> (c->a) -> c->b Typ von (.) (τ 1 -> τ 2 ) Typ von f (τ 3 -> τ 1 ) Typ von g τ 3 Typ des Arguments x der Komposition f. g τ 2 Typ des Resultats der Komposition f(g x) Grundlagen der Programmierung 2 (Typen-A) 11/37
13 Typ der Komposition Erklärung zum Typ von komp, wobei {a,b,c} Typvariablen sind. Ausdruck: f komp g bzw. f. g (a->b) -> (c->a) -> c->b Typ von (.) (τ 1 -> τ 2 ) Typ von f (τ 3 -> τ 1 ) Typ von g τ 3 Typ des Arguments x der Komposition f. g τ 2 Typ des Resultats der Komposition f(g x) (τ 3 -> τ 2 ) Typ von (f. g) Grundlagen der Programmierung 2 (Typen-A) 11/37
14 Typ der Komposition Erklärung zum Typ von komp, wobei {a,b,c} Typvariablen sind. Ausdruck: f komp g bzw. f. g (a->b) -> (c->a) -> c->b Typ von (.) (τ 1 -> τ 2 ) Typ von f (τ 3 -> τ 1 ) Typ von g τ 3 Typ des Arguments x der Komposition f. g τ 2 Typ des Resultats der Komposition f(g x) (τ 3 -> τ 2 ) Typ von (f. g) x :: τ 3 g τ 1 f τ 2 Grundlagen der Programmierung 2 (Typen-A) 11/37
15 Typen von Konstruktoren Typen von Konstruktoren werden durch deren data-definition automatisch festgelegt! data Baum a b = Empty Blatt b Knoten a (Baum a b) Baum a b) Typen der Konstruktoren: Empty :: Baum a b Blatt :: b Baum a b Knoten :: b Baum a b Baum a b Baum a b Grundlagen der Programmierung 2 (Typen-A) 12/37
16 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument Beispiele: (s t) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
17 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ (s t) ::? Beispiele: Grundlagen der Programmierung 2 (Typen-A) 13/37
18 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) ::? Beispiele: Grundlagen der Programmierung 2 (Typen-A) 13/37
19 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: Grundlagen der Programmierung 2 (Typen-A) 13/37
20 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: (quadrat 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
21 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int (quadrat 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
22 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
23 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int Grundlagen der Programmierung 2 (Typen-A) 13/37
24 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int ((1 +) 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
25 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int (1 +) ::? ((1 +) 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
26 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int (1 +) ::?, 2:: Int ((1 +) 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
27 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int + :: Int (Int Int) (1 +) ::?, 2:: Int ((1 +) 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
28 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int + :: Int (Int Int), 1 :: Int (1 +) ::?, 2:: Int ((1 +) 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
29 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int + :: Int (Int Int), 1 :: Int (1 +) :: (Int Int), 2:: Int ((1 +) 2) ::? Grundlagen der Programmierung 2 (Typen-A) 13/37
30 Typregeln Wie berechnet man Typen von Ausdrücken? Anwendung von Funktionsausdruck auf Argument s :: σ τ, t :: σ (s t) :: τ Beispiele: quadrat :: Int Int, 2 :: Int (quadrat 2) :: Int + :: Int (Int Int), 1 :: Int (1 +) :: (Int Int), 2:: Int ((1 +) 2) :: Int Grundlagen der Programmierung 2 (Typen-A) 13/37
31 Typregel Anwendung : mehrere Argumente Beispiele s :: σ 1 σ 2... σ n τ, t 1 :: σ 1,..., t n :: σ n (s t 1... t n ) :: τ + :: Int Int Int, 1 :: Int, 2 :: Int (+ 1 2) :: Int + :: Int Int Int (1 + 2) :: Int Grundlagen der Programmierung 2 (Typen-A) 14/37
32 Beispiel even. quadrat ::??? Grundlagen der Programmierung 2 (Typen-A) 15/37
33 Beispiel even::int -> Bool (.)::(a -> b) -> (c -> a) -> c -> b quadrat::int -> Int even. quadrat ::??? Grundlagen der Programmierung 2 (Typen-A) 15/37
34 Beispiel even::int -> Bool (.)::(a -> b) -> ((c -> a) -> (c -> b)) quadrat::int -> Int even. quadrat ::??? Grundlagen der Programmierung 2 (Typen-A) 15/37
35 Beispiel even::int -> Bool (.)::(a -> b) -> ((c -> a) -> (c -> b)) quadrat::int -> Int a -> b. = Int -> Bool even. quadrat ::??? Grundlagen der Programmierung 2 (Typen-A) 15/37
36 Beispiel even::int -> Bool (.)::(a -> b) -> ((c -> a) -> (c -> b)) quadrat::int -> Int a -> b. = Int -> Bool c -> a. = Int -> Int even. quadrat ::??? Grundlagen der Programmierung 2 (Typen-A) 15/37
37 Beispiel even::int -> Bool (.)::(a -> b) -> ((c -> a) -> (c -> b)) quadrat::int -> Int a -> b. = Int -> Bool c. = Int; b. = Bool c -> a. = Int -> Int even. quadrat ::??? Grundlagen der Programmierung 2 (Typen-A) 15/37
38 Beispiel even::int -> Bool (.)::(a -> b) -> ((c -> a) -> (c -> b)) quadrat::int -> Int a -> b. = Int -> Bool c. = Int; b. = Bool c -> a. = Int -> Int even. quadrat :: Int -> Bool Grundlagen der Programmierung 2 (Typen-A) 15/37
39 Anwendungsregel für polymorphe Typen Ziel: Anwendung der Typregel für z.b. length oder map Neuer Begriff: γ ist eine Typsubstitution wenn sie Typen für Typvariablen einsetzt γ(τ) nennt man Instanz von τ Beispiel Typsubstitution: Instanz: γ = {a Char, b Float} γ([a] Int) = [Char] Int Grundlagen der Programmierung 2 (Typen-A) 16/37
40 Anwendungsregel für polymorphe Typen s :: σ τ, t :: ρ und γ(σ) = γ(ρ) (s t) :: γ(τ) Berechnet den Typ von (s t) wenn die Typen von s, t schon bekannt sind Hierbei ist zu beachten: Damit alle Freiheiten erhalten bleiben: die Typvariablen in ρ müssen vorher umbenannt werden, so dass σ und ρ keine gemeinsamen Typvariablen haben. Grundlagen der Programmierung 2 (Typen-A) 17/37
41 Beispiel zur polymorphen Anwendungsregel Typ von (map quadrat)? map :: (a b) ([a] [b]) quadrat :: Int Int Grundlagen der Programmierung 2 (Typen-A) 18/37
42 Beispiel zur polymorphen Anwendungsregel Typ von (map quadrat)? map :: (a b) ([a] [b]) quadrat :: Int Int Instanziiere mit: γ = {a Int, b Int} Grundlagen der Programmierung 2 (Typen-A) 18/37
43 Beispiel zur polymorphen Anwendungsregel Typ von (map quadrat)? map :: (a b) ([a] [b]) quadrat :: Int Int Instanziiere mit: ergibt: γ = {a Int, b Int} map :: (Int Int) ([Int] [Int]) Grundlagen der Programmierung 2 (Typen-A) 18/37
44 Beispiel zur polymorphen Anwendungsregel Typ von (map quadrat)? map :: (a b) ([a] [b]) quadrat :: Int Int Instanziiere mit: ergibt: γ = {a Int, b Int} map :: (Int Int) ([Int] [Int]) Regelanwendung ergibt: map :: (Int Int) ([Int] [Int]), quadrat :: (Int Int) (map quadrat) :: [Int] [Int] Grundlagen der Programmierung 2 (Typen-A) 18/37
45 Polymorphe Regel für n Argumente s :: σ 1 σ 2... σ n τ, t 1 :: ρ 1,..., t n :: ρ n und i : γ(σ i ) = γ(ρ i ) (s t 1... t n ) :: γ(τ) Die Typvariablen in ρ 1,..., ρ n müssen vorher umbenannt werden. Beachte: verwende möglichst allgemeines γ (kann berechnet werden; s.u.) Grundlagen der Programmierung 2 (Typen-A) 19/37
46 Wie berechnet man die Typsubstitutionen? Unifikation: Berechnung der allgemeinsten Typsubstitution im Typberechnungsprogramm bzw Typchecker Unifikation wird benutzt im Typchecker von Haskell! Grundlagen der Programmierung 2 (Typen-A) 20/37
47 polymorphe Typen; Unifikation s :: σ τ, t :: ρ und γ ist allgemeinster Unifikator von σ. = ρ (s t) :: γ(τ) (die Typvariablen in ρ müssen vorher umbenannt werden.) Grundlagen der Programmierung 2 (Typen-A) 21/37
48 Unifikation: Regelbasierter Algorithmus Man braucht 4 Regeln, die auf (E; G) operieren: E: Menge von Typgleichungen, G: Lösung; mit Komponenten der Form x t. Beachte: x, y ist Typvariable s i, t i, s, t sind Typen, f, g sind Typkonstruktoren Grundlagen der Programmierung 2 (Typen-A) 22/37
49 Unifikation: Die Regeln Start mit G = ; E: zu lösende Gleichung(en) G; {x. = x} E G; E G; {t. = x} E G; {x. = t} E G; {x =. t} E G[t/x] {x t}; E[t/x] G; {(f s 1... s n ). = (f t 1... t n )} E G; {s 1. = t1,..., s n. = tn )} E Wenn t keine Variable ist Wenn x nicht in t vorkommt Ersetzung: Effekt: E[t/x]: alle Vorkommen von x werden durch t ersetzt G[t/x]: jedes y s wird durch y s[t/x] ersetzt Grundlagen der Programmierung 2 (Typen-A) 23/37
50 Unifikation: Regelbasierter Algorithmus Fehlerabbruch, wenn: x. = t in E, x t und x kommt in t vor. (Occurs-Check) (f(...). = g(...) kommt in E vor und f g. (Clash) Fehlerabbruch bedeutet: nicht typisierbar Grundlagen der Programmierung 2 (Typen-A) 24/37
51 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) [a] [b] id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E Grundlagen der Programmierung 2 (Typen-A) 25/37
52 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} Grundlagen der Programmierung 2 (Typen-A) 25/37
53 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} Grundlagen der Programmierung 2 (Typen-A) 25/37
54 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } Grundlagen der Programmierung 2 (Typen-A) 25/37
55 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } Grundlagen der Programmierung 2 (Typen-A) 25/37
56 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } {a a }; {b =. a } Grundlagen der Programmierung 2 (Typen-A) 25/37
57 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } {a a }; {b =. a } Grundlagen der Programmierung 2 (Typen-A) 25/37
58 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } {a a }; {b =. a } {a a, b a }; Grundlagen der Programmierung 2 (Typen-A) 25/37
59 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } {a a }; {b =. a } {a a, b a }; {a a, b a }; Grundlagen der Programmierung 2 (Typen-A) 25/37
60 Beispiel mit Typvariablen Berechne Typ von (map id) map:: (a b) ([a] [b]) id:: a a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = (a a ): G E ; {(a b) =. (a a )} ; {a =. a, b =. a } {a a }; {b =. a } {a a, b a }; {a a, b a }; Einsetzen der Lösung γ = {a a, b a } in [a] [b] ergibt: (map id) :: ([a ] [a ]). Grundlagen der Programmierung 2 (Typen-A) 25/37
61 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) [a] [b] head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b) =. ([a ] a ): G E Grundlagen der Programmierung 2 (Typen-A) 26/37
62 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b) =. ([a ] a ): G E ; {(a b) =. ([a ] a )} Grundlagen der Programmierung 2 (Typen-A) 26/37
63 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b) =. ([a ] a ): G E ; {(a b) =. ([a ] a )} Grundlagen der Programmierung 2 (Typen-A) 26/37
64 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } Grundlagen der Programmierung 2 (Typen-A) 26/37
65 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } Grundlagen der Programmierung 2 (Typen-A) 26/37
66 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } {a [a ]}; {b =. a } Grundlagen der Programmierung 2 (Typen-A) 26/37
67 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } {a [a ]}; {b =. a } Grundlagen der Programmierung 2 (Typen-A) 26/37
68 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } {a [a ]}; {b =. a } {a [a ], b a }; Grundlagen der Programmierung 2 (Typen-A) 26/37
69 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } {a [a ]}; {b =. a } {a [a ], b a }; {a [a ], b a }; Grundlagen der Programmierung 2 (Typen-A) 26/37
70 Noch ein Beispiel Berechne Typ von (map head) map:: (a b) ([a] [b]) head:: [a] a Gesuchter Typ: γ([a] [b]) Regelanwendung benötigt Lösung γ von (a b). = ([a ] a ): G E ; {(a b) =. ([a ] a )} ; {a =. [a ], b =. a } {a [a ]}; {b =. a } {a [a ], b a }; {a [a ], b a }; Einsetzen der Lösung γ = {a [a ], b a } in [a] [b] ergibt: (map head) :: ([[a ]] [a ]). Grundlagen der Programmierung 2 (Typen-A) 26/37
71 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] ([]) :: [a] G E Grundlagen der Programmierung 2 (Typen-A) 27/37
72 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} Grundlagen der Programmierung 2 (Typen-A) 27/37
73 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} Grundlagen der Programmierung 2 (Typen-A) 27/37
74 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
75 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
76 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
77 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
78 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
79 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
80 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
81 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
82 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} {b [c], a c, d c} {[c] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
83 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} {b [c], a c, d c} {[c] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 27/37
84 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} {b [c], a c, d c} {[c] =. [c]} {b [c], a c, d c} {c =. c} Grundlagen der Programmierung 2 (Typen-A) 27/37
85 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} {b [c], a c, d c} {[c] =. [c]} {b [c], a c, d c} {c =. c} {b [c], a c, d c} {} Grundlagen der Programmierung 2 (Typen-A) 27/37
86 Beispiel (foldr (:) []) ::?? foldr :: (a -> b -> b) -> b -> [a] -> b (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b b =. c [c] [c], b =. [d]} {b [d]} {a [d] [d] =. c [c] [c]} {b [d]} {a =. c, [d] =. [c], [d] =. [c]} {b [d], a c} {[d] =. [c], [d] =. [c]} {b [d], a c} {d =. c, [d] =. [c]} {b [c], a c, d c} {[c] =. [c]} {b [c], a c, d c} {c =. c} {b [c], a c, d c} {} (foldr (:) [])::[c] [c] = γ([a] b) Grundlagen der Programmierung 2 (Typen-A) 27/37
87 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] ([]) :: [a] G E Grundlagen der Programmierung 2 (Typen-A) 28/37
88 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} Grundlagen der Programmierung 2 (Typen-A) 28/37
89 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} Grundlagen der Programmierung 2 (Typen-A) 28/37
90 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
91 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
92 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
93 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
94 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
95 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
96 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} {a [d], b [c]} {c =. [d], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
97 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} {a [d], b [c]} {c =. [d], [d] =. [c]} Grundlagen der Programmierung 2 (Typen-A) 28/37
98 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} {a [d], b [c]} {c =. [d], [d] =. [c]} {a [d], b [[d]], c [d]} {[d] =. [[d]]} Grundlagen der Programmierung 2 (Typen-A) 28/37
99 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} {a [d], b [c]} {c =. [d], [d] =. [c]} {a [d], b [[d]], c [d]} {[d] =. [[d]]} Grundlagen der Programmierung 2 (Typen-A) 28/37
100 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} {a [d], b [c]} {c =. [d], [d] =. [c]} {a [d], b [[d]], c [d]} {[d] =. [[d]]} {a [d], b [[d]], c [d]} {d =. [d]} Grundlagen der Programmierung 2 (Typen-A) 28/37
101 Beispiel. Linksfaltung: (foldl (:) [])? foldl :: (a -> b -> a) -> a -> [b] -> a (:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c] ([]) :: [a] umbenannt: [d] G E {a b a =. c [c] [c], a =. [d]} {a [d]} {[d] b [d] =. c [c] [c]} {a [d]} {[d] =. c, b =. [c], [d] =. [c]} {a [d], b [c]} {[d] =. c, [d] =. [c]} {a [d], b [c]} {c =. [d], [d] =. [c]} {a [d], b [[d]], c [d]} {[d] =. [[d]]} {a [d], b [[d]], c [d]} {d =. [d]} nicht lösbar, da d in [d] echt vorkommt (foldl (:) []) ist nicht typisierbar! Grundlagen der Programmierung 2 (Typen-A) 28/37
102 Beispiel zu Typberechnung Typ von map length map :: (a b) ([a] [b]), length :: [a ] Int (map length) ::? = γ([a] [b]) Unifiziere (a b) =. [a ] Int G E ; {(a b) =. ([a ] Int)} Grundlagen der Programmierung 2 (Typen-A) 29/37
103 Beispiel zu Typberechnung Typ von map length map :: (a b) ([a] [b]), length :: [a ] Int (map length) ::? = γ([a] [b]) Unifiziere (a b). = [a ] Int G E ; {(a b) =. ([a ] Int)} ; {a =. [a ], b =. Int} Grundlagen der Programmierung 2 (Typen-A) 29/37
104 Beispiel zu Typberechnung Typ von map length map :: (a b) ([a] [b]), length :: [a ] Int (map length) ::? = γ([a] [b]) Unifiziere (a b). = [a ] Int G E ; {(a b) =. ([a ] Int)} ; {a =. [a ], b =. Int} Grundlagen der Programmierung 2 (Typen-A) 29/37
105 Beispiel zu Typberechnung Typ von map length map :: (a b) ([a] [b]), length :: [a ] Int (map length) ::? = γ([a] [b]) Unifiziere (a b). = [a ] Int G E ; {(a b) =. ([a ] Int)} ; {a =. [a ], b =. Int} {a [a ]}; {b =. Int} Grundlagen der Programmierung 2 (Typen-A) 29/37
106 Beispiel zu Typberechnung Typ von map length map :: (a b) ([a] [b]), length :: [a ] Int (map length) ::? = γ([a] [b]) Unifiziere (a b). = [a ] Int G E ; {(a b) =. ([a ] Int)} ; {a =. [a ], b =. Int} {a [a ]}; {b =. Int} {a [a ], b Int}; Grundlagen der Programmierung 2 (Typen-A) 29/37
107 Beispiel zu Typberechnung Typ von map length map :: (a b) ([a] [b]), length :: [a ] Int (map length) ::? = γ([a] [b]) Unifiziere (a b). = [a ] Int G E ; {(a b) =. ([a ] Int)} ; {a =. [a ], b =. Int} {a [a ]}; {b =. Int} {a [a ], b Int}; Somit: (map length) :: γ([a] [b]) = [[a ]] [Int] Grundlagen der Programmierung 2 (Typen-A) 29/37
108 Beispiele zu polymorpher Typberechnung Berechne Typ der Liste [1]: 1 : Int (:) :: a [a] [a] [] :: [b] 1 : [] ::? Anwendungsregel ergibt Gleichungen: {a. = Int, [a]. = [b]} Lösung: γ = {a Int} Typ (1 : []) :: [Int] Grundlagen der Programmierung 2 (Typen-A) 30/37
109 Beispiel zu Typfehler [1, a ] hat keinen Typ: 1 : ( a : []) 1 :: Integer, [] :: [b], a :: Char (Typen der Konstanten.) (1 :) :: [Integer] [Integer] und ( a :[]) :: [Char]. Kein Typ als Resultat, denn: [Integer]. = [Char] ist nicht lösbar. Grundlagen der Programmierung 2 (Typen-A) 31/37
110 Beispiel zu Typfehler im Interpreter Prelude> [1, a ] <interactive>:1:1: No instance for (Num Char) arising from the literal 1 at <interactive>:1:1 Possible fix: add an instance declaration for (Num Char) In the expression: 1 In the expression: [1, a ] In the definition of it : it = [1, a ] Grundlagen der Programmierung 2 (Typen-A) 32/37
111 Typ eines Ausdrucks Typ von (map quadrat [1,2,3,4]) : map:: (a b) [a] [b] quadrat:: Integer Integer, und [1, 2, 3, 4] :: [Integer]. γ = {a Integer, b Integer}. Das ergibt: γ(a) = Integer, γ([a]) = [Integer], γ([b]) = [Integer]. Resultat: γ([b]) = [Integer] Grundlagen der Programmierung 2 (Typen-A) 33/37
112 Typisierung von Funktionen und Ausdrücken Kompexe Sprachkonstrukte: rekursiv definierte Funktionen Lambda-Ausdrücke, let-ausdrücke Listen-Komprehensionen. Typcheckalgorithmus von Robin Milner (in Haskell und ML) ist schnell, (i.a.) liefert allgemeinste (Milner-)Typen benutzt Unifikation (eine optimierte Variante) schlechte worst-case Komplexität: in seltenen Fällen exponentieller Zeitbedarf Liefert in seltenen Fällen nicht die allgemeinsten möglichen polymorphen Typen Grundlagen der Programmierung 2 (Typen-A) 34/37
113 Typisierung von Funktionen, Milner Satz zur Milner-Typisierung in Haskell: Sei t ein getypter Haskell-Ausdruck, ohne freie Variablen. Dann wird die Auswertung des Ausdrucks t nicht mit einem Typfehler abbrechen. Allgemeine Aussage zu starken Typsystemen Es gibt keine dynamischen Typfehler, wenn das Programm statisch korrekt getypt ist Grundlagen der Programmierung 2 (Typen-A) 35/37
114 Typisierung und Reduktion Beachte: Nach Reduktionen kann ein Ausdruck mehr Typen (bzw. einen allgemeineren Typ) haben als vor der Reduktion Grundlagen der Programmierung 2 (Typen-A) 36/37
115 Typisierung und Reduktion Beachte: Nach Reduktionen kann ein Ausdruck mehr Typen (bzw. einen allgemeineren Typ) haben als vor der Reduktion Beispiel: if 1 > 0 then [] else [1] :: [Integer] arithmetische-reduktion: if True then [] else [1] Case-Reduktion: [] :: [Integer] :: [a] Grundlagen der Programmierung 2 (Typen-A) 36/37
116 Typisierung und Reduktion weiteres Beispiel: (if 1 > 0 then foldr else foldl) :: (a -> a -> a) -> a -> [a] -> a Reduktion ergibt als Resultat: foldr:: (a -> b -> b) -> b -> [a] -> b Grundlagen der Programmierung 2 (Typen-A) 37/37
117 Typisierung und Reduktion weiteres Beispiel: (if 1 > 0 then foldr else foldl) :: (a -> a -> a) -> a -> [a] -> a Reduktion ergibt als Resultat: foldr:: (a -> b -> b) -> b -> [a] -> b der Typ ist allgemeiner geworden! Grundlagen der Programmierung 2 (Typen-A) 37/37
Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):
Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel
Grundprinzipien der funktionalen Programmierung
Grundprinzipien der funktionalen Programmierung Funktionen haben keine Seiteneffekte Eine Funktion berechnet einen Ausgabewert der nur von den Eingabewerten abhängt: 12 inputs + output 46 34 2 Nicht nur
Funktionale Programmierung
Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 2 Teil II Typen mit Werten und Ausdruck, sogar listenweise 3 Haskell Programme Programm Module ein
Funktionale Programmierung mit Haskell. Jan Hermanns
Funktionale Programmierung mit Haskell Jan Hermanns 1 Programmiersprachen imperativ deklarativ konventionell OO logisch funktional Fortran Smalltalk Prolog Lisp C Eiffel ML Pascal Java Haskell 2 von Neumann
Beispiele: (Funktionen auf Listen) (3) Bemerkungen: Die Datenstrukturen der Paare (2) Die Datenstrukturen der Paare
Beispiele: (Funktionen auf Listen) (3) Bemerkungen: 5. Zusammenhängen der Elemente einer Liste von Listen: concat :: [[a]] -> [a] concat xl = if null xl then [] else append (head xl) ( concat (tail xl))
Funktionale Programmierung ALP I. Funktionen höherer Ordnung. Teil 2 SS 2013. Prof. Dr. Margarita Esponda. Prof. Dr.
ALP I Funktionen höherer Ordnung Teil 2 SS 2013 Funktionen höherer Ordnung Nehmen wir an, wir möchten alle Zahlen innerhalb einer Liste miteinander addieren addall:: (Num a) => [a -> a addall [ = 0 addall
Übersicht. Einführung in die Funktionale Programmierung: Einleitung & Motivation. Klassifizierung von Programmiersprachen (1)
Motivation Funktionale Programmiersprachen Haskell Übersicht Einführung in die Funktionale Programmierung: Einleitung & Motivation Prof Dr. Manfred Schmidt-Schauß 1 Motivation Übersicht Programmierparadigmen
Programmierung und Modellierung
Programmierung und Modellierung Terme, Suchbäume und Pattern Matching Martin Wirsing in Zusammenarbeit mit Moritz Hammer SS 2009 2 Inhalt Kap. 7 Benutzerdefinierte Datentypen 7. Binärer Suchbaum 8. Anwendung:
Definieren Sie eine Funktion circlearea zur Berechnung der Fläche eines Kreises mit gegebenen Radius (Float).
Haskell Funktionen Definieren Sie eine Funktion circlearea zur Berechnung der Fläche eines Kreises mit gegebenen Radius (Float). circlearea :: Float -> Float circlearea radius = 2 * pi * radius^2 Definieren
Tutorium - Haskell in der Schule. Ralf Dorn - Dennis Buchmann - Felix Last - Carl Ambroselli
Tutorium - Haskell in der Schule Wer sind wir? Otto-Nagel-Gymnasium in Berlin-Biesdorf Hochbegabtenförderung und MacBook-Schule Leistungskurse seit 2005 Einführung Was ist funktionale Programmierung? Einführung
Grundlagen der Programmierung 2. Bäume
Grundlagen der Programmierung 2 Bäume Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 24. Mai 2006 Graphen Graph: Menge von Knoten undzugehörige (gerichtete oder ungerichtete)
Eine zu Grunde liegende Typdefinition beschreibt eine Struktur, die alle erlaubten Instanzen dieses Typs gemeinsam haben.
Der binäre Baum Tree Die geläufigste Datenstuktur ist der binäre Baum Tree. Dieses Beispielskript zeigt im direkten Vergleich zu anderen Sprachen den Umgang mit formalen Typparametern in CHELSEA. Wir steigen
Haskell zur Constraint-Programmierung HaL8
Haskell zur Constraint-Programmierung HaL8 Alexander Bau 2. Mai 2013 Wir benutzen eine Teilmenge von Haskell zur Spezifikation von Constraint- Systemen über Haskell-Datentypen. Ein Constraint-Compiler
Haskell. A Wild Ride. Sven M. Hallberg. sm@khjk.org. 21C3 Berlin / Bildungswerk Hamburg 20.6.2007 p. 1/36
21C3 Berlin / Bildungswerk Hamburg 20.6.2007 p. 1/36 Haskell A Wild Ride Sven M. Hallberg sm@khjk.org 21C3 Berlin / Bildungswerk Hamburg 20.6.2007 p. 2/36 Überblick Vorsichtsmaßnahmen Einführung und Sprachgrundlagen
Verträge für die funktionale Programmierung Design und Implementierung
1 Verträge für die funktionale Programmierung Design und Implementierung RALF HINZE Institut für Informatik III, Universität Bonn Römerstraße 164, 53117 Bonn, Germany Email: ralf@informatik.uni-bonn.de
Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen
Rev. 1152 1 [23] Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen Christoph Lüth & Dennis Walter Universität Bremen Wintersemester 2010/11
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine. Studienleistung
Adressen Adressen, Termine Studienleistung Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Büro und Email Raum 216, Robert-Mayer-Str. 11-15 sabel@ki.informatik.uni-frankfurt.de
Funktionale Programmierung
Schleifen 1 Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 3 Teil I Jedem Anfang wohnt ein Zauber inne 4 Über mich Diplom in Informatik in Saarbrücken
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 20. November 2006 Monaden und I/O Monade ist ein Datentyp für (sequentielle)
Proseminar: Perlen der Informatik II Haskell List comprehensions & Typklassen
Proseminar: Perlen der Informatik II Haskell List comprehensions & Typklassen Dmitriy Traytel 8. Juli 2008 Diese Ausarbeitung im Rahmen des Proseminars Perlen der Informatik II beschäftigt sich mit einigen
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen:
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen: Peano-Zahlen, Listen, Bäume Rekursive Funktionen strukturelle
Grundlagen der Informatik. Prof. Dr. Stefan Enderle NTA Isny
Grundlagen der Informatik Prof. Dr. Stefan Enderle NTA Isny 2 Datenstrukturen 2.1 Einführung Syntax: Definition einer formalen Grammatik, um Regeln einer formalen Sprache (Programmiersprache) festzulegen.
Funktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation
Grundlagen der Programm- und Systementwicklung Funktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation Technische Universität München Institut für Informatik Software &
Lösungvorschlag zum Übungsblatt 6: Software-Entwicklung I (WS 2007/08)
Prof. Dr. A. Poetzsch-Heffter Dipl.-Inform. J. O. Blech Dipl.-Inform. M. J. Gawkowski Dipl.-Inform. N. Rauch TU Kaiserslautern Fachbereich Informatik AG Softwaretechnik Lösungvorschlag zum Übungsblatt
Formale Sprachen, reguläre und kontextfreie Grammatiken
Formale Sprachen, reguläre und kontextfreie Grammatiken Alphabet A: endliche Menge von Zeichen Wort über A: endliche Folge von Zeichen aus A A : volle Sprache über A: Menge der A-Worte formale Sprache
Entwicklung eines korrekten Übersetzers
Entwicklung eines korrekten Übersetzers für eine funktionale Programmiersprache im Theorembeweiser Coq Thomas Strathmann 14.01.2011 Gliederung 1 Einleitung
Programmiersprachen: rekursives Programmieren in Haskell
Kapitel 1 Programmiersprachen: rekursives Programmieren in Haskell Das generelle Ziel dieses Teils der Vorlesung ist das Verständnis von Programmierparadigmen, insbesondere rekursive Programmierung, funktionaler
Auswahl von Klauseln und Atomen in Prolog
5.6 Prolog... ist die bekannteste Implementierung einer LP-Sprache; wurde Anfang der 1970er von Alain Colmerauer (Marseille) und Robert Kowalski (Edinburgh) entwickelt. konkretisiert den vorgestellten
Generische Record-Kombinatoren mit statischer Typprüfung
System Generische mit statischer Typprüfung Brandenburgische Technische Universität Cottbus Lehrstuhl Programmiersprachen und Compilerbau Lehrstuhlkolloquium am 13. Januar 2010 Überblick System System
Funktionale Programmierung. der direkte Weg vom Modell zum Programm
1 Funktionale Programmierung der direkte Weg vom Modell zum Programm Peter Padawitz, TU Dortmund 19. Juni 2010 2 Inhalt Modelle Bestandteile eines Modells Konstruktor- versus destruktorbasierte Modelle
1 ÜBERSETZER. Compilerbau 1
1 ÜBERSETZER 1 A.V.Aho, J.D.Ullmann: Principles of Compiler Design, Addison Wesley (1977) J.Amsterdam: Building a computer in Software, BYTE (Okt. 1985) Programming Project: A SIMPL Compiler, BYTE (Dez.
Kapitel 7: Benutzerdefinierte Datentypen
Kapitel 7: Benutzerdefinierte Datentypen Andreas Abel LFE Theoretische Informatik Institut für Informatik Ludwig-Maximilians-Universität München 10. Juni 2011 Quelle: Martin Wirsing, Benutzerdefinierte
5.2 Das All-Pairs-Shortest-Paths-Problem (APSP-Problem) Kürzeste Wege zwischen allen Knoten. Eingabe: Gerichteter Graph G =(V, E, c)
5.2 Das All-Pairs-Shortest-Paths-Problem (APSP-Problem) Kürzeste Wege zwischen allen Knoten. Eingabe: Gerichteter Graph G =(V, E, c) mit V = {1,...,n} und E {(v, w) 1 apple v, w apple n, v 6= w}. c : E!
ALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Sortieren und Suchen (Teil 1) WS 2012/2013 Suchen 8 False unsortiert 21 4 16 7 19 11 12 7 1 5 27 3 8 False sortiert 2 4 6 7 9 11 12 18 21 24 27 36 Suchen in unsortierten
Eine Einführung in die funktionale Programmierung mit Haskell
TECHNISCHE UNIVERSITÄT CAROLO-WILHELMINA ZU BRAUNSCHWEIG Übungsskript Eine Einführung in die funktionale Programmierung mit Haskell Jan Oliver Ringert, überarbeitet von Henning Basold und Christoph Szeppek
Proseminar Funktionales Programmieren. Stephan Kreutzer
Proseminar Funktionales Programmieren Die Programmiersprache LISP Stephan Kreutzer Teil I: Funktionales Programmieren Imperative Sprachen Imperative Sprachen: Befehlsorientiert Imperative Sprachen orientieren
Heutiges Thema... Datenstrukturen in Haskell... Algebraische Datentypen (data Tree =...) Typsynonyme (type Student =...)
Heutiges Thema... Datenstrukturen in Haskell... Algebraische Datentypen (data Tree =...) Typsynonyme (type Student =...) Spezialitäten (newtype State =...) Funktionale Programmierung (WS 2007/2008) / 4.
Einführung in das Programmieren Prolog Sommersemester 2006. Teil 2: Arithmetik. Version 1.0
Einführung in das Programmieren Prolog Sommersemester 2006 Teil 2: Arithmetik Version 1.0 Gliederung der LV Teil 1: Ein motivierendes Beispiel Teil 2: Einführung und Grundkonzepte Syntax, Regeln, Unifikation,
Formale Spezialisierungstechniken. am Beispiel des binären Baums. Hybride Programmiersprachen Daniel Krompass Berlin, 2009
Formale Spezialisierungstechniken am Beispiel des binären Baums. Hybride Programmiersprachen Daniel Krompass Berlin, 2009 Spezialisierungsarten (Typbeziehungen erster Art) X stellt Methoden und Eigenschaften
Tutoraufgabe 1 (Datenstrukturen in Haskell):
Prof. aa Dr. J. Giesl Programmierung WS12/13 M. Brockschmidt, F. Emmes, C. Otto, T. Ströder Allgemeine Die Hausaufgaben sollen in Gruppen von je 2 Studierenden aus der gleichen Kleingruppenübung (Tutorium)
Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at
Inhalt SWP Funktionale Programme (2. Teil) Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at Interpreter für funktionale Sprache
Sprachbeschreibung und Erweiterung
Sprachbeschreibung und Erweiterung Worte, Sprachen, reguläre Ausdrücke, Automaten, BNF, Grammatik, Syntax- Diagramme, Spracherweiterungen do, for, break, switch Formale Beschreibung von Programmiersprachen
Codes und Informationsgehalt
Aufgaben 2 Codes und Informationsgehalt Auf wie viele Dezimalziffern genau können vorzeichenlose ganze Zahlen in einem binären Code der Länge 32 bit dargestellt werden? 2 Codes und Informationsgehalt Auf
1. Probeklausur zu Programmierung 1 (WS 07/08)
Fachschaft Informatikstudiengänge Fachrichtung 6.2 Informatik Das Team der Bremser 1. Probeklausur zu Programmierung 1 (WS 07/08) http://fsinfo.cs.uni-sb.de Name Matrikelnummer Bitte öffnen Sie das Klausurheft
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
Java Generics & Collections
Java Praktikum Effizientes Programmieren (Sommersemester 2015) Dennis Reuling Agenda 1 2 3 1 / 30 Praktikum Effizientes Programmieren (Sommersemester 2015) Java Subtyping Teil 1 2 / 30 Praktikum Effizientes
1 Polymorphie (Vielgestaltigkeit)
1 Polymorphie (Vielgestaltigkeit) Problem: Unsere Datenstrukturen List, Stack und Queue können einzig und allein int-werte aufnehmen. Wollen wir String-Objekte, andere Arten von Zahlen oder andere Objekttypen
Wissensbasierte Systeme
WBS4 Slide 1 Wissensbasierte Systeme Vorlesung 4 vom 03.11.2004 Sebastian Iwanowski FH Wedel WBS4 Slide 2 Wissensbasierte Systeme 1. Motivation 2. Prinzipien und Anwendungen 3. Logische Grundlagen 4. Suchstrategien
Modul 122 VBA Scribt.docx
Modul 122 VBA-Scribt 1/5 1 Entwicklungsumgebung - ALT + F11 VBA-Entwicklungsumgebung öffnen 2 Prozeduren (Sub-Prozeduren) Eine Prozedur besteht aus folgenden Bestandteilen: [Private Public] Sub subname([byval
Fakultät Wirtschaftswissenschaft
Fakultät Wirtschaftswissenschaft Matrikelnr. Name Vorname KLAUSUR: Entwurf und Implementierung von Informationssystemen (32561) TERMIN: 11.09.2013, 14.00 16.00 Uhr PRÜFER: Univ.-Prof. Dr. Stefan Strecker
Funktionale Programmierung
Funktionale Programmierung Mitschrift von www.kuertz.name Hinweis: Dies ist kein offizielles Script, sondern nur eine private Mitschrift. Die Mitschriften sind teweilse unvollständig, falsch oder inaktuell,
BTree.dll - Balancierte und verkettete Bäume. Ecofor. BTree.dll. Realisiert mit Microsoft Visual Studio 16.04.2015 1/9
BTree.dll Realisiert mit Microsoft Visual Studio 16.04.2015 1/9 INHALT 1. Allgemein... 3 2. Class BTree1 (balanciert)... 3 3. Class BTree2 (balanciert und verkettet)... 4 4. Beschreibung BTree1 und BTree2...
Kapitel 6. Komplexität von Algorithmen. Xiaoyi Jiang Informatik I Grundlagen der Programmierung
Kapitel 6 Komplexität von Algorithmen 1 6.1 Beurteilung von Algorithmen I.d.R. existieren viele Algorithmen, um dieselbe Funktion zu realisieren. Welche Algorithmen sind die besseren? Betrachtung nicht-funktionaler
3.2 Binäre Suche. Usr/local/www/ifi/fk/menschen/schmid/folien/infovk.ppt 1
3.2 Binäre Suche Beispiel 6.5.1: Intervallschachtelung (oder binäre Suche) (Hier ist n die Anzahl der Elemente im Feld!) Ein Feld A: array (1..n) of Integer sei gegeben. Das Feld sei sortiert, d.h.: A(i)
Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?
![Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?](/thumbs/24/4200701.jpg "Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?")
Fragen f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))? Wozu evaluiert [f [ ], f [ ]]? Weiteres Beispiel: f [ ] y = [
Eine Baumstruktur sei folgendermaßen definiert. Eine Baumstruktur mit Grundtyp Element ist entweder
Programmieren in PASCAL Bäume 1 1. Baumstrukturen Eine Baumstruktur sei folgendermaßen definiert. Eine Baumstruktur mit Grundtyp Element ist entweder 1. die leere Struktur oder 2. ein Knoten vom Typ Element
Kapiteltests zum Leitprogramm Binäre Suchbäume
Kapiteltests zum Leitprogramm Binäre Suchbäume Björn Steffen Timur Erdag überarbeitet von Christina Class Binäre Suchbäume Kapiteltests für das ETH-Leitprogramm Adressaten und Institutionen Das Leitprogramm
"Alles, was einen Wert zurueckliefert, ist ein Ausdruck." Konstanten, Variablen, "Formeln" oder auch Methoden koennen Werte zurueckgeben.
Ausdruecke "Alles, was einen Wert zurueckliefert, ist ein Ausdruck." Konstanten, Variablen, "Formeln" oder auch Methoden koennen Werte zurueckgeben. Im Gegensatz zu Anweisungen; die geben keinen Wert zurueck.
Programmierung in Python
Programmierung in Python imperativ, objekt-orientiert dynamische Typisierung rapid prototyping Script-Sprache Funktionales und rekursives Programmieren P raktische Informatik 1, W S 2004/05, F olien P
Informatik Repetitorium SS 2009. Volker Jaedicke Volker.Jaedicke@web.de 0179 1322692
Informatik Repetitorium SS 2009 Volker Jaedicke Volker.Jaedicke@web.de 0179 1322692 Operatoren und Datentypen Beispiel: Anweisungen Variable int a float b int c a= a % (int) (++b-1/4) Vorher 36 3.5 c=b
Einführung in die Informatik Grammars & Parsers
Einführung in die Informatik Grammars & Parsers Grammatiken, Parsen von Texten Wolfram Burgard Cyrill Stachniss 12.1 Einleitung Wir haben in den vorangehenden Kapiteln meistens vollständige Java- Programme
Ein erstes Java-Programm
Ein erstes Java-Programm public class Rechnung { public static void main (String [] arguments) { int x, y; x = 10; y = -1 + 23 * 33 + 3 * 7 * (5 + 6); System.out.print ("Das Resultat ist "); System.out.println
Binärbäume als weiteres Beispiel für abstrakte Datentypen in PVS mit in Knoten gespeicherten Werten vom Typ T:
Binäre Bäume Binärbäume als weiteres Beispiel für abstrakte Datentypen in PVS mit in Knoten gespeicherten Werten vom Typ T: BinTree [T: TYPE]: DATATYPE empty: empty? node (key: T, left:bibtree, right:bibtree):
Haskell, eine rein funktionale Programmiersprache
Grundlegendes Typsystem Weiteres Gemeinschaft Haskell, eine rein funktionale Programmiersprache Ingo Blechschmidt Augsburger Linux-Infotag 27. März 2010 Grundlegendes Typsystem Weiteres
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK WS 11/12 Einführung in die Informatik II Übungsblatt 2 Univ.-Prof. Dr. Andrey Rybalchenko, M.Sc. Ruslán Ledesma Garza 8.11.2011 Dieses Blatt behandelt
Spracherweiterungen von C# 3.5
Microsoft Press Seitenanzahl 13 45 Spracherweiterungen von C# 3.5 Lokale Typinferenz 1213 Erweiterungsmethoden 1214 Objektinitialisierer 1216 Anonymer Typ 1217 Lambda-Ausdrücke 1218 Die Spracherweiterungen
Übungen zur Vorlesung Funktionale Programmierung. Wintersemester 2012/2013 Übungsblatt 1
Übungsblatt 1 Installieren Sie die Haskell-Platform (http://www.haskell.org/platform/) auf ihrem Rechner. Stellen Sie zudem sicher, dass ghci zu ihrer Pfadvariablen hinzugefügt wird. Unter Windows nden
CGI Programmierung mit Ha. Markus Schwarz
CGI Programmierung mit Ha Markus Schwarz Überblick Was ist funktionale Programmierung Einführung in Haskell CGI-Programmierung mit Haskell Ein etwas größeres Beispiel Was ist funktionale Programm Ein Programm
Grundlagen der Programmierung Prof. H. Mössenböck. 3. Verzweigungen
Grundlagen der Programmierung Prof. H. Mössenböck 3. Verzweigungen If-Anweisung n > 0? j n if (n > 0) x = x / n; ohne else-zweig x x / n j max x x > y? n max y if (x > y) max = x; else max = y; mit else-zweig
Deklarationen in C. Prof. Dr. Margarita Esponda
Deklarationen in C 1 Deklarationen Deklarationen spielen eine zentrale Rolle in der C-Programmiersprache. Deklarationen Variablen Funktionen Die Deklarationen von Variablen und Funktionen haben viele Gemeinsamkeiten.
Terme stehen für Namen von Objekten des Diskursbereichs (Subjekte, Objekte des natürlichsprachlichen Satzes)
Prädikatenlogik Man kann den natürlichsprachlichen Satz Die Sonne scheint. in der Prädikatenlogik beispielsweise als logisches Atom scheint(sonne) darstellen. In der Sprache der Prädikatenlogik werden
Logische Programmierung
Logische Programmierung B-82 Deklaratives Programmieren in Prädikatenlogik: Problem beschreiben statt Algorithmus implementieren (idealisiert). Grundlagen: Relationen bzw. Prädikate (statt Funktionen);
Einführung Datentypen Verzweigung Schleifen Funktionen Dynamische Datenstrukturen. Java Crashkurs. Kim-Manuel Klein (kmk@informatik.uni-kiel.
Java Crashkurs Kim-Manuel Klein (kmk@informatik.uni-kiel.de) May 7, 2015 Quellen und Editoren Internet Tutorial: z.b. http://www.java-tutorial.org Editoren Normaler Texteditor (Gedit, Scite oder ähnliche)
Programmieren in Haskell
Programmieren in Haskell Felder (Arrays) Programmieren in Haskell 1 Was wir heute machen Motivationsbeispiel Die Typklasse Ix Felder in Haskell Funktionstabellierung Binäre Suche Pascalsches Dreieck Ein
1 Syntax von Programmiersprachen
1 Syntax von Programmiersprachen Syntax ( Lehre vom Satzbau ): formale Beschreibung des Aufbaus der Worte und Sätze, die zu einer Sprache gehören; im Falle einer Programmier-Sprache Festlegung, wie Programme
Übersicht. Schleifen. Schleifeninvarianten. Referenztypen, Wrapperklassen und API. 9. November 2009 CoMa I WS 08/09 1/15
Übersicht Schleifen Schleifeninvarianten Referenztypen, Wrapperklassen und API CoMa I WS 08/09 1/15 CoMa I Programmierziele Linux bedienen Code umschreiben strukturierte Datentypen Anweisungen und Kontrollstrukturen
Gliederung. Tutorium zur Vorlesung. Gliederung. Gliederung. 1. Gliederung der Informatik. 1. Gliederung der Informatik. 1. Gliederung der Informatik
Informatik I WS 2012/13 Tutorium zur Vorlesung 1. Alexander Zietlow zietlow@informatik.uni-tuebingen.de Wilhelm-Schickard-Institut für Informatik Eberhard Karls Universität Tübingen 11.02.2013 1. 2. 1.
Übung 1 mit C# 6.0 MATTHIAS RONCORONI
Übung 1 mit C# 6.0 MATTHIAS RONCORONI Inhalt 2 1. Überblick über C# 2. Lösung der Übung 1 3. Code 4. Demo C# allgemein 3 aktuell: C# 6.0 mit.net-framework 4.6: Multiparadigmatisch (Strukturiert, Objektorientiert,
Entwurf von Algorithmen - Kontrollstrukturen
Entwurf von Algorithmen - Kontrollstrukturen Eine wichtige Phase in der Entwicklung von Computerprogrammen ist der Entwurf von Algorithmen. Dieser Arbeitsschritt vor dem Schreiben des Programmes in einer
Fortgeschrittene Programmierung
Skript zur Vorlesung Fortgeschrittene Programmierung SS 2014 Prof. Dr. Michael Hanus Priv.Doz. Dr. Frank Huch Arbeitsgruppe Programmiersprachen und Übersetzerkonstruktion Institut für Informatik Christian-Albrechts-Universität
Programmiertechnik II
Analyse von Algorithmen Algorithmenentwurf Algorithmen sind oft Teil einer größeren Anwendung operieren auf Daten der Anwendung, sollen aber unabhängig von konkreten Typen sein Darstellung der Algorithmen
Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 11 (Kapitel 12)
Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 11 (Kapitel 12) Hinweis: Dieses Übungsblatt enthält
Kostenmaße. F3 03/04 p.188/395
Kostenmaße Bei der TM nur ein Kostenmaß: Ein Schritt (Konfigurationsübergang) kostet eine Zeiteinheit; eine Bandzelle kostet eine Platzeinheit. Bei der RAM zwei Kostenmaße: uniformes Kostenmaß: (wie oben);
Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen
Was bisher geschah Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen Syntax: Signatur Semantik: Axiome (FOL-Formeln, meist
Klassenbeziehungen & Vererbung
Klassenbeziehungen & Vererbung VL Objektorientierte Programmierung Raimund Kirner teilweise nach Folien von Franz Puntigam, TU Wien Überblick Arten von Klassenbeziehungen Untertypen versus Vererbung in
Grundlagen. Die Komponenten eines C Programms. Das erste Programm
Grundlagen 1. Die Komponenten eines C Programms 2. Ein Programm erzeugen und übersetzen 3. Variablen Deklarieren und Werte zuweisen 4. Zahlen eingeben mit der Tastatur 5. Arithmetische Ausdrücke und Berechnungen
SOI 2013. Die Schweizer Informatikolympiade
SOI Die Schweizer Informatikolympiade Lösung SOI Wie schreibe ich eine gute Lösung? Bevor wir die Aufgaben präsentieren, möchten wir dir einige Tipps geben, wie eine gute Lösung für die theoretischen
Praktikum BKSPP. Aufgabenblatt Nr. 1. 1 Umrechnung zwischen Stellenwertsystemen
Dr. David Sabel Institut für Informatik Fachbereich Informatik und Mathematik Johann Wolfgang Goethe-Universität Frankfurt am Main Praktikum BKSPP Sommersemester 21 Aufgabenblatt Nr. 1 Abgabe: Mittwoch,
Kapitel 12: Übersetzung objektorienter Konzepte
Kapitel 12: Übersetzung objektorienter Konzepte Themen Klassendarstellung und Methodenaufruf Typüberprüfung Klassenhierarchieanalyse Escape Analyse 12.1 Klassendarstellung bei Einfachvererbung class Punkt
Ausarbeitung des Interpreter Referats
Ausarbeitung des Interpreter Referats Gliederung 1. Programmiersprache 1.2. Syntax 1.2.1. Konkrete Syntax 1.2.2. Abstrakter Syntax Baum (Abstrakte Syntax) 2. Parser 2.1. Syntaktische Struktur einer Sprache
Mächtigkeit von WHILE-Programmen
Mächtigkeit von WHILE-Programmen Prof. Dr. Berthold Vöcking Lehrstuhl Informatik 1 Algorithmen und Komplexität RWTH Aachen 26. November 2009 Berthold Vöcking, Informatik 1 () Vorlesung Berechenbarkeit
2: Zahlentheorie / Restklassen 2.1: Modulare Arithmetik
Stefan Lucks Diskrete Strukturen (WS 2009/10) 57 2: Zahlentheorie / Restklassen 2.1: Modulare Arithmetik Uhr: Stunden mod 24, Minuten mod 60, Sekunden mod 60,... Rechnerarithmetik: mod 2 w, w {8, 16, 32,
Kapitel 3: Programmierung mit Kombinatoren
Funktionale Programmierung (WS2005/2006) 3/1 Kapitel 3: Programmierung mit Kombinatoren Lernziele dieses Kapitels 1. Denken in unktionalen Komponenten, Vermeidung von Kontrolllussdenken (Rekursion) Details
Java 7. Elmar Fuchs Grundlagen Programmierung. 1. Ausgabe, Dezember 2011 JAV7
Java 7 Elmar Fuchs Grundlagen Programmierung 1. Ausgabe, Dezember 2011 JAV7 5 Java 7 - Grundlagen Programmierung 5 Kontrollstrukturen In diesem Kapitel erfahren Sie wie Sie die Ausführung von von Bedingungen
Grundlagen der Programmierung 2. Parallele Verarbeitung
Grundlagen der Programmierung 2 Parallele Verarbeitung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 27. Mai 2009 Parallele Algorithmen und Ressourcenbedarf Themen: Nebenläufigkeit,
7down Zusatzaufgaben. Mathias Ziebarth und Joachim Breitner. 13. März 2008
7down Zusatzaufgaben Mathias Ziebarth und Joachim Breitner 13. März 2008 1 Problem 1 Unser Programm hat folgende Lösungen berechnet: Testfall 1 153131 141441 973493 330529 869017 876927 Testfall 2 279841
Tutorium Rechnerorganisation
Woche 2 Tutorien 3 und 4 zur Vorlesung Rechnerorganisation 1 Christian A. Mandery: KIT Universität des Landes Baden-Württemberg und nationales Grossforschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu