Einführung in die funktionale Programmierung

Transkript

1 Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 18. November 2008

2 Typcheck zu KFPT; KFPTS;... Ziele des Kapitels: Polymorphes Typsystem für alle Konstrukte von KFPTSP Typsystem unabhängig vom Haskell-Typcheck Soll das Typsystem von Haskell verständlich machen Funktionalität des Formalismus Grenzen; und Vor- und Nachteile zwei Varianten des Typchecks Einführung in die funktionale Programmierung, fol

3 Polymorpher Typcheck in KFPTS(P) Urväter dieses Typsystems: Hindley, Milner, Mycroft, Abramsky, Damas Wird verwendet in Haskell, ML Ebenso in Java ( leicht angepasst) Einführung in die funktionale Programmierung, fol

4 Polymorpher Typcheck in KFPTS(P) Annahmen KFPTSP ist die Grundlage: Es gibt eine Typsyntax, Typen und Typkonstruktoren Der Typ der Daten-Konstruktoren ist vorgegeben Ein case-konstrukt pro abstraktem Datentyp (mit data type deklariert) (nicht für den Funktionsdatentyp a b) rekursive Superkombinatoren sind erlaubt. Einführung in die funktionale Programmierung, fol

5 Erwünschte Eigenschaften eines Typsystems Wenn Typcheck erfolgreich, dann keine dynamischen Typfehler (d.h. zur Laufzeit) Flexibles Programmieren trotz Typenbeschränkungen Typisierung sollte entscheidbar sein. Falls möglich: effizient Jeder Ausdruck und Unterausdruck muss einen Typ haben. Einführung in die funktionale Programmierung, fol

6 Wiederholung; Exp-Syntax von KFPT: Exp ::= V (Variablen) (\V -> Exp) (Exp 1 Exp 2 ) (c T yp Exp 1... Exp n ) (wobei n = ar(c) ) (case Typ Exp of {P at 1 -> Exp 1 ;... ; P at n -> Exp n }) (P at i sind alle einfachen Pattern zum Typ des case) Pat ::= (c V 1... V ar(c) ) Die Variablen V i müssen alle verschieden sein. Einführung in die funktionale Programmierung, fol

7 Dynamische Typfehler Definition: Ein dynamischer Typfehler tritt auf, wenn: Die Normalordnung versucht folgendes auszuwerten: (case Typ (c...)...) wobei c kein Konstruktor zu Typ ist. (case Typ (\x->s)...) (case Typ (sc t1.. tn)...) und n < ar(sc) ((c...) t) wobei c ein Konstruktor ist. Einführung in die funktionale Programmierung, fol

8 Dynamische Typfehler Satz Es gibt kein (entscheidbares) Typsystem in KFPT (KFPTS), das genau die Ausdrücke erkennt, die keine dynamischen Typfehler verursachen. Beweis-Skizze Zurückführung auf das Halteproblem: Betrachte den Ausdruck if t then case_bool Nil {p1-> (Nil Nil) ;... } else case_bool Nil {p1-> (Nil Nil) ;... } Falls t nur True, False, (oder Nichtterminierung) ergeben kann, dann ergibt sich ein Typfehler genau dann wenn t terminiert. Als t kann man eine Turingmaschine in KFPT kodieren D.h.: Lösung des Halteproblem Existenz eines exakten Typcheckers Einführung in die funktionale Programmierung, fol

9 Nicht-Existenz eines exakten Typcheckers: Konsequenzen Angenommen, wir haben ein entscheidbares Typsystem, das keine dynamischen Typfehler zulässt. Dann gibt es ungetypte Ausdrücke, die keine dynamischen Typfehler verursachen. Erweiterung des entscheidbaren Typsystems sind immer möglich; sind trotzdem nie exakt. Einführung in die funktionale Programmierung, fol

10 Polymorphe Typen (Hindley; Milner; Mycroft) Syntax Typ ::= Typkonstante Typvariable (TC Typ 1... Typ n ) Wobei TC Stelligkeit n hat. elementarer Typ = Basistyp, d.h. Konstante Grundtyp,monomorpher Typ. = Typ ohne Typvariablen polymorph = mit Typvariablen Einführung in die funktionale Programmierung, fol

