Einführung in die Funktionale Programmierung mit Haskell

Transkript

1 Typsysteme Typisierung Polymorphie Typinferenz Einführung in die Funktionale Programmierung mit Haskell Typsysteme & Typinferenz LFE Theoretische Informatik, Institut für Informatik, Ludwig-Maximilians Universität, München 12. Juni 2013

2 Typsysteme Typisierung Polymorphie Typinferenz Planung Klausur: h Vorläufige Planung: Mi Vorlesung Do Vorlesung Fr Übung 17. Apr Apr Apr Apr Apr Apr Mai Mai Mai Mai Mai Mai Mai Mai Mai Mai Mai Mai Mai Mai Mai Jun Jun Jun Jun Jun Jun Jun Jun Jun Jun Jun Jun Jul Jul Jul Jul Jul Jul Jul Jul Jul 13 Sollumfang: 3+2 Raumbuchung: Termine, davon 3 Feiertage 4 Übung nachholen 6 Entfällt 1 Klausurtermin = 20V + 12Ü

3 Typsysteme Typisierung Polymorphie Typinferenz Typprüfung Wir haben bisher behauptet: Das statische Typsystem von Haskell prüft während dem Kompilieren alle Typen: Keine Typfehler und keine Typprüfung zur Laufzeit Kompiler findet bereits viele Programmierfehler Kompiler kann besser optimieren Well-typed programs can t go wrong! R. Milner Heute klären wir: Was genau sind Typfehler? Was ist der Unterschied zwischen getypten und ungetypten Sprachen? Wie bestimmt man den Typ eines Programmes?

4 Typsysteme Typisierung Polymorphie Typinferenz Typfehler Offensichtlich machen folgende Ausdrücke keinen Sinn: "Hello" * True a False && (\x -> "error") (*) 1 (+) (\f -> f 42) 69 if 3 * x then 42 else "nothing" Ist dies wirklich offensichtlich? Wie formalisieren wir die Intuition, welche Ausdrücke korrekt sind? Wie ist das in anderen Sprachen?

5 Typsysteme Typisierung Polymorphie Typinferenz Typsysteme in der Praxis In der Praxis gibt es durchaus unterschiedliche Ansätze zum Einsatz von Typsystemen in der Programmierung. Was passiert bei der Auswertung von (\f -> f 42) 69? Keine Typprüfung: 69 wird als Sprungaddresse interpretiert. Systemabsturz oder schwere Betriebssystem-Ausnahme möglich. Dynamische Typprüfung: Werte tragen zur Laufzeit Typ-Markierung Ganzzahl, Funktion,... Da 69 keine Funktion ist, wird eine Ausnahme im Laufzeitsystem geworfen. Statische Typprüfung: Der Übersetzer weigert sich, ein Programm mit Typfehlern zu übersetzen. Es kommt nie zu derartigen Laufzeitfehlern.

6 Typsysteme Typisierung Polymorphie Typinferenz Typsysteme in der Praxis Unterschiedliche Ansätze zum Einsatz von Typsystemen: Keine Typprüfung: Assembler Schnelle Ausführung; Viel Freiheit für Programmierer Keinerlei Sicherheit; Schwere Fehler möglich Dynamische Typprüfung: LISP, Scheme, BASIC, Skriptsprachen: JavaScript, Python Viel Freiheit für Programmierer Ständige Typrüfung zur Laufzeit verlangsamt Ausführung Statische Typprüfung: Haskell, SML, Ocaml, Scala, Eingeschränkt: C, Java Kompiler schliesst viele Fehler von vorn herein aus Eingeschränkte Freiheit beim Programmieren; Langwierige Fehlermeldung nerven beim Kompilieren

7 Programmausdrücke Zur Vereinfachung betrachten wir nur ein Haskell-Fragment. Der λ-kalkül (1936, Alonzo Church( )) beschreibt den funktionalen Kern von Haskell. Ein Programmausdruck e im Lambda-Kalkül ist: e ::= x Variable foo c Konstante e 1 e 2 Anwendung sqrt 5.0 λx.e Funktionsabstraktion (\x -> e) (e wie expression, engl. für Ausdruck ) Der Einfachheit verwenden wir die Haskell-Syntax Weitere Haskell-Ausdrücke werden nach Bedarf hinzugenommen Infix-Operatoren schreiben wir hier meist in präfix Notation, also (+) 2 7 anstatt 2 + 7

