Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen Mark 1 und Mark 2
|
|
|
- Damian Sachs
- vor 5 Jahren
- Abrufe
Transkript
1 Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen und Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009
2 Zeitplan Teil 3 Meilenstein 1 Teil 1: Lexen und Parsen Teil 2: Semantische Analyse und Transformation Teil 3: Abstrakte Maschinen und Meilenstein 3 Teil 5: Nebenläufigkeit: Concurrent Teil 6: Codeerzeugung, Compiler, Interpreter und VM Teil 7: Verbesserungen: Garbage Collection 27. April (2 Wochen) 4. Mai (1 Woche) 1. Juni (4 Wochen) 22. Juni (3 Wochen) 6. Juli (2 Wochen) 13. Juli (1 Woche) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
3 Teil 3 Teil 3: Abstrakte Maschinen und Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
4 und Teil 3 Quelle Die Maschinen basieren im Wesentlichen auf: Peter Sestoft: Deriving a lazy abstract machine Journal of Functional Programming, 7(3): , Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
5 Zustand der Maschine Startzustand / Endzustand Zustandsübergang Datenstrukturen (Γ, e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
6 Zustand der Maschine Startzustand / Endzustand Zustandsübergang Datenstrukturen (Γ, e, S) Heap, der eine Abbildung von Variablennamen auf Ausdrücke ist. aktuell auszuwertender CoreLFPCR- Ausdruck Stack Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
7 Startzustand Startzustand / Endzustand Zustandsübergang Datenstrukturen Wenn e der auszuwertende CoreLFPCR-Ausdruck, dann starte mit (, e, []) wobei := leerer Heap [] := leerer Stack Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
8 Endzustand Startzustand / Endzustand Zustandsübergang Datenstrukturen Ein Endzustand ist von der Form (Γ, v, []) wobei v eine Konstruktorapplikation, oder eine Abstraktion Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
9 Zustandsübergang Startzustand / Endzustand Zustandsübergang Datenstrukturen (Γ, (e p), S) push (Γ, e, # app (p) : S) (Γ, λy -> e, # app (p) : S) take (Γ, e[p/y], S) (Γ, (seq e 1 e 2 ), S) pushseq (Γ, e, # seq (e 2 ) : S) (Γ, v, # seq (e) : S) takeseq (Γ, e, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p e}, p, S) enter (Γ, e, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
10 Zustandsübergang (2) Startzustand / Endzustand Zustandsübergang Datenstrukturen (Γ, letrec x 1 = e 1,..., x n = e n in e, S) mkbinds (Γ n {p i ê i }, ê, S) wobei p 1,..., p n neue Pointer sind, d.h. weder in S noch in Γ vorkommen, ê i = e i [p 1 /x 1,... p n /x n ] und ê = e[p 1 /x 1,... p n /x n ] i=1 (Γ, case e of alts, S) pushalts (Γ, e, # case (alts) : S) (Γ, c k,a p 1... p a, # heap (p) : S) update2 (Γ {p c k,a p 1... p a }, c k,a p 1... p a, S) (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) wobei c k,a y 1... y a -> e die k-te Alternative in alts ist Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
11 Zustandsübergang (3) Startzustand / Endzustand Zustandsübergang Datenstrukturen (Γ, p, S) blackhole (Γ, p, S) falls für p keine Bindung in Γ (Γ, c k,a p 1... p a, # app (p) : S) blackhole2 (Γ, c k,a p 1... p a, # app (p) : S) (Γ, λy -> e, # case (alts) : S) blackhole3 (Γ, λy -> e, # case (alts) : S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
12 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen Startzustand Heap: Ausdruck: letrec tail =... bot = bot in ( letrec x 1 = True, x 2 = [], x 3 = (x 1 : x 2), x 4 = (x 1 : x 3) in tail x 4) Stack: [] Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
13 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (1) mkbinds { } p1... [p Heap: 1 /tail, p 2 /bot], p 2 p 2 Ausdruck: (letrec x 1 = True, x 2 = [], x 3 = (x 1 : x 2), x 4 = (x 1 : x 3) in p 1 x 4) Stack: [] Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
14 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (2) mkbinds Heap: Ausdruck: p 1 p 6 Stack: [] 8 p 1... [p 1/tail, p 2/bot], p 2 p 2, >< p 3 True[p 3/x 1, p 4/x 2, p 5/x 3.p 6/x 4] = True, p 4 [][p 3/x 1, p 4/x 2, p 5/x 3.p 6/x 4] = [], p 5 (x 1 : x 2)[p 3/x 1, p 4/x 2, p 5/x 3.p 6/x 4] = (p 3 : p 4), >: p 6 (x 1 : x 3)[p 3/x 1, p 4/x 2, p 5/x 3.p 6/x 4] = (p 3 : p 5) 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
15 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (3) push Heap: 8 p 1... [p 1/tail, p 2/bot], p 2 p 2, >< p 3 True, p 4 [], p 5 (p 3 : p 4), >: p 6 (p 3 : p 5) Ausdruck: p 1 Stack: # app (p 6 ) : [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
16 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (4) enter Heap: 8 9 p 2 p 2, >< p 3 True, >= p 4 [], p 5 (p 3 : p 4), >: >; p 6 (p 3 : p 5) Ausdruck: \xs -> case xs of{ [] -> [], (a : as) -> as, True -> p 2, False -> p 2, One -> p 2, Zero -> p 2, (x, y) -> p 2, c, d -> p 2}, Stack: # heap (p 1 ) : # app (p 6 ) : [] Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
17 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (5) update Heap: 8 p 1 \xs -> case xs of alts p 2 p 2, >< p 3 True, p 4 [], p 5 (p 3 : p 4), >: p 6 (p 3 : p 5) Ausdruck: \xs -> case xs of{ [] -> [], (a : as) -> as, True -> p 2, False -> p 2, One -> p 2, Zero -> p 2, (x, y) -> p 2, c, d -> p 2}, Stack: # app (p 6 ) : [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
18 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (6) take 8 p 1 \xs -> case xs of alts p 2 p 2, >< p Heap: 3 True, p 4 [], p 5 (p 3 : p 4), >: p 6 (p 3 : p 5) Ausdruck: case p 6 of{ [] -> [], (a : as) -> as, True -> p 2, False -> p 2, One -> p 2, Zero -> p 2, (x, y) -> p 2, c, d -> p 2}, Stack: [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
19 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (7) pushalts Heap: Ausdruck: p 6 Stack: 8 p 1 \xs -> case xs of alts p 2 p 2, >< p 3 True, p 4 [], p 5 (p 3 : p 4), >: p 6 (p 3 : p 5) # case 8 >< >: [] -> [], (a : as) -> as, True -> p 2, False -> p 2, One -> p 2, Zero -> p 2, (x, y) -> p 2, c, d -> p 2 9 >= >; : [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
20 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (8) enter Heap: 8 9 p 1 \xs -> case xs of alts >< p 2 p 2, >= p 3 True, p 4 [], >: >; p 5 (p 3 : p 4), Ausdruck: (p 3 : p 5 ) Stack: # heap (p 6 ) :# case 8 >< >: [] -> [], (a : as) -> as, True -> p 2, False -> p 2, One -> p 2, Zero -> p 2, (x, y) -> p 2, c, d -> p 2 9 >= >; : [] Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
21 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (9) update2 Heap: 8 p 1 \xs -> case xs of alts p 2 p 2, >< p 3 True, p 4 [], p 5 (p 3 : p 4), >: p 6 (p 3 : p 5) Ausdruck: (p 3 : p 5 ) Stack: # case 8 >< >: [] -> [], (a : as) -> as, True -> p 2, False -> p 2, One -> p 2, Zero -> p 2, (x, y) -> p 2, c, d -> p 2 9 >= >; : [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
22 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (10) branch Heap: 8 p 1 \xs -> case xs of alts p 2 p 2, >< p 3 True, p 4 [], p 5 (p 3 : p 4), >: p 6 (p 3 : p 5) Ausdruck: as[p 3 /a, p 5 /as] = p 5 Stack: [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
23 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (11) enter Heap: 8 p 1 \xs -> case xs of alts >< p 2 p 2, p 3 True, p 4 [], >: p 6 (p 3 : p 5) Ausdruck: (p 3 : p 4 ) Stack: [# heap (p 5 )] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
24 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen (12) update2 Heap: 8 p 1 \xs -> case xs of alts p 2 p 2, >< p 3 True, p 4 [], p 6 (p 3 : p 5), >: p 5 (p 3 : p 4) Ausdruck: (p 3 : p 4 ) Stack: [] 9 >= >; Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
25 Beispiel Startzustand / Endzustand Zustandsübergang Datenstrukturen So sollte es aussehen > runmark1 "letrec tail = \\xs -> case xs of {[] -> [], (a:as) -> as} in (tail (True:True:[]))" "(True:[])" Zum Ausdrucken des Ergebnisses Man muss die Maschine nach dem ersten stoppen mit den Argumenten von : erneut aufrufen Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
26 Heap Startzustand / Endzustand Zustandsübergang Datenstrukturen type Heap p e =... (Datenstruktur selbst wählen.) polymorph über den Heapvariablen p und rechten Seiten e Operationen: emptyheap :: Heap p e liefert leeren Heap lookupheap :: p -> Heap p e -> Maybe (e, Heap p e) sucht nach dem Eintrag für p in einem Heap, und nimmt ihn vom Heap weg. Ergebnis: bei Erfolg: Just (rechte Seite, modifizierter Heap) sonst: Nothing insertheap :: p -> e -> Heap p e -> Heap p e erhält: Heapvariable, Eintrag, alten Heap liefert: neuen Heap. Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
27 Stack Startzustand / Endzustand Zustandsübergang Datenstrukturen type Stack a =... (Datenstruktur selbst wählen.) polymorph über den Einträgen colorbluea Operationen: emptystack :: Stack a liefert leeren Stack isemptystack :: Stack a -> Bool prüft, ob der Stack leer ist push :: a -> Stack a -> Stack a erhält Element und Stack und legt das Element oben auf den Stack pop :: Stack a -> (a, Stack a) erhält Stack und liefert Paar bestehend aus oberstem Element und Reststack Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
28 Stackelemente Startzustand / Endzustand Zustandsübergang Datenstrukturen data StackElem v a b = RetApp v RetHeap v RetCase a RetSeq b polymorph über den Variablen v den Alternativen a und den Ausdrücken colorblueb Operationen: isretapp :: StackElem v a b -> Bool: Ist Stack-Element ein RetApp? isretheap :: StackElem v a b -> Bool: Ist Stack-Element ein RetHeap? isretcase :: StackElem v a b -> Bool: Ist Stack-Element ein RetCase? isretseq :: StackElem v a b -> Bool: Ist Stack-Element ein RetSeq? mkretheap :: v -> StackElem v a b: Erstelle aus Variable ein RetHeap. mkretapp :: v -> StackElem v a b: Erstelle aus Variable ein RetApp. mkretcase :: a -> StackElem v a b: Erstelle ein RetCase. mkretseq :: b -> StackElem v a b: Erstelle ein RetSeq fromvar :: StackElem v a b -> v: Aus RetApp, RetHeap die Variable rausholen. fromretcase :: StackElem v a b -> a: Aus RetCase die Alternativen rausholen. fromretseq :: StackElem v a b -> b: Aus RetSeq den Ausdruck rausholen Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
29 Substitution von Variablen Startzustand / Endzustand Zustandsübergang Datenstrukturen Wir benötigt für take, mkbinds und branch substitute :: CoreLFPCR -> Var -> Var -> CoreLFPCR erhält einen Ausdruck und zwei Variablen und ersetzt alle Vorkommen der ersten Variablen durch die zweite Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
30 Zustand der Maschine Startzustand / Endzustand Zustandsübergang Datenstrukturen data Mark1State = Mark1State {heap :: Heap Var CoreLFPCR, control :: CoreLFPCR, stack :: (Stack (StackElem Var [Alt] CoreLFPCR))} Achtung: Record-Syntax! Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
31 Operationen auf dem Zustand Startzustand / Endzustand Zustandsübergang Datenstrukturen startstate :: CoreLFPCR -> Mark1State Startzustand ausgehend vom Ausdruck berechnen nextstate :: Mark1State -> [Var] -> (Mark1State, [Var]) Folgezustand berechnen. Liste neuer Variablennamen wird benötigt bei mkbinds! Ergebnis: (Folgezustand, nicht benutzte Variablennamen) finalstate :: Mark1State -> [Var] -> (Mark1State, [Var]) Endzustand berechnen: solange nextstate anwenden bis man in einem Endzustand angelangt ist. exec :: CoreLFPCR -> [Var] -> String Für einen Ausdruck die Maschine laufen lassen, das Ergebnis als String zurückliefen. 1 Startzustand berechnen 2 Endzustand berechnen 3 Falls Ergebnisausdruck noch Heapvariablen enthält, mit diesen die Maschine weiterlaufen lassen. Dabei: Zahlen, Listen, Paare in lesbare Darstellung konvertieren! Deswegen brauchen wir die speziellen Paare für die Zahlen: Sonst wüssten wir nicht, ob es eine normales Paar oder eine Zahl ist! Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
32 Im Modul LFPC.Run Startzustand / Endzustand Zustandsübergang Datenstrukturen runmark1,erhält deterministisches LFP +C -Programm und 1 lext das Programm 2 übergibt die Token dem Parser 3 unterzieht das CoreLFPC-Programm der semantischen Analyse 4 konvertiert in CoreLFPCR 5 den Ausdruck auf der laufen lässt und als Ergebnis den String liefert. Lauffähiger Interpreter für deterministische Programme Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
33 Startzustand / Endzustand Zustandsübergang Datenstrukturen Teil 4 (4 Wochen) Aufgabe 6: Datenstruktur Heap mit Operationen Aufgabe 7: Datenstruktur Stack mit Operationen Aufgabe 8: Operationen auf StackElem Aufgabe 9: Variablen-Subsitution Aufgabe 10: Mark1: startstate, nextstate, finalstate, exec Aufgabe 11: runmark1 Aufgabe 12: Environment mit Operationen Aufgabe 13: Mark2: startstate, nextstate, finalstate Aufgabe 14: runmark2 Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
34 Ineffizienz der Zustand Start- und Endzustände Übergangsrelation (Γ, λy -> e, # app (p) : S) take (Γ, e[p/y], S) (Γ, letrec x 1 = e 1,..., x n = e n in e, S) mkbinds (Γ n {p i ê i }, ê, S) i=1 wobei p 1,..., p n neue Pointer sind ê i = e i [p 1 /x 1,... p n /x n ] und ê = e[p 1 /x 1,... p n /x n ] (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
35 Ineffizienz der Zustand Start- und Endzustände Übergangsrelation (Γ, λy -> e, # app (p) : S) take (Γ, e[p/y], S) (Γ, letrec x 1 = e 1,..., x n = e n in e, S) mkbinds (Γ n {p i ê i }, ê, S) i=1 wobei p 1,..., p n neue Pointer sind ê i = e i [p 1 /x 1,... p n /x n ] und ê = e[p 1 /x 1,... p n /x n ] (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) Nachteile Substitutionen: Zeitintensiv und z.t. unnötig, wenn die substituierte Variable gar nicht vorkommt, wird trotzdem der Term durchlaufen. Heapvariablen und Programmvariablen müssen vom gleichen Typ sein! Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
36 Maschine Zustand Start- und Endzustände Übergangsrelation Zustand der (Γ, e, S) Heap CoreLFPCR- Ausdruck Stack Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
37 Maschine Zustand Start- und Endzustände Übergangsrelation Zustand der (Γ, e, E, S) Heap CoreLFPCR- Ausdruck Umgebung (Environment) Stack Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
38 Umgebung Zustand Start- und Endzustände Übergangsrelation Verzögern die Substitutionen Es wird nur dann substituiert, wenn es nötig ist Abbildung von Programmvariablen auf Heapvariablen Programmvariablen vom Typ Var (= String) : Heapvariablen sind Zahlen vom Typ Integer Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
39 Umgebung Zustand Start- und Endzustände Übergangsrelation Verzögern die Substitutionen Es wird nur dann substituiert, wenn es nötig ist Abbildung von Programmvariablen auf Heapvariablen Programmvariablen vom Typ Var (= String) : Heapvariablen sind Zahlen vom Typ Integer Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
40 Start- und Endzustand Zustand Start- und Endzustände Übergangsrelation Startzustand für Ausdruck e: (, e,, []) Endzustände (Γ, v, E, []) wobei v Abstraktion oder Konstruktorapplikation Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
41 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e p), S) push (Γ, e, # app (p) : S) (Γ, λy -> e, # app (p) : S) take (Γ, e[p/y], S) (Γ, (seq e 1 e 2 ), S) pushseq (Γ, e, # seq (e 2 ) : S) (Γ, v, # seq (e) : S) takeseq (Γ, e, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p e}, p, S) enter (Γ, e, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
42 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e x), E {x p}, S) push (Γ, e, E {x p}, # app (p) : S) (Γ, λy -> e, # app (p) : S) take (Γ, e[p/y], S) (Γ, (seq e 1 e 2 ), S) pushseq (Γ, e, # seq (e 2 ) : S) (Γ, v, # seq (e) : S) takeseq (Γ, e, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p e}, p, S) enter (Γ, e, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
43 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e x), E {x p}, S) push (Γ, e, E {x p}, # app (p) : S) (Γ, λy -> e, E, # app (p) : S) take (Γ, e, E {y p}, S) (Γ, (seq e 1 e 2 ), S) pushseq (Γ, e, # seq (e 2 ) : S) (Γ, v, # seq (e) : S) takeseq (Γ, e, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p e}, p, S) enter (Γ, e, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
44 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e x), E {x p}, S) push (Γ, e, E {x p}, # app (p) : S) (Γ, λy -> e, E, # app (p) : S) take (Γ, e, E {y p}, S) (Γ, seq e 1 e 2, E, S) pushseq (Γ, e 1, E, # seq (e 2, E) : S) (Γ, v, # seq (e) : S) takeseq (Γ, e, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p e}, p, S) enter (Γ, e, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
45 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e x), E {x p}, S) push (Γ, e, E {x p}, # app (p) : S) (Γ, λy -> e, E, # app (p) : S) take (Γ, e, E {y p}, S) (Γ, seq e 1 e 2, E, S) pushseq (Γ, e 1, E, # seq (e 2, E) : S) (Γ, v, E, # seq (e, E ) : S) takeseq (Γ, e, E, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p e}, p, S) enter (Γ, e, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
46 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e x), E {x p}, S) push (Γ, e, E {x p}, # app (p) : S) (Γ, λy -> e, E, # app (p) : S) take (Γ, e, E {y p}, S) (Γ, seq e 1 e 2, E, S) pushseq (Γ, e 1, E, # seq (e 2, E) : S) (Γ, v, E, # seq (e, E ) : S) takeseq (Γ, e, E, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p (e, E )}, x, E {x p}, S) enter (Γ, e, E, # heap (p) : S) (Γ, λy -> e, # heap (p) : S) update (Γ {p λy -> e}, λy -> e, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
47 Zustand Start- und Endzustände Übergangsrelation Zustandsübergang: Von zu (Γ, (e x), E {x p}, S) push (Γ, e, E {x p}, # app (p) : S) (Γ, λy -> e, E, # app (p) : S) take (Γ, e, E {y p}, S) (Γ, seq e 1 e 2, E, S) pushseq (Γ, e 1, E, # seq (e 2, E) : S) (Γ, v, E, # seq (e, E ) : S) takeseq (Γ, e, E, S) wenn v ein Wert ist, d.h. v = (λy -> e ) oder v = (c k,a p 1... p a ) (Γ {p (e, E )}, x, E {x p}, S) enter (Γ, e, E, # heap (p) : S) (Γ, λy -> e, E, # heap (p) : S) update (Γ {p (λy -> e, E)}, λy -> e, E, S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
48 Zustandsübergang (2) Zustand Start- und Endzustände Übergangsrelation (Γ, letrec x 1 = e 1,..., x n = e n in e, S) mkbinds (Γ n {p i ê i }, ê, S) wobei p 1,..., p n neue Pointer sind, d.h. weder in S noch in Γ vorkommen, ê i = e i [p 1 /x 1,... p n /x n ] und ê = e[p 1 /x 1,... p n /x n ] i=1 (Γ, case e of alts, S) pushalts (Γ, e, # case (alts) : S) (Γ, c k,a p 1... p a, # heap (p) : S) update2 (Γ {p c k,a p 1... p a }, c k,a p 1... p a, S) (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) wobei c k,a y 1... y a -> e die k-te Alternative in alts ist Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
49 Zustandsübergang (2) Zustand Start- und Endzustände Übergangsrelation (Γ, letrec x 1 = e 1,..., x n = e n in e, E, S) mkbinds (Γ n {p i (e i, Ê)}, e, Ê, S) wobei Ê = E {x 1 p 1,... x n p n } und p 1,..., p n neue Pointer sind, d.h. weder in S noch in Γ vorkommen i=1 (Γ, case e of alts, S) pushalts (Γ, e, # case (alts) : S) (Γ, c k,a p 1... p a, # heap (p) : S) update2 (Γ {p c k,a p 1... p a }, c k,a p 1... p a, S) (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) wobei c k,a y 1... y a -> e die k-te Alternative in alts ist Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
50 Zustandsübergang (2) Zustand Start- und Endzustände Übergangsrelation (Γ, letrec x 1 = e 1,..., x n = e n in e, E, S) mkbinds (Γ n {p i (e i, Ê)}, e, Ê, S) wobei Ê = E {x 1 p 1,... x n p n } und p 1,..., p n neue Pointer sind, d.h. weder in S noch in Γ vorkommen (Γ, case e of alts, E, S) pushalts (Γ, e, E, # case (alts, E) : S) i=1 (Γ, c k,a p 1... p a, # heap (p) : S) update2 (Γ {p c k,a p 1... p a }, c k,a p 1... p a, S) (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) wobei c k,a y 1... y a -> e die k-te Alternative in alts ist Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
51 Zustandsübergang (2) Zustand Start- und Endzustände Übergangsrelation (Γ, letrec x 1 = e 1,..., x n = e n in e, E, S) mkbinds (Γ n {p i (e i, Ê)}, e, Ê, S) wobei Ê = E {x 1 p 1,... x n p n } und p 1,..., p n neue Pointer sind, d.h. weder in S noch in Γ vorkommen (Γ, case e of alts, E, S) pushalts (Γ, e, E, # case (alts, E) : S) i=1 (Γ, c k,a x 1... x a, E, # heap (p) : S) update2 (Γ {p (c k,a x 1... x a, E)}, c k,a x 1... x a, E, S) (Γ, c k,a p 1... p a, # case (alts) : S) branch (Γ, e[p 1 /y 1,..., p a /y a ], S) wobei c k,a y 1... y a -> e die k-te Alternative in alts ist Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
52 Zustandsübergang (2) Zustand Start- und Endzustände Übergangsrelation (Γ, letrec x 1 = e 1,..., x n = e n in e, E, S) mkbinds (Γ n {p i (e i, Ê)}, e, Ê, S) wobei Ê = E {x 1 p 1,... x n p n } und p 1,..., p n neue Pointer sind, d.h. weder in S noch in Γ vorkommen (Γ, case e of alts, E, S) pushalts (Γ, e, E, # case (alts, E) : S) i=1 (Γ, c k,a x 1... x a, E, # heap (p) : S) update2 (Γ {p (c k,a x 1... x a, E)}, c k,a x 1... x a, E, S) (Γ, c k,a x 1... x a, E, # case (alts, E ) : S) branch (Γ, e, Ê, S) wobei c k,a y 1... y a -> e die k-te Alternative in alts ist und Ê = E a i=1 {y i E(x i )} Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
53 Zustandsübergang (3) Zustand Start- und Endzustände Übergangsrelation (Γ, p, S) blackhole (Γ, p, S) falls für p keine Bindung in Γ (Γ, c k,a p 1... p a, # app (p) : S) blackhole2 (Γ, c k,a p 1... p a, # app (p) : S) (Γ, λy -> e, # case (alts) : S) blackhole3 (Γ, λy -> e, # case (alts) : S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
54 Zustandsübergang (3) Zustand Start- und Endzustände Übergangsrelation (Γ, x, E {x p}, S) blackhole (Γ, x, E {x p}, S) falls für p keine Bindung in Γ (Γ, c k,a p 1... p a, # app (p) : S) blackhole2 (Γ, c k,a p 1... p a, # app (p) : S) (Γ, λy -> e, # case (alts) : S) blackhole3 (Γ, λy -> e, # case (alts) : S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
55 Zustandsübergang (3) Zustand Start- und Endzustände Übergangsrelation (Γ, x, E {x p}, S) blackhole (Γ, x, E {x p}, S) falls für p keine Bindung in Γ (Γ, c k,a x 1... x a, E, # app (p) : S) blackhole2 (Γ, c k,a x 1... x a, E, # app (p) : S) (Γ, λy -> e, # case (alts) : S) blackhole3 (Γ, λy -> e, # case (alts) : S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
56 Zustandsübergang (3) Zustand Start- und Endzustände Übergangsrelation (Γ, x, E {x p}, S) blackhole (Γ, x, E {x p}, S) falls für p keine Bindung in Γ (Γ, c k,a x 1... x a, E, # app (p) : S) blackhole2 (Γ, c k,a x 1... x a, E, # app (p) : S) (Γ, λy -> e, E, # case (alts, E ) : S) blackhole3 (Γ, λy -> e, E, # case (alts, E ) : S) Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
57 Aufgaben Zustand Start- und Endzustände Übergangsrelation Aufgabe 12 Implementieren Sie im Modul LFPC.AbsM.Environment einen polymorphen Datentypen Environment a b, der eine Abbildung von Werten des Types a auf Werte des Types b darstellt. Implementieren Sie die Operationen Erzeugen einer leeren Umgebung emptyenv :: Environment a b Nachschauen: lookupenv :: a -> Environment a b -> b : Einfügen insertenv :: a -> b -> Environment a b -> Environment a b Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
58 Zustand Start- und Endzustände Übergangsrelation Zustand der Implementierung type Mark2Environment = (Environment Var Integer) type Mark2Stack = Stack (StackElem Integer ([Alt], Mark2Environment) (CoreLFPCR,Mark2Environment) ) data Mark2State = Mark2State { heap :: Heap Integer (CoreLFPCR, Mark2Environment), control :: CoreLFPCR, stack :: Mark2Stack, environment :: Mark2Environment } Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
59 Aufgaben Zustand Start- und Endzustände Übergangsrelation Aufgabe 12 Implementieren Sie im Modul LFPC.AbsM.Environment einen polymorphen Datentypen Environment a b, der eine Abbildung von Werten des Types a auf Werte des Types b darstellt. Implementieren Sie die Operationen Erzeugen einer leeren Umgebung emptyenv :: Environment a b Nachschauen: lookupenv :: a -> Environment a b -> b Einfügen: insertenv :: a -> b -> Environment a b -> Environment a b Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
60 Aufgaben Zustand Start- und Endzustände Übergangsrelation Aufgabe 13 Implementieren Sie im Modul LFPC.Abs.Mark2 die folgenden Funktionen: Anfangszustand berechnen: startstate :: CoreLFPCR -> Mark2State Folgezustand berechnen: nextstate :: Mark2State -> Counter -> (Mark2State,Counter) wobei Counter (zum Generieren neuer Heapvariablen) definiert ist als type Counter = Integer Endzustand berechnen: finalstate :: Mark2State -> Counter -> (Mark2State, Counter) Ausführen: exec :: CoreLFPCR -> Counter -> String Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
61 Aufgaben Zustand Start- und Endzustände Übergangsrelation Aufgabe 14 Implementieren Sie im Modul LFPC.Run eine Funktion runmark2, die ein deterministisches LFP +C -Programm erwartet, dann das Programm lext, parst, der semantischen Analyse unterzieht, in CoreLFPCR umwandelt, schließlich auf der -Maschine laufen lässt und das Ergebnis als String zurück liefert. Professur KIST, SoSe 2009, 4. Mai Praktikum Funktionale Programmierung, Teil 3
Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen
Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen Dr. David Sabel Sommersemester 2015 Stand der Folien: SoSe 2015 Übersicht FP-PR Teil 3: Abstrakte Maschinen Sommersemester 2015 D. Sabel
Praktikum Funktionale Programmierung Teil 5: Codeerzeugung, Compiler, Interpreter und VM
Praktikum Funktionale Programmierung Teil 5: Codeerzeugung, Compiler, Interpreter und VM Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009 Zeitplan Teil 5 Meilenstein 1 Teil
Praktikum Funktionale Programmierung 10. Besprechung
Praktikum Funktionale Programmierung 10. Besprechung Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2007 Meilenstein 3 Teil 6: Codeerzeugung, Compiler, Interpreter und VM 9.
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009 Überblick Teil 1: Lexen und Parsen Die Sprache LFP +C Professur
Funktionale Programmierung
Praktikum: Funktionale Programmierung Anleitung zum Praktikum Sommersemester 2007 Stand vom: 4. Juni 2007 Professur für Künstliche Intelligenz und Softwaretechnologie Institut für Informatik Johann Wolfgang
Praktikum Funktionale Programmierung Teil 2: Typecheck und Transformation
Praktikum Funktionale Programmierung Teil 2: Typecheck und Transformation Dr. David Sabel Sommersemester 2015 Stand der Folien: SoSe 2015 Übersicht FP-PR Teil 2: Typecheck und Transformation Sommersemester
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine WWW
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
Praktikum Funktionale Programmierung Organisation und Überblick
Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Sommersemester 2013 Stand der Folien: SoSe 2013 Adressen Organisatorisches Software Projekt Adressen, Termine Studienleistung
Funktionale Programmierung [FP-PR]
![Funktionale Programmierung [FP-PR]](/thumbs/66/56031053.jpg "Funktionale Programmierung [FP-PR]")
Praktikum: Funktionale Programmierung [FP-PR] Anleitung zum Praktikum Sommersemester 2009 Stand vom: 15. Juni 2009 Professur für Künstliche Intelligenz und Softwaretechnologie Institut für Informatik,
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
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen
Stand der Folien: SoSe 2011 Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen Dr. David Sabel Sommersemester 2011 Übersicht FP-PR Teil 1: Lexen & Parsen Sommersemester 2011 D. Sabel 2/20 Übersicht
Thomas Behr. 17. November 2011
in in Fakultät für Mathematik und Informatik Datenbanksysteme für neue Anwendungen FernUniversität in Hagen 17. November 2011 c 2011 FernUniversität in Hagen Outline in 1 2 3 4 5 6 - Was ist das? in über
Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen, Bäume)
Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen,
Übungsblatt 6: Softwareentwicklung I (WS 2006/07)
Prof. Dr. A. Poetzsch-Heffter Dipl.-Inform. J.O. Blech Dipl.-Inform. M.J. Gawkowski Dipl.-Inform. N. Rauch Technische Universität Kaiserslautern Fachbereich Informatik AG Softwaretechnik Übungsblatt 6:
Haskell for Hackers... or why functional programming matters
... or why functional programming matters Franz Pletz CCC München 27-06-2009 @ GPN8 Fahrplan Ablauf Motivation 1 Ablauf Motivation 2 3 4 Ablauf Ablauf Motivation bei Fragen/Unklarheiten:
Abstrakte Maschinen und Kode-Erzeugung für Haskell
Abstrakte Maschinen und Kode-Erzeugung für Haskell Implementierung der Reduktion: Compilierung: Terme als Bäume, Reduktion als Transformation auf Bäumen Terme als gerichtete Graphen, Template-Instantiation,
Geheimnisprinzip: (information hiding principle, Parnas 1972)
2. Abstrakte Datentypen 2.0 Begriffe Geheimnisprinzip: (information hiding principle, Parnas 1972) Zugriffe auf Teile einer Programmeinheit, die für die reguläre Benutzung nicht erforderlich sind, sollten
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 26. Oktober 2006 Haskell - Einführung Syntax Typen Auswertung Programmierung
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
Abstrakter Datentyp (ADT): Besteht aus einer Menge von Objekten, sowie Operationen, die auf diesen Objekten wirken.
Abstrakte Datentypen und Datenstrukturen/ Einfache Beispiele Abstrakter Datentyp (ADT): Besteht aus einer Menge von Objekten, sowie Operationen, die auf diesen Objekten wirken. Datenstruktur (DS): Realisierung
Prüfung Funktionale Programmierung
Hochschule für angewandte Wissenschaften München Fakultät für Informatik und Mathematik Studiengruppe IF, IB, IC Sommersemester 2015 Prüfung Funktionale Programmierung Datum : 23.07.2015, 10:30 Uhr Bearbeitungszeit
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zur Übungsklausur -
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zur Übungsklausur - Punkte: A1: 30, A2: 20, A3: 20, A4: 20, A5: 10, A6: 20 Punkte: /120 12.02.2012 Hinweis: Geben Sie bei allen
Funktionale Programmierung. ALP I Lambda-Kalkül. Teil III SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I Lambda-Kalkül Teil III SS 2011 Parser Hilfsfunktionen: Die break-funktion ist eine Funktion Höherer Ordnung, die eine Liste beim ersten Vorkommen einer Bedingung in zwei Listen spaltet. break ::
Prüfung Funktionale Programmierung
Hochschule für angewandte Wissenschaften München Fakultät für Informatik und Mathematik Studiengruppe IF, IB, IC Sommersemester 2014 Prüfung Funktionale Programmierung Datum : 16.07.2014, 12:30 Uhr Bearbeitungszeit
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zu Übung 9 -
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zu Übung 9 - Dozent: Prof. Dr. G. Rote Tutoren: J. Fleischer, T. Haimberger, N. Lehmann, C. Pockrandt, A. Steen 10.01.2012 Ziele
Programmierung WS18/19 Übungsblatt 9 (Abgabe Freitag, den um 12 Uhr)
Prof. aa Dr. J. Giesl S. Dollase, M. Hark, D. Korzeniewski Aufgabe 2 (Datenstrukturen in Haskell): (2 + 1 + 2 + 2.5 + 3.5 = 11 Punkte) In dieser Aufgabe geht es darum, arithmetische Ausdrücke auszuwerten.
Programmieren in Haskell Programmiermethodik
Programmieren in Haskell Programmiermethodik Peter Steffen Universität Bielefeld Technische Fakultät 12.01.2011 1 Programmieren in Haskell Bisherige Themen Was soll wiederholt werden? Bedienung von hugs
Funktionale Programmierung. Das Funktionale Quiz. Das Funktionale Quiz. Das Funktionale Quiz
Funktionale Programmierung Das Funktionale Quiz 31.5.2005 Nenne eine Gemeinsamkeit zwischen Typklassen und OO-Klassen Das Funktionale Quiz Das Funktionale Quiz Nenne einen Unterschied zwischen Typklassen
Funktionale Programmierung und Typtheorie
Funktionale Programmierung und Typtheorie 5. Fortgeschrittene Konzepte 5.1 Komprehensionen 5.2 Partielle Applikationen 5.3 Strikte und nichtstrikte Funktionen 5.4 Unendliche Datenstrukturen und verzögerte
Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie
Rev. 2749 1 [28] Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom 04.11.2014: Typvariablen und Polymorphie Christoph Lüth Universität Bremen Wintersemester 2014/15 2 [28] Fahrplan Teil
Grundlagen der Informatik
Grundlagen der Informatik Musterklausur 1. Dynamische Datenstrukturen und objektorientierte Programmierung Zur Verwaltung einer digitalen Fotogalerie sollen Techniken der objektorientierten Programmierung
Konzepte von Programmiersprachen
Konzepte von Programmiersprachen Kapitel 3: Ausdrücke Phillip Heidegger Universität Freiburg, Deutschland SS 2009 Phillip Heidegger (Univ. Freiburg) Konzepte von Programmiersprachen KvP 1 / 17 Inhalt Let
Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence
Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence David Sabel Institut für Informatik Fachbereich Informatik und Mathematik Goethe-Universität Frankfurt Kolloquium
12. Dynamische Datenstrukturen
Motivation: Stapel. Dynamische Datenstrukturen Verkettete Listen, Abstrakte Datentypen Stapel, Warteschlange, Implementationsvarianten der verketteten Liste 0 04 Motivation: Stapel ( push, pop, top, empty
2.3 Spezifikation von Abstrakten Datentypen
Abstrakte Datentypen (ADT) 2.3 Spezifikation von Abstrakten Datentypen Sichtbare Schnittstelle: Typbezeichner Signaturen der Operationen Spezifikation der Operationen Abstraktionsbarriere Implementierung
Programmieren in Haskell Abstrakte Datentypen
Programmieren in Haskell Abstrakte Datentypen Peter Steffen Universität Bielefeld Technische Fakultät 09.01.2009 1 Programmieren in Haskell Einführung Man unterscheidet zwei Arten von Datentypen: konkrete
Programmieren in Haskell Einführung
Programmieren in Haskell Einführung Peter Steffen Universität Bielefeld Technische Fakultät 17.10.2008 1 Programmieren in Haskell Veranstalter Dr. Peter Steffen Raum: M3-124 Tel.: 0521/106-2906 Email:
Fortgeschrittene Funktionale Programmierung
Fortgeschrittene Funktionale Programmierung 13. Vorlesung Janis Voigtländer Universität Bonn Wintersemester 2015/16 Erweiterung um Datentypen Typen: τ := Bool [τ] Terme: t := False True [ ] τ t : t case
Gliederung. n Teil I: Einleitung und Grundbegriffe. n Teil II: Imperative und objektorientierte Programmierung
Gliederung n Teil I: Einleitung und Grundbegriffe l 1. Organisatorisches l 2. Grundlagen von Programmiersprachen n Teil II: Imperative und objektorientierte Programmierung l 1. Grundelemente der Programmierung
Proinformatik Marco Block Dienstag, den 21. Juli 2009
2. Skript vom Dienstag, den 21. Juli 2009 zur Vorlesung Proinformatik Marco Block Dienstag, den 21. Juli 2009 1 Verschiedenes 1.1 let und where Am Anfang der Vorlesung haben wir uns ein paar einfache neue
Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom : Monaden als Berechnungsmuster
16:02:16 2017-01-17 1 [30] Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom 10.01.2017: Monaden als Berechnungsmuster Christoph Lüth Universität Bremen Wintersemester 2016/17 Frohes
Programmieren in Haskell
Programmieren in Haskell Syntax und Semantik von Haskell Programmieren in Haskell 1 Was wir heute (und nächstes mal) machen Datentypdefinitionen Wertdefinitionen, Variablenbindungen Musterbindungen Funktionsbindungen
Wiederholung: Zusammenfassung Felder. Algorithmen und Datenstrukturen (für ET/IT) Definition Abstrakter Datentyp. Programm heute
Wiederholung: Zusammenfassung Felder Algorithmen und Datenstrukturen (für ET/IT) Wintersemester / Dr. Tobias Lasser Computer Aided Medical Procedures Technische Universität München Ein Feld A kann repräsentiert
Reguläre Sprachen und endliche Automaten
Reguläre Sprachen und endliche Automaten 1 Motivation: Syntaxüberprüfung Definition: Fließkommazahlen in Java A floating-point literal has the following parts: a whole-number part, a decimal point (represented
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 17. Oktober 2006 Einführung in Haskell: Syntax, Reduktionen, Kernsprachen Haskell,
Grundlagen der Programmierung 2. Operationale Semantik
Grundlagen der Programmierung 2 Operationale Semantik Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 29. April 2009 Semantik von Programmiersprachen Semantik = Bedeutung
Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen:
Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen: take 1 0 ( f i l t e r ( fn x => x mod 2=0) nat ) ; val it =
1. Die rekursive Datenstruktur Liste
1. Die rekursive Datenstruktur Liste 1.6 Die Datenstruktur Stapel Ein Stack, auch Stapel oder Keller genannt, ist eine Datenstruktur, bei der die Elemente nur an einem Ende der Folge eingefügt bzw. gelöscht
Gliederung. Algorithmen und Datenstrukturen I. Binäre Bäume: ADT Heap. inäre Bäume: ADT Heap. Abstrakte Datentypen IV. D. Rösner
Gliederung Algorithmen und Datenstrukturen I Abstrakte Datentypen IV D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg Winter 2009/10,
Semantik von Programmiersprachen SS 2017
Lehrstuhl für Programmierparadigmen Denis Lohner Sebastian Ullrich denis.lohner@kit.edu sebastian.ullrich@kit.edu Semantik von Programmiersprachen SS 2017 http://pp.ipd.kit.edu/lehre/ss2017/semantik Lösungen
1 Abstrakte Datentypen
1 Abstrakte Datentypen Spezifiziere nur die Operationen! Verberge Details der Datenstruktur; der Implementierung der Operationen. == Information Hiding 1 Sinn: Verhindern illegaler Zugriffe auf die Datenstruktur;
Programmieren in Haskell. Abstrakte Datentypen
Programmieren in Haskell Abstrakte Datentypen Einführung Man unterscheidet zwei Arten von Datentypen: konkrete Datentypen: beziehen sich auf eine konkrete Repräsentation in der Sprache. Beispiele: Listen,
Allgemeine Hinweise: TECHNISCHE UNIVERSITÄT MÜNCHEN. Name Vorname Studiengang Matrikelnummer. Hörsaal Reihe Sitzplatz Unterschrift
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen WS 2008/09 Einführung in die Informatik 2 Klausur Prof. Dr. Helmut Seidl, T. M. Gawlitza, S. Pott,
13 Abstrakte Datentypen
13 Abstrakte Datentypen Bisher: Konkrete Datentypen Menge von Elementen Operationen auf den Elementen (Konstruktoren, Selektoren, Typprädikate) Eigenschaften abgeleitet Jetzt: Abstrakte Datentypen (ADT)
Methoden zur Interpretation LISPähnlicher. Programmiersprachen. Seminarvortrag / 53 FH AACHEN FACHBEREICH 9 TOBIAS STUMM MATR.-NR.
Methoden zur Interpretation LISPähnlicher Programmiersprachen Seminarvortrag 20.01.2017 FACHBEREICH 9 TOBIAS STUMM MATR.-NR. 4012917 1 Inhalt Motivation Lisp > Definition > Scheme Interpreter > Definition
Gliederung. Algorithmen und Datenstrukturen I. Listen in Haskell: Listen in Haskell: Listen in Haskell. Datentyp Liste Strings Listenkomprehension
Gliederung Algorithmen und Datenstrukturen I D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg 1 Winter 2009/10, 16. Oktober 2009, c
Technische Universität München SoSe 2015 Institut für Informatik I Mai 2015 Dr. Tobias Lasser. Aufgabe 1 Rechnen mit Landau-Symbolen
Technische Universität München SoSe 2015 Institut für Informatik I-16 27. Mai 2015 Dr. Tobias Lasser Lösungsvorschläge zur Musterklausur zu Algorithmen und Datenstrukturen Aufgabe 1 Rechnen mit Landau-Symbolen
DieÜbersetzung funktionaler Programmiersprachen
DieÜbersetzung funktionaler Programmiersprachen 107 11 Die Sprache PuF Wir betrachten hier nur die Mini-Sprache PuF( Pure Functions ). Insbesondere verzichten wir(vorerst) auf: Seiteneffekte; Datenstrukturen;
Theorembeweiserpraktikum SS 2016
Institut für Programmstrukturen und Datenorganisation Lehrstuhl Programmierparadigmen Am Fasanengarten 5 76131 Karlsruhe http://pp.ipd.kit.edu/ Theorembeweiserpraktikum SS 2016 http://pp.ipd.kit.edu/lehre/ss2016/tba
Alexander Nutz. 3. Dezember 2007
3. Dezember 2007 1 / 21 Aufgabe: die zeit- und platzeziente Implementierung von abstrakten Datentypen, z.b. eines Wörterbuches oder einer Zahlenmenge, für Programme bekannte : Listen,, Heaps,, Stacks,...
12 Abstrakte Klassen, finale Klassen und Interfaces
12 Abstrakte Klassen, finale Klassen und Interfaces Eine abstrakte Objekt-Methode ist eine Methode, für die keine Implementierung bereit gestellt wird. Eine Klasse, die abstrakte Objekt-Methoden enthält,
Grundlagen der Programmierung 3 A
Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2016 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln
1. Typen 1.1 Typsicherheit 1.2 Typprüfung
1. Typen 1.1 Typsicherheit 1.2 Typprüfung Ein Typsystem ist ein praktikables, syntaktisches Verfahren, mit dem man die Abwesenheit gewisser Laufzeit-Eigenschaften eines Programms beweisen kann, indem man
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2017 Marc Bux, Humboldt-Universität zu Berlin Agenda 1. (Sortierte) Listen 2. Stacks & Queues 3. Datenstrukturen 4. Rekursion und vollständige Induktion
Programmierkurs II. Typsynonyme & algebraische Datentypen
Programmierkurs II Typsynonyme & algebraische Datentypen Um Dinge der realen Welt abzubilden, ist es nur in den seltensten Fällen komfortabel alles als Zahlen, Strings oder Listen zu kodieren. Wir benötigen
Programmieren in Haskell
Programmieren in Haskell Syntax und Semantik von Haskell Programmieren in Haskell 1 Was wir heute (und nächstes mal) machen Datentypdefinitionen Wertdefinitionen, Variablenbindungen Musterbindungen Funktionsbindungen
Grundlegende Datentypen
Grundlegende Datentypen Funktionale Programmierung Prof. Dr. Oliver Braun Letzte Änderung: 22.10.2018 10:53 Grundlegende Datentypen 1/21 Typen in Haskell ist alles streng typisiert Haskell verfügt über
Einfache Liste: Ein Stapel (Stack) Ansatz. Schaubild. Vorlesung 1. Handout S. 2. Die einfachste Form einer Liste ist ein Stapel (stack).
Programmieren I Martin Schultheiß Hochschule Darmstadt Sommersemester 2011 1 / 64 2 / 64 Motivation Hauptteil dieser Vorlesung sind die so genannten. Zur Motivation (und als Vorbereitung der Datencontainer-Klassen
Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Überladung und Konversion in Haskell. Typisierung in Haskell
Haskell, Typen, und Typberechnung Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr Manfred Schmidt-Schauß Ziele: Haskells Typisierung Typisierungs-Regeln Typ-Berechnung Sommersemester
2.2.1 Algebraische Spezifikation (Fortsetzung)
2.2.1 Algebraische Spezifikation (Fortsetzung) Algebraische Spezifikation: Mengen Types Set, Bool, t Signature > creates :: Eq t => Set t > isempty :: Eq t => Set t -> Bool > insert :: Eq t => t -> Set
Technische Universität München SoSe 2018 Fakultät für Informatik, I Mai 2018 Dr. Stefanie Demirci
Name: Vorname: Matr. Nr.: Technische Universität München SoSe 2018 Fakultät für Informatik, I-16 9. Mai 2018 Dr. Stefanie Demirci Probeklausur zu Algorithmen und Datenstrukturen Allgemeine Hinweise Die
B2.1 Abstrakte Datentypen
Algorithmen und Datenstrukturen 21. März 2018 B2. Abstrakte Datentypen Algorithmen und Datenstrukturen B2. Abstrakte Datentypen B2.1 Abstrakte Datentypen Marcel Lüthi and Gabriele Röger B2.2 Multimengen,
So schreiben Sie ein Parser-Programm
Universität des Saarlandes Fachrichtung Informatik Programming Systems Lab Prof. Gert Smolka Proseminar Programmiersysteme WS 03/04 Höhere Funktionale Programmierung: Parser-Kombinatoren Matthias Berg
WS 2011/2012. Robert Giegerich Dezember 2013
WS 2011/2012 Robert 1 AG Praktische Informatik 11. Dezember 2013 1 robert@techfak.uni-bielefeld.de Vorschau Themen heute: Funktionen höherer Ordnung (Fortsetzung) künstliche Striktheit mehr zu fold für
Grundlagen der Programmierung 2 (2.B)
Grundlagen der Programmierung 2 (2.B) Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 11. Juni 2008 Reduktionsregel zum case case-reduktion (case (c t 1... t n ) of... (c
Algorithmen und Datenstrukturen (für ET/IT)
Algorithmen und Datenstrukturen (für ET/IT) Sommersemester 2016 Dr. Tobias Lasser Computer Aided Medical Procedures Technische Universität München Programm heute 1 Einführung 2 Grundlagen von Algorithmen
Einführung in Haskell
Einführung in Haskell Axel Stronzik 21. April 2008 1 / 43 Inhaltsverzeichnis 1 Allgemeines 2 / 43 Inhaltsverzeichnis 1 Allgemeines 2 Funktions- und Typdefinitionen 2 / 43 Inhaltsverzeichnis 1 Allgemeines
Einführung in die Informatik 2 8. Übung
Technische Universität München WS 2013/14 Institut für Informatik 03.11.2012 Prof. Tobias Nipkow, Ph.D. Abgabe: 10.12.2012, 15:30 Lars Noschinski, Lars Hupel, Dr. Jasmin Blanchette Einführung in die Informatik
Einführung in die Computerlinguistik
Einführung in die Computerlinguistik Übung 2 Laura Kallmeyer Sommersemester 204, Heinrich-Heine-Universität Düsseldorf Offizielle Python Seite, auf der man jede Menge Dokumentation findet: http://www.python.org/
Fachhochschule Wedel 31. Januar 2004 Prof. Dr. Uwe Schmidt
Fachhochschule Wedel 31. Januar 2004 Prof. Dr. Uwe Schmidt Aufgaben zur Klausur C und Objektorientierte Programmierung im WS 2003/04 (WI h103, II h105, MI h353) Zeit: 150 Minuten erlaubte Hilfsmittel:
Typ-Polymorphismus. November 12, 2014
Typ-Polymorphismus Universität Bielefeld AG Praktische Informatik November 12, 2014 Das Haskell Typ-System Wir beginnen mit einer Wiederholung des Bekannten: In allen Programmiersprachen sind Typ-Konzepte
Praktische Informatik 3: Funktionale Programmierung Vorlesung 6 vom : Funktionen Höherer Ordnung II und Effizienzaspekte
16:02:08 2017-01-17 1 [34] Praktische Informatik 3: Funktionale Programmierung Vorlesung 6 vom 22.11.2016: Funktionen Höherer Ordnung II und Effizienzaspekte Christoph Lüth Universität Bremen Wintersemester
Funktionale Programmiersprachen
Funktionale Programmiersprachen An den Beispielen Haskell und Erlang Übersicht Programmiersprachen λ-kalkül Syntax, Definitionen Besonderheiten von funktionalen Programmiersprache, bzw. Haskell Objektorientierte
SWP Funktionale Programme (2. Teil)
SWP Funktionale Programme (2. Teil) Bernhard Aichernig Institut für Softwaretechnologie aichernig@ist.tugraz.at Institute for Software Technology Inhalt Einfache Ausdrücke (Sprachen A +, B bin +, C Mult,
Einführung in die Informatik 2
Technische Universität München Fakultät für Informatik Prof. Tobias Nipkow, Ph.D. Manuel Eberl, Lars Hupel, Lars Noschinski Wintersemester 2014/15 Lösungsblatt Endklausur 13. Februar 2015 Einführung in
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.
Grundlegende Datentypen
Grundlegende Datentypen (Funktionale Programmierung) Prof. Dr. Oliver Braun Letzte Änderung: 18.03.2018 21:08 Grundlegende Datentypen 1/16 Typen in Haskell ist alles streng typisiert Haskell verfügt über
1 - Backus-Naur-Form. (a) Ableitung des Wortes /a*(a b)b/ aus der gegebenen BNF:
1 - Backus-Naur-Form (a) Ableitung des Wortes /a*(a b)b/ aus der gegebenen BNF: R Regel R -> '/' S '/' => '/' S '/' Regel S -> E S => '/' E S '/' Regel E -> E '*' => '/' E '*' S '/' Regel E -> D => '/'
Einführung in die Informatik Übung
Technische Universität München WS 2014/15 Institut für Informatik 09.01.2015 Prof. Tobias Nipkow, Ph.D. Abgabe: 16.01.2015 L. Noschinski, L. Hupel, M. Eberl Einführung in die Informatik 2 12. Übung Am
Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie
16:02:01 2017-01-17 1 [37] Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom 08.11.2016: Typvariablen und Polymorphie Christoph Lüth Universität Bremen Wintersemester 2016/17 PI3 WS 16/17
Grundlagen der Programmierung 3 A
Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln
Programmieren in Haskell Einstieg in Haskell
Programmieren in Haskell Einstieg in Haskell Peter Steffen Universität Bielefeld Technische Fakultät 24.10.2008 1 Programmieren in Haskell Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke
Aufgabe 1 Basiswissen zur Vorlesung (8 Punkte)
Matrikelnummer: 1 Aufgabe 1 Basiswissen zur Vorlesung (8 Punkte) Kreuzen Sie an, ob die folgenden Aussagen richtig oder falsch sind. Bewertung: keine Antwort: 0 Punkte richtige Antwort: +0.5 Punkte falsche
Stackmaschine; Speicheradressierung
Stackmaschine; Speicheradressierung Erweiterung um globalen Speicher (Heap, Halde) pro Speicherplatz eine Zahl. Notation ist als Array SP [0..]. Zugriff mittels Adresse (Index): eine Zahl i.a.: Zahlen
Grundlegende Datentypen
Funktionale Programmierung Grundlegende Datentypen Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 14.11.2017 15:37 Inhaltsverzeichnis Typen........................................