Funktionale Programmierung ALP I. Kombinatorische Logik (CL) SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda

Transkript

1 ALP I Kombinatorische Logik (CL) SS 2011

2 Äquivalenz vieler Berechnungsmodelle Alonzo Church λ-kalkül Kombinatorische Logik Alan Turing Turing-Maschine Mathematische Präzisierung µ-rekursive Funktionen Effektiv Berechenbare Funktionen Register- Maschinen GOTO- Berechenbar WHILE- Berechenbar Moderne Programmiersprachen mit unendlichem Speicher

3 Eingeführt von Kombinatorische Logik (CL) Moses Schönfinkel und Haskell Brooks Curry

4 Kombinatorische Logik (CL) ein noch einfacheres Berechnungsmodell Variation des λ-kalküls, indem λ-ausdrücke mit Kombinatoren ersetzt werden Kombinatoren sind primitive Funktionen ohne freie Variablen die kombinatorische Logik wird oft als Grundlage für die Implementierung von nicht-strikten funktionalen Programmiersprachen verwendet.

5 Was sind Kombinatoren? Motivation an der Tafel

6 Kombinatoren Ein Kombinator ist eine primitive Funktion (Lambda- Ausdruck) ohne freie Variablen. T i ist ein Kombinatorischer Term wenn: 1) T i ein Kombinator ist 2) (T 1 T 2 ) (Funktionsapplikation), wenn T 1 und T 2 wiederum Kombinatorische Terme sind.

7 SKI-Kombinatoren I-Kombinator oder Identitätskombinator einfachster Kombinator für den Identitätskombinator gilt: (I a) = a Die Lambda-Funktion λx.x I

8 SKI-Kombinatoren K-Kombinator oder Kanzellator gibt immer eine konstante Funktion als Ergebnis für den Konstantenkombinator gilt: (K a x) = a Die Lambda-Funktion λxy.x K

9 SKI-Kombinatoren S-Kombinator modelliert eine Verallgemeinerung der Funktionsapplikation für den S-Kombinator gilt: (S x y a) = (x a (y a)) Die Lambda-Funktion λxya.xa(ya) S

10 SKI-Kombinatoren Beispiele an der Tafel

11 Vollständigkeit der SKI-Kombinatoren Die Vollständigkeit ist gegeben, wenn es eine Transformationsfunktion gibt, die einen beliebigen λ-ausdruck in einen Ausdruck, der nur SKI- Kombinatoren beinhaltet, verwandeln kann. T[x] => x T[(E 1 E 2 )] => (T[E 1 ] T[E 2 ]) T[λx.E] => (K T[E]) wenn x nicht frei in E T[λx.x] => I T[λx.λy.E] => T[λx.T[λy.E]] falls x freie Variable von E T[λx.(E 1 E 2 )] => (S T[λx.E 1 ] T[λx.E 2 ])

12 Vollständigkeit der SKI-Kombinatoren -- Transformationsfunktion transform (Lambda x y) = (eliminate x y) transform (Var x) = Var x transform (App x y) = App (transform x) (transform y) transform S = S transform K = K transform I = I

13 Vollständigkeit der SKI-Kombinatoren eliminate x S eliminate x K eliminate x I = App K S = App K K = App K I eliminate x y not(element x (freie y [])) = (App K (transform y)) eliminate x (Var y) x==y = I otherwise = (App K (Var y)) eliminate x (Lambda y z) = eliminate x (eliminate y z) eliminate x (App y z) = (App (App S (eliminate x y)) (eliminate x z))

14 SKI-Kombinatoren Weiter geht es an der Tafel...

15 parse Nil [] parse e [] parse Nil (a:r) letter a parse e (a:r) letter a SKI-Parser parse Nil ('S':r) = parse S r parse e ('S':r) = parse (App e S) r parse Nil ('K':r) = parse K r parse e ('K':r) = parse (App e K) r parse Nil ('I':r) = parse I r parse e ('I':r) = parse (App e I) r = error "empty expression" = e = parse (Var [a]) r = parse (App e (Var [a])) r parse Nil ('(':r) = parse (parse Nil a) b where (a,b) = extract [] r 0 parse e ('(':r) = parse (App e (parse Nil a)) b where (a,b) = extract [] r 0 parse = error "parsing error"

16 SKI-Parser Der SKI-Parser kann auch wie unserer Lambda-Kalkül-Parser Macros mit längeren Namen innerhalb von geschweiften Klammern erkennen, damit das Testen von langen SKI-Ausdrücken einfacher wird.... parse Nil ('{':r) = parse Nil ((longmacro (fst a))++(tail(snd a))) where a = (break (=='}') r) parse e ('{':r) = parse e ((longmacro (fst a))++(tail(snd a))) where a = (break (=='}') r)...