8 Typausdrücke Ein Typausdruck A is definiert durch: A, B ::= α β... Typvariable a, b Int Double String... Basistyp A B Funktionstyp Int -> Bool Wir beschränken uns auf Grund- und Funktionstypen; also keine Listen, keine Typklassen, etc. Funktionstypen sind weiterhin implizit rechts-geklammert: A B C = A (B C) (A B) C Eventuell verwenden wir Abkürzungen für Basistypen I, D, S,... anstatt Int, Double, String,....

9 Typzuweisung Eine Typzuweisung e::a ist ein Paar, bestehend aus einem Programmausdruck e und einen Typausdruck A, interpretiert als Aussage e hat Typ A 4 :: Int wahr true :: String falsch 3.3 :: a falsch \x -> x - 1 :: Int-> Int wahr \x y -> x :: a -> b -> a wahr \x y -> y :: a -> b -> a falsch z (x + 0) :: Bool??? Typzuweisungs-Aussagen können wahr oder falsch sein In der Literatur wird oft e::a anstatt e::a geschrieben Der Typausdruck z (x + 0) enthält unbekannte, freie Variablen x und z, deren Typ wir nicht kennen

10 Typkontext Ein Typ(isierungs)kontext Γ ist eine endliche Menge von Typzuweisungen Γ = {x 1 ::A 1,... x n ::A n } (n 0) wobei die Typvariablen x i paarweise verschieden sein müssen. (engl. typing context/environment) {x::bool, y::int Int} gültig {z::int Bool, x::int} gültig {h::int Bool, h::int} ungültig Γ ist endliche Abbildung von Variablen x auf Typen Γ(x) Die Reihenfolge der Typzuweisungen in Γ ist unbedeutend Wir schreiben Γ, x::a um x::a in Γ einzufügen; falls x dom(γ) dann ist Γ, x::a undefiniert

11 Typisierung Ein Typurteil ist eine Aussage der Form: Unter der Annahme, dass Variablen die in Γ angegebenen Typen haben, hat Ausdruck e den Typ A (engl. typing judgement) Wir schreiben kurz Γ e::a für Ausdruck e den Typ A in Kontext Γ. Formal ist : eine dreistellige Relation zwischen Typkontexten, Ausdrücken, und Typen. Beispiele: {x::int} \y (+) x y : Int Int gültig {x::bool} \y (+) x y : Int Int ungültig {y : α} \x y : β α gültig

12 Typregeln Ein Typurteil ist nur dann gültig, wenn es durch Typregeln hergeleitet werden kann. Typregeln haben immer die Form: P 1... P n K (Name der Typregel) Dabei sind P 1... P n die Prämissen der Typregel und K die Konklusion. Sind alle Prämissen gültig, dann auch die Konklusion. P i und K sind in der Regel Typurteile Typregeln ohne Prämissen heißen Axiome Z.B. für jede Konstante c gibt es ein Typaxiom.

13 Typregel Var Der Typ einer Variablen ist durch den Kontext gegeben: (x::a) Γ Γ x::a (Var) Da Γ als endliche Abbildung aufgefasst werden kann, können wir diese Typregel auch äquivalent kurz schreiben durch: Γ x::γ(x) (Var) Beispiele: {x::double} x::double gültig {x::double, y::int, z::bool} y::int gültig {x::double, y::int, z::bool} y::double falscher Typ {} x::double ungebundene Variable

14 Typregel Const Für jede Konstante eines jeden Basistypen definieren wir ein Axiom (Regel ohne Prämisse), welches die Konstante erkennt: Γ True::Bool (True) Γ False::Bool (False) Dabei ist der Kontext Γ hier beliebig, d.h. wir definieren ein Axiomenschema für jedes Γ. Mehrere Konstanten fassen wir mit folgenden Schemen zusammen: c ist eine Integer Konstante c ist eine Double Konstante Γ c::int Γ c::double (Int) (Double) Es ist sowohl {} 5::Int als auch {} 5::Double herleitbar. Dies ist unproblematisch so lange wir Typklassen ignorieren.