11 Polymorphe Typen (Typ-)Variable: Typkonstruktor: Gleiche Variablen bedeuten gleichen Typ. zu jedem algebraischen Datentyp gibt es einen. Die Stelligkeit der Konstruktoren ist festgelegt. zweistelliger Typ-Konstruktor für Funktionen. Einführung in die funktionale Programmierung, fol

12 Bedeutung der Typen Zwei Möglichkeiten: (A) (B) Als Menge von Grundtypen Als Formel erster Ordnung: Aussage über Argument und Ergebnistypen einer Funktion Beispiel: (A) (B) Cons: α [α] [α] Die Menge der Typen von Cons ist: {τ [τ] [τ] τ ist ein Grundtyp}. α.α [α] [α]: Für alle Eingaben... ist die Ausgabe vom Typ [α]. Betrachtungsweise: Jeder Ausdruck hat eine Menge von Grundtypen Einführung in die funktionale Programmierung, fol

13 Weitere Annahmen zu Datenkonstruktoren Annahmen: Typ des Datenkonstruktors gibt die Stelligkeit an, und die möglichen Typen und Typkombinationen der Argumente. Zieltyp muss von der Form T α 1... α n sein, wobei T Typkonstruktor des zugehörigen algebraischen Datentyps und die α i verschiedene Typvariablen sind. Nur α 1... α n können als Typvariablen in Argumenttypen von Konstruktoren vorkommen Das schließt im Moment GADT aus, ebenso existenzielle Typen in Konstruktor-Deklarationen (Wird in WX-Haskell benötigt) Einführung in die funktionale Programmierung, fol

14 Beispiele zu Datenkonstruktoren Paare: (.,.) : α β (α, β) Listen: Nil: [α] und : : α [α] [α] Boolesche Werte: True: Bool und False: Bool. Einführung in die funktionale Programmierung, fol

15 Beispiel: Bäume Data Tree a = Node a (Tree a) (Tree a) Leaf a Tree ist der einstellige Typkonstruktor. Node,Leaf sind die (Daten-)Konstruktoren. Node: α (Tree α) (Tree α) (Tree α) Leaf: α (Tree α) Einführung in die funktionale Programmierung, fol

16 Instanz eines polymorphen Typs (Typ-)Substitution σ: ist Abbildung : Typ-Ausdrücke Typen definiert auf den Typ-Variablen Anwendungsregeln: σ α = σα σ (c t 1... t n ) = (c (σ t 1 )... (σ t n )) Beispiel Instanzen von [α] sind [Int] mit {α Int} [[α]] mit {α [α]} [β Int] mit {α (β Int)} Einführung in die funktionale Programmierung, fol

17 Typregeln (auf Grundtypen) für KFPTSP Idee der Typregeln: Die Regeln berechnen Grundtypen von Ausdrücken (i.a.unendlich viele) Grundtypen Ist scheinbar umständlich, Aber allgemeiner als polymorphe Typ-Schemata. Einführung in die funktionale Programmierung, fol

18 Typregeln (auf Grundtypen) für KFPTSP Aufbau einer Regel: bisherige Folgerungen neue Folgerung Typannahme t : τ ist eine Einzel-Komponente (judgement) Bisherige Folgerungen = Liste von Komponenten neue Folgerungen bestehen aus einer Komponente Regeln ohne Voraussetzungen sind Axiome. Bei diesen wird die Annahme und der Strich weggelassen. Einführung in die funktionale Programmierung, fol

19 Typregeln (auf Grundtypen) für KFPTSP Typannahmen A: Variablen x sind eine Menge von Annahmen über die möglichen Typen der freien Variablen und bekanntes Wissen über die Typen der Konstanten bzw. Funktionssymbole haben höchstens eine Typannahme x : τ in jedem A Superkombinatoren werden getrennt behandelt Konstanten c können mehrere Typannahmen haben: c : τ 1,..., c : τ n. I.A. Menge aller Grundinstanzen eines polymorphen Typs Typangabe c : (σ). Einführung in die funktionale Programmierung, fol