15 Typregel Funktionsanwendung Anwendung einer Funktion e 1 mit Typ A B auf Argument e 2 von Typ A liefert ein Ergebnis des Typs B: Γ e 1 ::A B Γ e 1 e 2 ::B Γ e 2 ::A (App) Diese Regel ist nicht anwendbar, falls: e 1 nicht von einem Funktionstypen ist e 2 nicht von Typ A ist, d.h. nicht im Definitionsbereich liegt. Beispiel: {x::bool Bool, y::bool} x::bool Bool {x::bool Bool, y::bool} y::bool {x::bool Bool, y::bool} xy::bool (App)

16 Beispiel Funktionsanwendung Γ e 1 :: A B Γ e 1 e 2 :: B Γ e 2 :: A (App) Zur Anwendung der allgemeinen Typregel werden Metavariablen gemäß Kontext, Ausdruck und Typ instanziiert: Γ \z (+) z x::int Int Γ ( ) 2 y::int Γ ( \z (+) z x ) ( ( ) 2 y ) (App) :: Int... ist z.b. herleitbar für Γ = {x::int, y :: Int}. Alternative Schreibweise in Infix-Notation: Γ \z z + x :: Int Int Γ ( \z z + x ) ( 2 y ) :: Int Γ 2 y :: Int (App)

17 Beispiel Funktionsanwendung Γ e 1 :: A B Γ e 1 e 2 :: B Γ e 2 :: A (App) Zur Anwendung der allgemeinen Typregel werden Metavariablen gemäß Kontext, Ausdruck und Typ instanziiert: Γ \z (+) z x::int Int Γ ( ) 2 y::int Γ ( \z (+) z x ) ( ( ) 2 y ) (App) :: Int... ist z.b. herleitbar für Γ = {x::int, y :: Int}. Alternative Schreibweise in Infix-Notation: Γ \z z + x :: Int Int Γ ( \z z + x ) ( 2 y ) :: Int Γ 2 y :: Int (App)

18 Typregel Funktionsabstraktion Die Typregel für anonyme Funktionsabstraktion lautet: Γ, x::a e::b Γ \x e :: A B (Abs) Hat der Programmausdruck e den Typ B unter der Annahme x : A, so hat der Programmausdruck \x e den Typ A B Man nennt e den Funktionsrumpf der Funktion \x e, im Funktionsrumpf kommt die abstrahierte Variable x frei vor, in dem Programmausdruck \x e gebunden. Man sagt auch Lambda \ bindet die darauf folgende Variable

19 Typherleitung Eine Typherleitung / Typbeweis ist ein endlicher Baum, wobei alle die Blätter Typaxiome sind; alle Knoten derart Instanzen von Typregeln sind, dass die Beschriftung des Knotens die Konklusion ist, und die Kinder des Knotens die Prämissen sind. Die Beschriftung des Wurzelknotens ist die hergeleitete Aussage. Eine Typaussage ist herleitbar, wenn sie eine Herleitung hat. Eine Typherleitung ist letztendlich nur eine verkette Anwendung von Typregeln.

20 Beispiel Herleitungsbaum Eine Herleitung als Baum dargestellt: Var Var {x::α, f ::α β} f :: α β {x::α, f ::α β} x :: α App {x::α, f ::α β} f x :: β Abs {x::α} \f f x :: (α β) β Abs {} \x (\f f x) :: α (α β) β Den Namen der angewendeten Regel schreiben wir an den rechten Rand, damit man besser nachvollziehen kann, was gemacht wurde. In Haskell könnten wir anstatt \x (\f f x) auch einfach \x f f x schreiben, doch unsere Typregel Abs haben wir der Einfachheit halber nur für ein Argument definiert was ja keinen Unterschied macht!

21 Beispiel Herleitungen Eine Herleitung in linearer Schreibweise: 1 {x::α, f ::α β} f ::α β Var 2 {x::α, f ::α β} x::α Var 3 {x::α, f ::α β} f x::β App(1, 2) 4 {x::α} \f f x::(α β) β Abs(3) 5 {} \x (\f f x)::α (α β) β Abs(4) Bei dieser Schreibweise müssen wir alle Zeilen nummerieren. Bei jeder Regelanwendung listen wir dann die verwendeten Prämissen der Reihe nach auf. Erstellt werden Herleitungen normalerweise von unten nach oben, gelesen werden sie aber meist von oben nach unten.

22 Kontexterweiterung Eine Typaussage bleibt gültig, wenn wir den Typisierungkontext erweitern. Bsp: {x::α} \f f x :: (α β) β {x::α, y::γ} \f f x :: (α β) β {f ::Int Bool, x::α, y::γ} \f f x :: (α β) β Lemma (Kontexterweiterung/Abschwächung) Wenn Γ Γ und Γ e : A herleitbar ist, dann auch Γ e : A. Beweisbar durch Induktion über die Länge der Herleitung. Daraus leiten wir folgende strukturelle Typregel ab: Γ Γ Γ e : A Γ e : A (Weak) Die Regel ist jederzeit anwendbar, da sie unabhängig von e ist.

23 Einführung in die Funktionale Programmierung mit Haskell Typsysteme & Typinferenz LFE Theoretische Informatik, Institut für Informatik, Ludwig-Maximilians Universität, München 19. Juni 2013

24 Typregeln Wdh. Ein Typurteil ist nur dann gültig, wenn es durch Typregeln hergeleitet werden kann. Typregeln haben immer die Form: P 1... P n K (Name der Typregel) Dabei sind P 1... P n die Prämissen der Typregel und K die Konklusion. Sind alle Prämissen gültig, dann auch die Konklusion. P i und K sind in der Regel Typurteile Typregeln ohne Prämissen heißen Axiome Z.B. für jede Konstante c gibt es ein Typaxiom.

25 Bisher behandelte Typregeln Wdh Folgende Typregeln wurden bisher in der Vorlesung behandelt: Γ x :: Γ(x) c ist eine Integer Konstante Γ c :: Int Γ e 1 :: A B Γ e 2 :: A Γ e 1 e 2 :: B Γ, x::a e :: B Γ \x e :: A B (Var) (Int) (App) (Abs)

26 Typherleitung Beispiel An der Tafel konstruieren wir eine Typherleitung für das Typurteil: { (+)::Int Int Int, z::α } (+) 4 ( (\x -> 1) z ) :: Int

27 Weakening Wdh Wir hatten gesehen, dass folgende Typregel zulässig ist, da Kontexterweiterungen harmlos sind: Γ Γ Γ e : A Γ e : A (Weak) Intuitiv: Es schadet nie, mehr zu wissen als nötig Eine Typregel ist zulässig (engl. admissible), wenn deren Hinzunahme keine neuen Herleitungen ermöglicht. D.h. die Regel kann Herleitungen lediglich vereinfachen.

28 Exchange Da wir Typkontexte als Mengen von Typzuweisungen definiert haben, ist die Reihenfolge der Typannahmen bedeutungslos. Dies können wir ebenfalls durch eine zulässige Regel ausdrücken: Γ, x::a, y::b, e :: C Γ, y::b, x::a, e :: C (Exchange)

29 Kontraktion Mehrfachverwendung von Variablen ist harmlos: Γ, x::a, y::a e :: C Γ, z::a e[z/x, z/y] :: C (Contraction) Termsubstitution: e[z/x, z/y] bezeichnet den Term e, bei den alle freie Vorkommen von x und y ersetzt werden.

30 Termsubstitution: Wir definieren Substitution für Terme wir folgt: x[e 0 /x] := e 0 y[e 0 /x] := y (e 1 e 2 )[e 0 /x] := e 1 [e 0 /x] e 2 [e 0 /x] (\y -> e 1 )[e 0 /x] := \x -> e 1 [e 0 /x] falls y / FV(e 0 ) (\x -> e 1 )[e 0 /x]:= \x -> e 0 (\y -> e 1 )[e 0 /x]:= \y -> (e 1 [y /y])[e 0 /x] für y eine frische Variable Bei Substitutionen muss man aufpassen, dass freie Variablen nicht versehentlich eingefangen werden: Wir schreiben kurz e 0 [e 1 /x, e 2 /y] für ( e 0 [e 1 /x] ) [e 2 /y], d.h. mehrere Substitution arbeiten wir von links nach rechts ab.