20 Typregeln Die Typregeln definieren eine Herleitbarkeitsrelation A s : τ bedeutet, dass aus A der Typ τ für s herleitbar ist. I.a. ist eine Menge von Typen für einen Term herleitbar. Oft ist diese Menge eine Instanzmenge eines polymorphen Typs. Einführung in die funktionale Programmierung, fol

21 Typen und Typklassen Mit der Typmengen-Methode kann man einige Beschränkungen des Typklassensystem modellieren: Typen von +: {Int Int Int, Integer Integer Integer,...}. Das sind endlich viele; Diese Menge ist nicht als Instanz eines polymorphen Typs darstellbar. Einführung in die funktionale Programmierung, fol

22 Typregeln τ, τ i sind Grundtypen, T Menge von Grundtypen. Axiom für Konstanten A {c : T } c : τ wenn τ T Axiom für Konstanten (polymorphe Typen) A {c : (σ)} c : τ wenn τ Grundinstanz von σ Axiome für freie Variablen A {x : τ} x : τ Einführung in die funktionale Programmierung, fol

23 Typregeln Anwendungsregel: Superkombinator-Regel A a : (τ 1 τ 2 ); A b : τ 1 A (a b) : τ 2 A {x 1 : τ 1,... x n : τ n } e : τ; sc x 1... x n = e ist die Definition für den Superkombinator sc A sc : τ 1... τ n τ Nebenbedingung: A hat keine Annahmen über x i Abstraktion: A {x : τ 1 } t : τ 2 A (λx.t) : τ 1 τ 2 Einführung in die funktionale Programmierung, fol

24 Typregeln case-regel: µ ist Typ zu Typkonstruktor D A e : µ A {x 1,1 : τ 1,1... x 1,n(1) : τ 1,n(1) } (c 1 x 1,1... x 1,n(1) ) : µ... A {x m,1 : τ m,1... x m,n(m) : τ m,n(m) } (c m x m,1... x m,n(m) ) : µ A {x 1,1 : τ 1,1... x 1,n(1) : τ 1,n(1) } e 1 : τ... A {x m,1 : τ m,1... x m,n(m) : τ m,n(m) } e m : τ A (case D e {(c 1 x 1,1... x 1,n(1) ) e 1 ;... ; (c m x m,1... x m,n(m) ) e m }) : τ Es reicht aus, sich zu merken: e und alle Pattern haben gleichen Typ der zu D gehört ebenso die entsprechenden Unterterme alle e i und der Gesamt-case-Ausdruck haben gleichen Typ. Einführung in die funktionale Programmierung, fol

25 Typregeln; Anmerkungen Die Typregeln für Abstraktionen, Superkombinatoren und case verändern die Menge der Typannahmen: und zwar um lokale Annahmen für gebundene Variablen Einführung in die funktionale Programmierung, fol

26 Typregeln Obige Regeln sind ausreichend für Typen von nicht rekursiv definierten Superkombinatoren Man stellt fest, dass oft polymorphe Typen (Schemata) für die Menge der herleitbaren Typen eines (nicht-rekursiven) Superkombinatoren herleitbar sind. Einführung in die funktionale Programmierung, fol

27 Wohlgetypte Ausdrücke Definition Ein Ausdruck t ist (bzgl des Grundtypensystem) wohlgetypt, wenn man für t mindestens einen Typ herleiten kann. D.h. A t :: τ soll herleitbar sein. Hierbei darf A nur Annahmen zu Variablen enthalten, die frei in t vorkommen. Es gilt Bei geschlossenen Ausdrücken muss A = sein Wenn t wohlgetypt ist, dann auch alle Unterausdrücke von t. Einführung in die funktionale Programmierung, fol

28 Typregeln: Beispiele Abstraktion Id := λx.x: {x : τ} x : τ λx.x : τ τ wobei τ ein (beliebiger) Grundtyp ist. D.h. λx.x hat alle Typen der Form {τ τ}. Das ist gerade die Menge der Instanzen von α α. Einführung in die funktionale Programmierung, fol