31 Strukturelle Typregeln Üblicherweise gelten diese drei strukturellen Typregeln implizit, wenn nichts anderes angegeben wurde. Zusätzliche Annahmen sind harmlos: Γ Γ Γ e : A Γ e : A (Weak) Reihenfolge der Annahmen ist bedeutungslos: Γ, x::a, y::b, e :: C Γ, y::b, x::a, e :: C (Exchange) Eine Variable kann mehrfach verwendet werden: Γ, x::a, y::a e :: C z / FV(e) (Contraction) Γ, z::a e[z/x, z/y] :: C

32 Bisher behandelte Typregeln II Übung 7 behandelte Typregeln für Bildung von Paaren und deren Elimination durch Pattern-Matching so wie if-then-else Ausdrücke: Γ e 1 :: A Γ e 2 :: B Γ (e 1, e 2 ) :: (A, B) (Pair-Intro) Γ e 1 :: (B, C) Γ, x::b, y::c e 2 :: A (Pair-Elim) Γ let (x, y) = e 1 in e 2 :: A Γ e 1 : Bool Γ e 2 : A Γ e 3 : A Γ if e 1 then e 2 else e 3 : A (Cond) Dabei wurden neue Programm- und Typ-ausdrücke eingeführt.

33 Typregeln Paare Neue Programmausdrücke: (e 1, e 2 ) Paar-Introduktion let (x, y) = e 1 in e 2 Paar-Elimination Neuer Typausdruck: (A, B) Neue Typregeln: Γ e 1 :: A Γ e 2 :: B Γ (e 1, e 2 ) :: (A, B) (Pair-Intro) Γ e 1 :: (B, C) Γ, x::b, y::c e 2 :: A (Pair-Elim) Γ let (x, y) = e 1 in e 2 :: A Bedeutung: Typ eines Paares ist das Produkt der Typen der Einzelteile

34 Curry-Howard-Isomorphismus Beobachtung Regeln treten of in Paaren auf: zur Einführung eines Typs und zu Elimination eines Typs Abs/App, Pair-Intro/Pair-Elim Dies ist sehr ähnlich zur mathematischen Beweisführung im Hilbert-Stil, welche ebenfalls Herleitungsbäume verwendet. Curry-Howard-Isomorphismus Ein Typ kann als logische Formel aufgefasst werden. Gibt es einen Programmausdruck zu einem Typ, so ist die entsprechende logische Formel intuitionistisch beweisbar. Typ A B entspricht der logischen Implikation, Typ (A, B) entspricht dem logischen und, usw. Beobachtet durch Curry & Feys (1958) und Howard (1969) Anwendung Übertragung von Erkenntnissen zwischen Fachgebieten, Konstruktion von Beweisassistenten, Automatische Programmextraktion aus intuitionistischen Beweisen

35 Typregel Konditional Neuer Programmausdruck: if e 1 then e 2 else e 3 Neue Typregel: Γ e 1 :: Bool Γ e 2 :: A Γ e 3 :: A Γ if e 1 then e 2 else e 3 :: A (Cond) Bedeutung: Bedingung muss Typ Bool haben Zweige müssen vom gleichen Typ wie Gesamtausdruck sein

36 Safety = Progress + Preservation Eine Typherleitung ist ein formaler Beweis, dass ein Typausdruck einen bestimmten Typ hat. Was nutzt das? Wir behaupteten: Well-typed programs can t go wrong Dies beweist man üblicherweise in 2 Schritten: Progress Jeder wohl-typisierte Programmausdruck ist entweder ein Wert oder er kann weiter ausgewertet werden. Preservation Auswertung verändert den Typ eines Programmausdrucks nicht. Für diese Beweise müssten wir Substitutionsmodell durch Auswerteregeln formalisieren, wie z.b. Operationale Semantik e 1 [e 2 /x] v (\x -> e 1 ) e 2 v ( -App)