29 Typregeln: Beispiele unitlist x = Cons x Nil Menge der Annahmen: A = {x : τ, (Nil : [β]), Cons : (α [α] [α])} 1. A (Cons x) : [τ] [τ] 2. A (Cons x Nil) : [τ] 3. Superkombinatorregel: unitlist: τ [τ]. Für alle Grundtypen τ gilt: unitlist: τ [τ]. Auch hier: unitlist : α [α] Einführung in die funktionale Programmierung, fol

30 Typregeln: Beispiele twice f x = f (f x) Typannahme A = {x : τ 1, f : τ 2 }. 1. Der Typ von (f x) muss existieren: deshalb muss f : τ 2 = τ 1 τ 3 sein, wobei τ 3 noch unbestimmt ist. a (f x) : τ Nur Annahmen der Form A = {x : τ 1, f : τ 1 τ 3 } sind sinnvoll 3. Typ von f (f x) muss existieren: Argumentvariablen haben nur einen Typ: Also τ 1 = τ 3 und f (f x): τ A = {x : τ 1, f : τ 1 τ 1 } herleitbar: f (f x): τ 1 5. Mit der Superkombinatorregel: twice: (τ τ) τ τ. 6. Polymorpher Typ von twice :: (α α) α α Einführung in die funktionale Programmierung, fol

31 Anmerkungen Statt mit x : τ Grundtypen durchzuprobieren : Evtl. besser: x : α mit Typvariable α. Wesentlich für das Typsystem: Nur eine Grundtypannahme für lokale Variablen (ohne Quantoren) keine Menge o.ä. Lambda-gebundene Variablen dürfen nicht polymorph verwendet werden Das ist eine echte Einschränkung, falls Variablen vom Funktionstyp Einführung in die funktionale Programmierung, fol

32 Beispiel selfapply selfapply kommt als Unterausdruck in der Definition des Fixpunktkombinators Y vor. selfapply x = x x Typ von selfapply nach zwei verschiedenen Methoden: 1. lambda-gebundene Variablen sind monomorph 2. Argumente dürfen eine Menge von Typen haben. (was wäre wenn,...) Polymorphismus mit höherem Rang. Einführung in die funktionale Programmierung, fol

33 Beispiel selfapply selfapply x = x x Unter der Annahme, dass lambda-gebundene Variablen monomorph sind. 1. Annahme: {x : τ} 2. (x x) hat Typ, deshalb τ = τ 1 τ 2 und τ 1 = τ. Fehler, denn solche Grundtypen, gibt es nicht. Damit hat Y = λf.(λx.f(x x)) (λx.f(x x)) keinen polymorphen Typ Aber: (selfapply x) kann vernünftig sein: Z.B: selfapply I (I I) I. Einführung in die funktionale Programmierung, fol

34 Beispiel selfapply: ohne Monomorphie- Annahme zu lambda-gebundenen Variablen Als versuchsweise Erweiterung des Typsystems: eine Menge von Typen ist erlaubt pro Variable 1. {selfapply : S; x : T } 2. (x x) muss einen Typ haben T muss erfüllen: Es gibt Typen τ 1 T und τ 1 τ 2 T 3. Die von T abgeleitete Typmenge von (x x) ist dann: T 1 = {τ 2 Es gibt τ 1 τ 2 T und τ 1 T } D.h. selfapply: T {τ 2 Es gibt τ 1 τ 2 T und τ 1 T } Der Mengen-Typ von selfapply ist keine Instanz eines polymorphen Typausdrucks, sondern eine komplexere Bedingung an Mengen von Grundtypen. Einführung in die funktionale Programmierung, fol

35 Typen für rekursive Superkombinatoren Das bisherige Typsystem kann keine Typen für rekursiv definierte Superkombinatoren herleiten, da die Definition der Herleitbarkeit dann zyklisch ist. Einführung in die funktionale Programmierung, fol

36 Erweiterung des Typsystems Erweiterung zur Berechnung von Typen von rekursiven Superkombinatoren Einführung in die funktionale Programmierung, fol

37 Typen für rekursive Superkombinatoren Konsistente Annahme Programm: sc 1 = e 1,..., sc n = e n A C := Typen der Konstruktoren A SC := {sc 1 :: S 1,..., sc n :: S n } sind Typannahmen zu den sc i Für jeden Kombinator sc j und für alle τ i S j : lässt sich jeder angenommene Typ herleiten, d.h.: A SC A C sc j : τ i, wobei die letzte angewendete Regel jeder Herleitung jeweils die Superkombinatorregel zu sc j ist, dann ist A eine konsistente Typannahme. A ist dann ein Fixpunkt des Verfahrens. Einführung in die funktionale Programmierung, fol

38 Typen für rekursive Superkombinatoren Konsistenz: alle (Grund-)Typen von Superkombinatoren, die in den Annahmen sind, kann man auch aus diesen Annahmen herleiten (Evtl. mehr Typen) Einführung in die funktionale Programmierung, fol

39 Typen für rekursive Superkombinatoren Definition Ein Programm P (eine Mengen von Superkombinatordefinitionen) ist wohlgetypt, wenn es eine konsistente Typannahme zu P gibt. Wenn es eine allgemeinste (größte) konsistente Typannahme gibt dann sind sc i : S i die allgemeinsten Typen der Superkombinatoren. entspricht: größtem Fixpunkt der Annahmen unter Superkombinator-Typ-Herleitung Einführung in die funktionale Programmierung, fol

40 Typisierung eines rekursiven Kombinators Beispiel: repeat x = Cons x (repeat x) Versuch einer Typannahme: A = {repeat : α, Cons : (β [β] [β]), x : τ} Dann ergibt sich: 1. (repeat x) (rechts) ist getypt, deshalb repeat: τ α 2. (Cons x (repeat x)) ist getypt, deshalb [τ] = α und damit (Cons x (repeat x)): [τ]. 3. Das Ergebnis: repeat : τ [τ] Beachte: das geht für alle τ! Aber: Typ-Annahme nicht konsistent. Einführung in die funktionale Programmierung, fol

41 Beispiel: repeat Neue Annahmen A 1 = {repeat : (α [α]), Cons : (β [β] [β])} Konsistenz-Test bzw Typisierung unter A 1 : 1. (repeat x): [τ] 2. (Cons x (repeat x)): [α] und β = α = τ 3. Damit: repeat : τ [τ] für alle τ mit Superkombinatorregel als letzte Regel herleitbar 4. Damit ist A 1 eine konsistente Typannahme. Einführung in die funktionale Programmierung, fol

42 Reduktion und Typen Lemma Sei A konsistente Typannahme für alle Superkombinatoren. Dann gilt: Wenn t t eine Reduktion ist, Dann A t : τ = A t : τ (falls t geschlossen) Bzw. A A V t : τ = A A V t : τ (falls t offen) Begründung: Alle Reduktionsfälle durchgehen: Superkombinator-Reduktion, Beta-Reduktion, Case-Reduktion Einführung in die funktionale Programmierung, fol

43 Reduktion und Typen Begründung des Lemmas: 1. Superkombinator-Reduktion: sc t 1... t n e[t 1 /x 1... t n /x n ] mit sc x 1... x n = e Wir wollen wissen, ob: (A sc t 1... t n ) :: τ = (A e[t 1 /x 1... t n /x n ] :: τ) Einführung in die funktionale Programmierung, fol

44 Reduktion und Typen; Begründung Typregel zu Superkombinatoren und Anwendung: Term sc t 1... t n : Aus A herleitbar: t 1 :: τ 1,..., t n :: τ n, ebenso sc :: τ 1... τ n τ A und (sc t 1... t n ) :: τ. Typannahmen konsistent = sc :: τ 1... τ n τ mittels der Superkombinatorregel herleitbar somit auch für den Rumpf e :: τ unter den Annahmen x 1 :: τ 1,.... Typisierungsregeln beachten nur den Typ der Terme, somit: e[t 1 /x 1... t n /x n ] :: τ ist aus A herleitbar Einführung in die funktionale Programmierung, fol