37 Beweisidee: Solche Beweise werden üblicherweise mit Induktion über die Länge der Typherleitung geführt: Um zu zeigen, dass if e 1 then e 2 else e 3 ausgewertet werden kann, darf man annehmen dann, dass e 1 zu einem Wert ausgewertet werden kann, da die Typherleitung für Γ e 1 : Bool ja ein Schritt kleiner sein muss; usw. e 1 True e 2 v if e 1 then e 2 else e 3 v Γ e 1 :: Bool Γ e 2 :: A Γ e 3 :: A Γ if e 1 then e 2 else e 3 :: A ( -If-T) (Cond) Auswerteregeln und Typregeln müssen übereinstimmen. Auswerteregeln und Implementation müssen übereinstimmen.

38 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Polymorphie Wie wir wissen, können Ausdrücke mehr als einen Typ haben, z.b. für den Programmausdruck f x sind herleitbar: {x::int, f ::Int Int} f x :: Int {x::bool, f ::Bool Int} f x :: Int {x::α, f ::α α} f x :: α {x::α, f ::α β} f x :: β Letzte hier die allgemeinste Typisierung (engl. principal typing): jede andere Typisierung von f x erhält man daraus durch Einsetzen von Typen für die Typvariablen α und β (Instanziierung). {x::α, f ::α β}[bool/α, Int/β] f x :: β[bool/α, Int/β] Man kann beweisen: Allgemeinste Typisierung eines Ausdrucks ist bis auf Umbenennung von Typvariablen eindeutig.

39 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Typsubstitutionen Eine Typsubstitution σ ist eine endliche Abbildung von Typvariablen α auf Typausdrücke A. σ 1 = [Bool/α, Int/β] = [Bool/α, Int/β, γ/γ] = [Bool/α, Int/β, γ/γ, δ/δ]... σ 2 = [β/α, (β Bool)/β, Int/γ] σ 3 = [γ/α, δ/β] σ 4 = [β/α, α/β] Für die Anwendung Aσ einer Substitution σ auf Typen A gilt z.b.: Int σ = Int (A B)σ = Aσ Bσ α[bool/α, Int/β] = Bool Da bei uns alle Typvariablen frei sind, gibt es keine vergleichbaren Probleme wir bei der Termsubstitution.

40 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Instanziierung Wir definieren die Anwendung einer einer Substitution σ auf einen Typkontext Γ punktweise: Beispiel (Γσ)(x) := (Γ(x))σ {x::int, y::α β, z::α}[γ/α, Int/β, Bool/γ] = {x::int, y::bool Int, z::bool} Es ist beweisbar, dass Typurteile unter Substitution gültig bleiben: Lemma (Typerhaltung unter Substitution) Wenn Γ e :: A, dann Γσ e :: Aσ. Wir leiten daraus erneut eine zulässige Typregel ab: Γ e :: A Γσ e :: Aσ (subst)

41 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Substitutionskomposition Die Komposition σσ zweier Substitutionen definieren wir wieder von links nach rechts: A(σ 1 σ 2 ) := (Aσ 1 )σ 2 Eine Komposition können wir oft vereinfachen: α[(α β)/α][int/α, Bool/β] = (α β)[int/α, Bool/β] = Int Bool β[(α β)/α][int/α, Bool/β] = β[int/α, Bool/β] = Bool [(α β)/α][int/α, Bool/β] = [(Int Bool)/α, Bool/β] Komposition ist assoziativ, σ 1 (σ 2 σ 3 ) = (σ 1 σ 2 )σ 3, aber nicht kommutativ σ 1 σ 2 σ 2 σ 1 Als neutrales Element der Komposition haben wir die leere Identitätssubstitution id = []. Es gilt id σ = σ und σ id = σ.

42 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Prinzipale Typisierung Eine Typisierung Γ e :: A eines Ausdrucks e ist die allgemeinste oder auch prinzipal Typisierung, falls es für jede Typisierung Γ e :: A von e eine Substitution σ gibt, so dass A = Aσ und Γ Γσ. {x::α, f ::α β} f x :: β prinzipal {x::int, f ::Int Int} f x :: Int σ = [Int/α, Int/β] {x::α, f ::α β, y::γ} f x :: β σ = id {x::γ, f ::γ β} f x :: β σ = [γ/α] (auch prinzipal) Mann kann beweisen, dass jeder Programmausdruck unserer eingeschränkten Sprache eine prinzipale Typisierung hat! Für volles Haskell gilt dies aber nicht mehr. Die Berechnung einer prinzipalen Typisierung für einen Programmausdruck ist oft unentscheidbar. unentscheidbar: kein Verfahren mit endlicher Laufzeit bekannt

43 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Monomorphismus Einschränkung In Haskell ist die Suche nach allgemeinen Typen grundsätzlich eingeschränkt: > :t show show :: Show a => a -> String > let f1 = show f1 :: () -> String > let f2 x = show x f2 :: Show a => a -> String > let f3 = \x -> show x f3 :: () -> String Option NoMonomorphismRestriction erweitert die Suche: > :set -XNoMonomorphismRestriction > let f4 = show f4 :: Show a => a -> String

44 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Monomorphismus Einschränkung Diese Option hat aber auch weitere Nachteile: lentwo = (len,len) where len = Data.List.genericLength xs Für den Typ lentwo :: Num t => [b] -> (t, t) muss die Länge nur einmal berechnet werden, aber für den Typ lentwo :: (Num a, Num b) => [c] -> (a,b) muss die Länge zwei Mal berechnet werden, da die grundlegenden Operationen (z.b. Addition) ja anders implementiert sein könnten. Wenn man Typsignaturen explizit angibt, dann braucht man die Option ohnehin nicht, da Haskell dann einfach nur den gegeben Typ prüft.

45 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Polymorphe Rekursion Polymorphe Rekursion bezeichnet rekursive Aufrufe mit anderem Typ; genauer: polymorphe Typparameter werden anders instantiiert. Polymorphe Rekursion ist sehr problematisch für Typinferenz. Es wurde bewiesen, dass Typinferenz für polymorphe Rekursion unentscheidbar ist. Beispiel data PowerList a = Zero a Succ (PowerList (a,a)) pl1 = Succ $ Succ $ Succ $ Zero (((1,2),(3,4)),((5,6),(7,8))) pllength :: PowerList a -> Int -- GHC cannot infer this type! pllength (Zero _ ) = 1 pllength (Succ pl) = 2 * pllength pl Im Rumpf der Definition für pllength :: PowerList a -> Int findet ein rekursiver Aufruf mit Typ PowerList (a,a) -> Int statt.

46 Typsysteme Typisierung Polymorphie Typinferenz Typsubstitutionen Prinzipale Typisierung Inferenzprobleme Rank N-Types Die Spracherweiterungen um GADTs und Rank N-Types bereiten der Typinferenz ebenfalls Probleme Beide Themen gehen jedoch über den Rahmen der Vorlesung heraus. Rank N-Types sind Typen, bei denen Quantoren für Typvariablen mitten im Typ auftauchen, und nicht nur wie bisher ganz vorne. Pathologisches Beispiel -- foo :: (forall a. a) -> b foo :: (forall a. a -> a) -> (b -> b) foo x = x x > (foo (foo id)) Keine der beiden Typsignaturen kann von GHC inferiert werden. foo hat keinen prinzipalen Typ.

47 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Typinferenz Typinferenz berechnet zu jedem Ausdruck den allgemeinsten Typ (bzw. Fehlermeldung, falls der Ausdruck keinen Typ hat). Beispiel Der prinzipale Typ einer Funktionsanwendung e 1 e 2 muss aus den prinzipalen Typen von e 1 und e 2 berechnet werden: {} e 1 :: (Int β) (γ β) {x::α} e 2 :: α Double {x::int} e 1 e 2 :: γ Double Beide Prämissen müssen mit [Int/α, Double/β] instanziiert werden, welche die allgemeinste Lösung der Gleichung Int β = α Double ist. Dazu müssen wir also Typgleichung lösen können.