45 Reduktion und Typen: Begründung 2. ((λx.s)t) s[t/x]. Analog zur Superkombinatorreduktion: Abstraktions und Anwendungsregel-Typisierung passen zur Beta- Reduktion Typen vorher: λx.s :: τ 1 τ 2 t :: σ. ((λx.s) t) :: γ(τ 2 ). wobei γ(τ 1 ) = γ(σ) Typ nachher: s[t/x] ::?? Da der Typcheck-Algorithmus nur auf den Typ der Unterterme achtet und t :: γ(σ) und x :: γ(σ), gilt: s[t/x] : γ(τ 2 ) Einführung in die funktionale Programmierung, fol

46 Reduktion und Typen: Begründung zu case- Reduktion 3. case-reduktion case A (c i t 1... t n(i) )) {(c 1 x 1,1,... x 1,n(1) ) exp 1 ;... (c m x m,1,... x m,n(m) ) exp m } exp i [t 1 /x i,1,..., t n(i) /x i,n(i) ] case-typregel: = : (c i t 1... t n(i) ) und (c i x i,1... x i,n(i) ) haben gleichen Typ. = : t i : τ i und x j,i : τ i exp i : τ, wobei τ der Typ des case- Ausdrucks. Beachte: Aus den Konventionen zu Konstruktoren folgt: aus dem Typ von (c i t 1... t n(i) ) laesst sich der Typ der Terme t i eindeutig bestimmen. = : exp i [t 1 /x i,1,..., t n(i) /x i,n(i) ] : τ Einführung in die funktionale Programmierung, fol

47 Aussagen zu Typcheck Satz wohlgetypte Programme machen keine dynamischen Typfehler Das gilt auch für die (Milner-)Typisierung (wird noch besprochen) Die Milner-Typisierung typisiert aber weniger Programme als die Grundtypenmethode. Einführung in die funktionale Programmierung, fol

48 Direkt Ungetypte Ausdrücke Aussage Für direkt ungetypte Ausdrücke lässt sich kein Typ herleiten. direkt ungetypte Fälle: 1. (case T (c...)...) wobei c kein Konstruktor zu Typ ist. 2. (case T (\x->s)...) 3. (case T (sc t1.. tn)...) und n < ar(sc) 4. ((c...) t) wobei c ein Konstruktor ist. zu 1. Keine Typregel für case anwendbar: Pattern-Typ verschieden von (T...) zu 2. Abstraktion hat Typ τ 1 τ 2 (T...) zu 3. (sc t1.. tn) hat Typ τ 1 τ 2 (T...) zu 4. ((c t 1... t n ) t): Typ von (c t 1...t n ) ist kein -Typ = Die Typregel für Anwendungen ist nicht anwendbar Einführung in die funktionale Programmierung, fol

49 Aussagen zu Typcheck Definition: t dynamisch ungetypt: gdw. t t und t direkt ungetypt Lemma Für dynamisch ungetypte Ausdrücke lässt sich kein Typ herleiten. Folgt aus obigen Lemmas: 1. Typ bleibt erhalten unter Reduktion 2. direkt dynamisch ungetypte t haben keinen Typ. Einführung in die funktionale Programmierung, fol

50 Keine Typfehler: Fortschrittslemma Progress-Lemma; Fortschrittslemma: (zb in KFPTSP) Für jeden geschlossenen, wohlgetypten Ausdruck t gilt: Entweder t ist eine WHNF; oder t hat eine Normalordnungsreduktion Einführung in die funktionale Programmierung, fol

51 Keine Typfehler: Fortschrittslemma Fortschrittslemma gilt nicht in KFPT für die erlaubten Ausdrücke zb (Cons Nil Nil) Nil ist keine WHNF, und hat keine Normalordnungsreduktion Fortschrittslemma gilt nicht für offene Ausdrücke: Einführung in die funktionale Programmierung, fol