48 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Unifikation Eine Substitution σ ist allgemeiner als σ, falls es eine Substitution τ gibt mit σ = στ. Die speziellere Substitution σ ist also eine Instanz von σ. Zum Lösen von Typgleichungen verwenden wir Unifikation: Ein Unifikator zweier Typen A und A ist eine Substitution σ, so dass Aσ = A σ. Der allgemeinste Unifikator von A und A ist die allgemeinste Substitution σ, so dass Aσ = A σ. Beispiel: (α β) = (Int β) für diese Typgleichung ist [Int/α, Int/β] ein Unifikator. Die Substitution [Int/α] ist der allgemeinste Unifikator.

49 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Robinson s Unifikationsalgorithmus Der Unifikationsalgorithmus unify arbeitet auf einer Menge E = {A 1 = B 1,..., A n = B n } von Typgleichungen und liefert allgemeinste Substitution σ, so dass A i σ = B i σ für alle i gilt oder einen Typfehler. Algorithmus unify: 1 unify({}) = id - -Fertig 2 unify({a = A} E) = unify(e) - -redundante Gleichung 3 unify({a A = B B } E) = unify({a = B, A = B } E) 4 unify({α = B} E) = unify({b = α} E) = falls α in B erwähnt wird: Fehlermeldung Zirkulär, sonst berechne Komposition σ unify(eσ) für σ = [B/α] 5 In allen andern Fällen: Fehlermeldung Typfehler z.b. wenn (Int = Bool) oder (Int = α β) E sind.

50 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Beispiele Unifikation Nur Variablen: unify{α = β, β = γ} = [β/α]unify{β = γ} = [β/α][γ/β]unify{} = [β/α][γ/β]id = [β/α][γ/β] = [γ/α, γ/β] Typkonstruktorkonflikt: unify{int α = α Double} = unify{int = α, α = Double} = [Int/α]unify{Int = Double} = Error: Typfehler Zirkulärer Typ: unify{β = β, α = α Double} = unify{α = α Double} = Error: Zirkulär

51 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Typinferenzalgorithmus I infer Γ (e) = (A, σ) nimmt einen Ausdruck e in Typkontext Γ und liefert den allgemeinsten Typ A von e samt der allgemeinsten Instanziierung σ von Γ, so dass Γσ e :: A. 1 infer Γ (x) = wenn x::a Γ dann (A, id) sonst Fehlermeldung Ungebundene Variable 2 infer Γ (c) = (A, id) wobei A der Typ der Konstanten c ist. 3 infer Γ (\x -> e) = Für eine frische Typvariable α berechne zuerst infer Γ,x::α (e) = (B, σ) Damit gilt (Γσ, x::ασ) e :: B und wir liefern (ασ B, σ)

52 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Typinferenzalgorithmus II Applikation infer Γ (e) = (A, σ) nimmt einen Ausdruck e in Typkontext Γ und liefert den allgemeinsten Typ A von e samt der allgemeinsten Instanziierung σ von Γ, so dass Γσ e :: A. 4 infer Γ (e 1 e 2 ) = Wir berechnen zuerst infer Γ (e 1 ) = (C, σ 1 ) und infer Γ (e 2 ) = (A, σ 2 ). Für eine frische Typvariable β berechne σ 3 = unify{cσ = A β}. Damit gilt Γσ 1 σ 2 σ 3 e 1 :: Aσ 3 βσ 3 und wir liefern (βσ 3, σ 1 σ 2 σ 3 ) zurück. Dieser Algorithmus geht auf mehrere Personen zurück: Ursprung bei Curry & Feys (1958) Erweitert und Allgemeinheit bewiesen bei Hindley (1969) Milner zeigte 1979 unabhängig das Geliche wie Hindley Erweitert unf Vollstänsigkeit bewiesen von Damas (1982)

53 Typsysteme Typisierung Polymorphie Typinferenz Unifikation Zusammenfassung Zusammenfassung Well-typed programs can t go wrong Typisierung in Form von Typurteilen: Γ e::a. Kontrolle eines Typs durch Typherleitung. Robin Milner Eine Typherleitung hat eine Baum-Struktur. Wenn alle Blätter Axiome sind, dann ist die Herleitung ein Beweis. Typinferenz beruht auf Unifikation. Prinzipale Typen in vielen Sprache berechenbar.