Einführung in Funktionale Programmierung Typisierung

Transkript

1 Einführung in Funktionale Programmierung Typisierung PD Dr. David Sabel WS 2015/16 Stand der Folien: 19. November 2015

2 Motivation Typen Typisierungsverfahren Ziele des Kapitels Warum typisieren? Typisierungsverfahren für Haskell bzw. KFPTS+seq für parametrisch polymorphe Typen Iteratives Typisierungsverfahren Milnersches Typisierungsverfahren D. Sabel EFP WS 2015/16 Typisierung 2/106

3 Motivation Typen Typisierungsverfahren Übersicht D. Sabel EFP WS 2015/16 Typisierung 3/106

4 Motivation Typen Typisierungsverfahren Motivation Warum ist ein Typsystem sinnvoll? Für ungetypte Programme können dynamische Typfehler auftreten Fehler zur Laufzeit sind Programmierfehler Starkes und statisches Typsystem = keine Typfehler zu Laufzeit Typen als Dokumentation Typen bewirken besser strukturierte Programme Typen als Spezifikation in der Entwurfsphase D. Sabel EFP WS 2015/16 Typisierung 4/106

5 Motivation Typen Typisierungsverfahren Motivation (2) Minimalanforderungen: Die Typisierung sollte zur Compilezeit entschieden werden. Korrekt getypte Programme erzeugen keine Typfehler zur Laufzeit. D. Sabel EFP WS 2015/16 Typisierung 5/106

6 Motivation Typen Typisierungsverfahren Motivation (2) Minimalanforderungen: Die Typisierung sollte zur Compilezeit entschieden werden. Korrekt getypte Programme erzeugen keine Typfehler zur Laufzeit. Wünschenswerte Eigenschaften: Typsystem schränkt wenig oder gar nicht beim Programmieren ein Compiler kann selbst Typen berechnen = Typinferenz D. Sabel EFP WS 2015/16 Typisierung 5/106

7 Motivation Typen Typisierungsverfahren Motivation (3) Es gibt Typsysteme, die diese Eigenschaften nicht erfüllen: Z.B. Simply-typed Lambda-Calculus: Getypte Sprache ist nicht mehr Turing-mächtig, da dieses Typsystem erzwingt, dass alle Programme terminieren Erweiterungen in Haskells Typsystem: Typisierung / Typinferenz ist unentscheidbar. U.U. terminiert der Compiler nicht!. Folge: mehr Vorsicht/Anforderungen an den Programmierer. D. Sabel EFP WS 2015/16 Typisierung 6/106

8 Motivation Typen Typisierungsverfahren Naiver Ansatz Naive Definition von korrekt getypt : Ein KFPTS+seq-Programm ist korrekt getypt, wenn es keine dynamischen Typfehler zur Laufzeit erzeugt. D. Sabel EFP WS 2015/16 Typisierung 7/106

9 Motivation Typen Typisierungsverfahren Naiver Ansatz Naive Definition von korrekt getypt : Ein KFPTS+seq-Programm ist korrekt getypt, wenn es keine dynamischen Typfehler zur Laufzeit erzeugt. Funktioniert nicht gut, denn Die dynamische Typisierung in KFPTS+seq ist unentscheidbar! D. Sabel EFP WS 2015/16 Typisierung 7/106

10 Motivation Typen Typisierungsverfahren Unentscheidbarkeit der dynamischen Typisierung Sei tmencode eine KFPTS+seq-Funktion, die sich wie eine universelle Turingmaschine verhält: Eingabe: Turingmaschinenbeschreibung und Eingabe für die TM Ausgabe: True, falls die Turingmaschine anhält Beachte: tmencode ist in KFPTS+seq definierbar und nicht dynamisch ungetypt (also dynamisch getypt) (Haskell-Programm auf der Webseite) D. Sabel EFP WS 2015/16 Typisierung 8/106

11 Motivation Typen Typisierungsverfahren Unentscheidbarkeit der dynamischen Typisierung (2) Für eine TM-Beschreibung b und Eingabe e sei s := if tmencode b e then case Bool Nil of {True True; False False} else case Bool Nil of {True True; False False} Es gilt: s ist genau dann dynamisch ungetypt, wenn die Turingmaschine b auf Eingabe e hält. Daher: Wenn wir dynamische Typisierung entscheiden könnten, dann auch das Halteproblem Satz Die dynamische Typisierung von KFPTS+seq-Programmen ist unentscheidbar. D. Sabel EFP WS 2015/16 Typisierung 9/106

12 Typen Motivation Typen Typisierungsverfahren Syntax von polymorphen Typen: T ::= T V T C T 1... T n T 1 T 2 wobei T V Typvariable, T C Typkonstruktor Sprechweisen: Ein Basistyp ist ein Typ der Form T C, wobei T C ein nullstelliger Typkonstruktor ist. Ein Grundtyp (oder alternativ monomorpher Typ) ist ein Typ, der keine Typvariablen enthält. Beispiele: Int, Bool und Char sind Basistypen. [Int] und Char -> Int sind keine Basistypen aber Grundtypen. [a] und a -> a sind weder Basistypen noch Grundtypen. D. Sabel EFP WS 2015/16 Typisierung 10/106

13 Motivation Typen Typisierungsverfahren Typen (2) Wir verwenden für polymorphe Typen die Schreibweise mit All-Quantoren: Sei τ ein polymorpher Typ mit Vorkommen der Variablen α 1,..., α n Dann ist α 1,..., α n.τ der all-quantifizierte Typ für τ. Da Reihenfolge egal, verwenden wir auch X.τ wobei X Menge von Typvariablen Später: Allquantifizierte Typen dürfen kopiert und umbenannt werden, Typen ohne Quantor dürfen nicht umbenannt werden! D. Sabel EFP WS 2015/16 Typisierung 11/106

14 Motivation Typen Typisierungsverfahren Typsubstitutionen Eine Typsubstitution ist eine Abbildung einer endlichen Menge von Typvariablen auf Typen, Schreibweise: σ = {α 1 τ 1,..., α n τ n }. Formal: Erweiterung auf Typen: σ E : Abbildung von Typen auf Typen σ E (T V ) := σ(t V ), falls σ die Variable T V abbildet σ E (T V ) := T V, falls σ die Variable T V nicht abbildet σ E (T C T 1... T n ) := T C σ E (T 1 )... σ E (T n ) σ E (T 1 T 2 ) := σ E (T 1 ) σ E (T 2 ) Wir unterscheiden im folgenden nicht zwischen σ und der Erweiterung σ E! D. Sabel EFP WS 2015/16 Typisierung 12/106

15 Motivation Typen Typisierungsverfahren Semantik eines polymorphen Typs Grundtypen-Semantik für polymorphe Typen: sem(τ) := {σ(τ) σ(τ) ist Grundtyp, σ ist Substitution} Entspricht der Vorstellung von schematischen Typen: Ein polymorpher Typ ist ein Schema für eine Menge von Grundtypen D. Sabel EFP WS 2015/16 Typisierung 13/106

16 Motivation Typen Typisierungsverfahren Typregeln Bekannte Regel: s :: T 1 T 2, t :: T 1 (s t) :: T 2 Problem: Man muss richtige Instanz raten, z.b. map :: (a -> b) -> [a] -> [b] not :: Bool -> Bool Typisierung von map not: Vor Anwendung der Regel muss der Typ von map instanziiert werden mit σ = {a Bool, b Bool} Statt σ zu raten, kann man σ berechnen: Unifikation D. Sabel EFP WS 2015/16 Typisierung 14/106

17 Motivation Typen Typisierungsverfahren Unifikationsproblem Definition Ein Unifikationsproblem auf Typen ist gegeben durch eine Menge Γ von Gleichungen der Form τ 1 = τ 2, wobei τ 1 und τ 2 polymorphe Typen sind. Eine Lösung eines Unifikationsproblem Γ auf Typen ist eine Substitution σ (bezeichnet als Unifikator), so dass σ(τ 1 ) = σ(τ 2 ) für alle Gleichungen τ 1 = τ 2 des Problems. Eine allgemeinste Lösung (allgemeinster Unifikator, mgu = most general unifier) von Γ ist ein Unifikator σ, so dass gilt: Für jeden anderen Unifikator ρ von Γ gibt es eine Substitution γ so dass ρ(x) = γ σ(x) für alle x FV (Γ). D. Sabel EFP WS 2015/16 Typisierung 15/106

18 Motivation Typen Typisierungsverfahren Unifikationsalgorithmus Datenstruktur: Γ = Multimenge von Gleichungen Multimenge Menge mit mehrfachem Vorkommen von Elementen Γ Γ sei die disjunkte Vereinigung von zwei Multimengen Γ[τ/α] ist definiert als {s[τ/α] = t[τ/α] (s = t) Γ}. Algorithmus: Wende Schlussregeln (s.u.) solange auf Γ an, bis Fail auftritt, oder keine Regel mehr anwendbar ist D. Sabel EFP WS 2015/16 Typisierung 16/106

19 Motivation Typen Typisierungsverfahren Unifikationsalgorithmus: Schlussregeln Fail-Regeln: Fail1 Γ {(T C 1 τ 1... τ n ) = (T C 2 τ 1... τ m)} Fail wenn T C 1 T C 2 Fail2 Γ {(T C 1 τ 1... τ n ) = (τ 1 τ 2)} Fail Fail3 Γ {(τ 1 τ 2) = (T C 1 τ 1... τ n )} Fail D. Sabel EFP WS 2015/16 Typisierung 17/106

20 Motivation Typen Typisierungsverfahren Unifikationsalgorithmus: Schlussregeln (2) Dekomposition: Decompose1 Γ {T C τ 1... τ n = T C τ 1... τ n} Γ {τ 1 = τ 1,..., τ n = τ n} Decompose2 Γ {τ 1 τ 2 = τ 1 τ 2} Γ {τ 1 = τ 1, τ 2 = τ 2} D. Sabel EFP WS 2015/16 Typisierung 18/106

21 Motivation Typen Typisierungsverfahren Unifikationsalgorithmus: Schlussregeln (3) Orientierung, Elimination: Orient Γ {τ 1 = α} Γ {α = τ 1 } wenn τ 1 keine Typvariable und α Typvariable Elim Γ {α = α} Γ wobei α Typvariable D. Sabel EFP WS 2015/16 Typisierung 19/106

22 Motivation Typen Typisierungsverfahren Unifikationsalgorithmus: Schlussregeln (4) Einsetzung, Occurs-Check: Γ {α = τ} Solve Γ[τ/α] {α = τ} wenn Typvariable α nicht in τ vorkommt, aber α kommt in Γ vor OccursCheck Γ {α = τ} Fail wenn τ α und Typvariable α kommt in τ vor D. Sabel EFP WS 2015/16 Typisierung 20/106

23 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} D. Sabel EFP WS 2015/16 Typisierung 21/106

24 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} Beispiel 2: {[d] = c, a [a] = Bool c}: {[d] = c, a [a] = Bool c} D. Sabel EFP WS 2015/16 Typisierung 21/106

25 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Beispiel 2: {[d] Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} = c, a [a] = Bool c}: Decompose2 {[d] = c, a [a] = Bool c} {[d] = c, a = Bool, [a] = c} D. Sabel EFP WS 2015/16 Typisierung 21/106

26 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Beispiel 2: {[d] Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} = c, a [a] = Bool c}: Decompose2 {[d] = c, a [a] = Bool c} {[d] = c, a = Bool, [a] = c} Orient {[d] = c, a = Bool, c = [a]} D. Sabel EFP WS 2015/16 Typisierung 21/106

27 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Beispiel 2: {[d] Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} = c, a [a] = Bool c}: Decompose2 {[d] = c, a [a] = Bool c} {[d] = c, a = Bool, [a] = c} Orient {[d] = c, a = Bool, c = [a]} Solve {[d] = [a], a = Bool, c = [a]} D. Sabel EFP WS 2015/16 Typisierung 21/106

28 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Beispiel 2: {[d] Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} = c, a [a] = Bool c}: Decompose2 {[d] = c, a [a] = Bool c} {[d] = c, a = Bool, [a] = c} Orient {[d] = c, a = Bool, c = [a]} Solve {[d] = [a], a = Bool, c = [a]} Solve {[d] = [Bool], a = Bool, c = [Bool]} D. Sabel EFP WS 2015/16 Typisierung 21/106

29 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Beispiel 2: {[d] Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} = c, a [a] = Bool c}: Decompose2 {[d] = c, a [a] = Bool c} {[d] = c, a = Bool, [a] = c} Orient {[d] = c, a = Bool, c = [a]} Solve {[d] = [a], a = Bool, c = [a]} Solve {[d] = [Bool], a = Bool, c = [Bool]} Decompose1 {d = Bool, a = Bool, c = [Bool]} D. Sabel EFP WS 2015/16 Typisierung 21/106

30 Motivation Typen Typisierungsverfahren Beispiele Beispiel 1: {(a b) = Bool Bool}: Beispiel 2: {[d] Decompose2 {(a b) = Bool Bool} {a = Bool, b = Bool} = c, a [a] = Bool c}: Decompose2 {[d] = c, a [a] = Bool c} {[d] = c, a = Bool, [a] = c} Orient {[d] = c, a = Bool, c = [a]} Solve {[d] = [a], a = Bool, c = [a]} Solve {[d] = [Bool], a = Bool, c = [Bool]} Decompose1 {d = Bool, a = Bool, c = [Bool]} Der Unifikator ist {d Bool, a Bool, c [Bool]}. D. Sabel EFP WS 2015/16 Typisierung 21/106

31 Motivation Typen Typisierungsverfahren Beispiele (2) Beispiel 3: {a = [b], b = [a]} OccursCheck Solve {a = [b], b = [a]} {a = [[a]], b = [a]} Fail D. Sabel EFP WS 2015/16 Typisierung 22/106

32 Motivation Typen Typisierungsverfahren Beispiele (2) Beispiel 3: {a = [b], b = [a]} OccursCheck Solve {a = [b], b = [a]} {a = [[a]], b = [a]} Fail Beispiel 4: {a [b] = a c d} Decompose2 {a [b] = a c d} {a = a, [b] = c d} Elim {[b] = c d} Fail2 Fail D. Sabel EFP WS 2015/16 Typisierung 22/106

33 Motivation Typen Typisierungsverfahren Eigenschaften des Unifikationsalgorithmus Der Algorithmus endet mit Fail gdw. es keinen Unifikator für die Eingabe gibt. Der Algorithmus endet erfolgreich gdw. es einen Unifikator für die Eingabe gibt. Das Gleichungssystem Γ ist dann von der Form {α 1 = τ 1,..., α n = τ n }, wobei α i paarweise verschiedene Typvariablen sind und kein α i in irgendeinem τ j vorkommt. Der Unifikator kann dann abgelesen werden als σ = {α 1 τ 1,..., α n τ n }. Liefert der Algorithmus einen Unifikator, dann ist es ein allgemeinster Unifikator. σ allgemeinst bedeutet: jede andere Lösung ist abgedeckt, d.h ist spezieller als σ, genauer: kann durch weitere Einsetzung aus σ erzeugt werden. D. Sabel EFP WS 2015/16 Typisierung 23/106

34 Motivation Typen Typisierungsverfahren Eigenschaften des Unifikationsalgorithmus (2) Man braucht keine alternativen Regelanwendungen auszuprobieren! Der Algorithmus kann deterministisch implementiert werden. Der Algorithmus terminiert für jedes Unifikationsproblem auf Typen. Ausgabe: Fail oder der allgemeinste Unifikator D. Sabel EFP WS 2015/16 Typisierung 24/106

35 Motivation Typen Typisierungsverfahren Eigenschaften des Unifikationsalgorithmus (3) Die Typen in der Resultat-Substitution können exponentiell groß werden. Der Unifikationsalgorithmus kann aber so implementiert werden, dass er Zeit O(n log n) benötigt. Man muss Sharing dazu beachten; Dazu eine andere Solve-Regel benutzen. Die Typen in der Resultat-Substitution haben danach Darstellungsgröße O(n). Das Unifikationsproblem (d.h. die Frage, ob eine Menge von Typgleichungen unifizierbar ist) ist P-complete. D.h. man kann im wesentlichen alle PTIME-Probleme als Unifikationsproblem darstellen: Interpretation ist: Unifikation ist nicht effizient parallelisierbar. D. Sabel EFP WS 2015/16 Typisierung 25/106

36 Typisierungsverfahren Wir betrachten nun die polymorphe Typisierung von KFPTSP+seq-Ausdrücken Wir verschieben zunächst: Typisierung von Superkombinatoren D. Sabel EFP WS 2015/16 Typisierung 26/106

37 Typisierungsverfahren Wir betrachten nun die polymorphe Typisierung von KFPTSP+seq-Ausdrücken Wir verschieben zunächst: Typisierung von Superkombinatoren Nächster Schritt: Wie müssen die Typisierungsregeln aussehen? D. Sabel EFP WS 2015/16 Typisierung 26/106

38 Anwendungsregel mit Unifikation s :: τ 1, t :: τ 2 (s t) :: σ(α) wenn σ allgemeinster Unifikator für τ 1 = τ 2 α ist und α neue Typvariable ist. D. Sabel EFP WS 2015/16 Typisierung 27/106

39 Anwendungsregel mit Unifikation Beispiel: s :: τ 1, t :: τ 2 (s t) :: σ(α) wenn σ allgemeinster Unifikator für τ 1 = τ 2 α ist und α neue Typvariable ist. map :: (a b) [a] [b], not :: Bool Bool (map not) :: σ(α) wenn σ allgemeinster Unifikator für (a b) [a] [b] = (Bool Bool) α ist und α neue Typvariable ist. D. Sabel EFP WS 2015/16 Typisierung 27/106

40 Anwendungsregel mit Unifikation Beispiel: s :: τ 1, t :: τ 2 (s t) :: σ(α) wenn σ allgemeinster Unifikator für τ 1 = τ 2 α ist und α neue Typvariable ist. map :: (a b) [a] [b], not :: Bool Bool (map not) :: σ(α) wenn σ allgemeinster Unifikator für (a b) [a] [b] = (Bool Bool) α ist und α neue Typvariable ist. Unifikation ergibt {a Bool, b Bool, α [Bool] [Bool]} Daher: σ(α) = [Bool] [Bool] D. Sabel EFP WS 2015/16 Typisierung 27/106

41 Typisierung mit Bindern Wie typisiert man eine Abstraktion λx.s? Typisiere den Rumpf s Sei s :: τ Dann erhält λx.s einen Funktionstyp τ 1 τ Was hat τ 1 mit τ zu tun? τ 1 ist der Typ von x Wenn x im Rumpf s vorkommt, brauchen wir τ 1 bei der Berechnung von τ! D. Sabel EFP WS 2015/16 Typisierung 28/106

42 Typisierung mit Bindern (2) Informelle Regel für die Abstraktion: Typisierung von s unter der Annahme x hat Typ τ 1 ergibt s :: τ λx.s :: τ 1 τ Woher erhalten wir τ 1? D. Sabel EFP WS 2015/16 Typisierung 29/106

43 Typisierung mit Bindern (2) Informelle Regel für die Abstraktion: Typisierung von s unter der Annahme x hat Typ τ 1 ergibt s :: τ λx.s :: τ 1 τ Woher erhalten wir τ 1? Nehme allgemeinsten Typ an für x, danach schränke durch die Berechnung von τ den Typ ein. Beispiel: λx.(x True) Typisiere (x True) beginnend mit x :: α Typisierung muss liefern α = Bool α Typ der Abstraktion λx.(x True) :: (Bool α ) α. D. Sabel EFP WS 2015/16 Typisierung 29/106

44 Typisierung von Ausdrücken Erweitertes Regelformat: Bedeutung: A s :: τ, E Gegeben eine Menge A von Typ-Annahmen. Dann kann für den Ausdruck s der Typ τ und die Typgleichungen E hergeleitet werden. In A kommen nur Typ-Annahmen für Konstruktoren, Variablen, Superkombinatoren vor. In E sammeln wir Gleichungen, sie werden erst später unifiziert. D. Sabel EFP WS 2015/16 Typisierung 30/106

45 Typisierung von Ausdrücken (2) Herleitungsregeln schreiben wir in der Form Voraussetzung(en) Konsequenz A 1 s 1 :: τ 1, E 1... A k s k :: τ k, E K A s :: τ, E D. Sabel EFP WS 2015/16 Typisierung 31/106

46 Typisierung von Ausdrücken (2) Vereinfachung: Konstruktoranwendungen (c s 1... s n ) werden während der Typisierung wie geschachtelte Anwendungen (((c s 1 )...) s n )) behandelt. D. Sabel EFP WS 2015/16 Typisierung 32/106

47 Typisierungsregeln für KFPTS+seq Ausdrücke (1) Axiom für Variablen: (AxV) A {x :: τ} x :: τ, D. Sabel EFP WS 2015/16 Typisierung 33/106

48 Typisierungsregeln für KFPTS+seq Ausdrücke (1) Axiom für Variablen: (AxV) A {x :: τ} x :: τ, Axiom für Konstruktoren: (AxK) A {c :: α1... α n.τ} c :: τ[β 1 /α 1,..., β n /α n ], wobei β i neue Typvariablen sind Beachte: Jedesmal wird ein neu umbenannter Typ verwendet! D. Sabel EFP WS 2015/16 Typisierung 33/106

49 Typisierungsregeln für KFPTS+seq Ausdrücke (2) Axiom für Superkombinatoren, deren Typ schon bekannt ist: (AxSK) A {SK :: α1... α n.τ} SK :: τ[β 1 /α 1,..., β n /α n ], wobei β i neue Typvariablen sind Beachte: Jedesmal wird ein neu umbenannter Typ verwendet! D. Sabel EFP WS 2015/16 Typisierung 34/106

50 Typisierungsregeln für KFPTS+seq Ausdrücke (3) Regel für Anwendungen: (RApp) A s :: τ 1, E 1 und A t :: τ 2, E 2 A (s t) :: α, E 1 E 2 {τ 1 = τ 2 α} wobei α neue Typvariable D. Sabel EFP WS 2015/16 Typisierung 35/106

51 Typisierungsregeln für KFPTS+seq Ausdrücke (3) Regel für Anwendungen: (RApp) A s :: τ 1, E 1 und A t :: τ 2, E 2 A (s t) :: α, E 1 E 2 {τ 1 = τ 2 α} wobei α neue Typvariable Regel für seq: (RSeq) A s :: τ 1, E 1 und A t :: τ 2, E 2 A (seq s t) :: τ 2, E 1 E 2 D. Sabel EFP WS 2015/16 Typisierung 35/106

52 Typisierungsregeln für KFPTS+seq Ausdrücke (4) Regel für Abstraktionen: A {x :: α} s :: τ, E (RAbs) A λx.s :: α τ, E wobei α eine neue Typvariable D. Sabel EFP WS 2015/16 Typisierung 36/106

53 Typisierungsregeln für KFPTS+seq Ausdrücke (5) Typisierung eines case: Prinzipien case T yp s of { (c 1 x 1,1... x 1,ar(c1 )) t 1 ;... ; (c m x m,1... x m,ar(cm)) t m } Die Pattern und der Ausdruck s haben gleichen Typ. Der Typ muss auch zum Typindex am case passen (Haskell hat keinen Typindex an case ) Die Ausdrücke t 1,..., t n haben gleichen Typ, und dieser Typ ist auch der Typ des ganzen case-ausdrucks. D. Sabel EFP WS 2015/16 Typisierung 37/106

54 Typisierungsregeln für KFPTS+seq Ausdrücke (6) (RCase) Regel für case: A s :: τ, E für alle i = 1,..., m: A {x i,1 :: α i,1,..., x i,ar(ci ) :: α i,ar(ci )} (c i x i,1... x i,ar(ci) ) :: τ i, E i für alle i = 1,..., m: A {x i,1 :: α i,1,..., x i,ar(ci ) :: α i,ar(ci )} t i :: τ i, E i A wobei E = E m case T yp s of { (c 1 x 1,1... x 1,ar(c1 )) t 1 ;... ; (c m x m,1... x m,ar(cm)) t m } E i m E i m {τ = τ i } m i=1 i=1 i=1 und α i,j, α neue Typvariablen sind :: α, E i=1 {α = τ i } D. Sabel EFP WS 2015/16 Typisierung 38/106

55 Instanz der Case-Regel für Bool A s :: τ, E A True :: τ 1, E 1 A False :: τ 2, E 2 A t 1 :: τ 1, E 1 A t 2 :: τ 2, E 2 (RCase) A (case Bool s of {True t 1 ; False t 2 }) :: α, E wobei E = E E 1 E 2 E 1 E 2 {τ = τ 1, τ = τ 2 } {α = τ 1, α = τ 2 } und α i,j, α neue Typvariablen sind D. Sabel EFP WS 2015/16 Typisierung 39/106

56 Instanz der Case-Regel für Listen A s :: τ, E A Nil :: τ 1, E 1 A {x 1 :: α 1, x 2 :: α 2 } Cons x 1 x 2 :: τ 2, E 2 A t 1 :: τ 1, E 1 A {x 1 :: α 1, x 2 :: α 2 } t 2 :: τ 2, E 2 (RCase) A (case List s of { (Nil t 1 ; (Cons x 1 x 2 t 2 }) :: α, E wobei E = E E 1 E 2 E 1 E 2 {τ = τ 1, τ = τ 2 } {α = τ 1, α = τ 2 } und α i,j, α neue Typvariablen sind D. Sabel EFP WS 2015/16 Typisierung 40/106

57 Typisierungsalgorithmus für KFPTS+seq-Ausdrücke Sei s ein geschlossener KFPTS+seq-Ausdruck, wobei die Typen für alle in s benutzten Superkombinatoren und Konstruktoren bekannt sind. (d.h. diese Typen sind schon berechnet) 1 Starte mit Anfangsannahme A, die Typen für die Konstruktoren und die Superkombinatoren enthält. 2 Leite A s :: τ, E mit den Typisierungsregeln her. 3 Löse E mit Unifikation. 4 Wenn die Unifikation mit Fail endet, ist s nicht typisierbar; Andernfalls: Sei σ ein allgemeinster Unifikator von E, dann gilt s :: σ(τ). D. Sabel EFP WS 2015/16 Typisierung 41/106

58 Optimierung Zusätzliche Regel, zum zwischendrin Unifizieren: Typberechnung: A s :: τ, E (RUnif) A s :: σ(τ), E σ wobei E σ das gelöste Gleichungssystem zu E ist und σ der ablesbare Unifikator ist D. Sabel EFP WS 2015/16 Typisierung 42/106

59 Wohlgetyptheit Definition Ein KFPTS+seq Ausdruck s ist wohl-getypt, wenn er sich mit obigem Verfahren typisieren lässt. (Typisierung von Superkombinatoren kommt noch) D. Sabel EFP WS 2015/16 Typisierung 43/106

60 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (RApp) A 0 (Cons True) :: τ 1, E 1, A 0 Nil :: τ 2, E 2 A 0 (Cons True Nil) :: α 4, E 1 E 2 {τ 1 = τ 2 α 4 } D. Sabel EFP WS 2015/16 Typisierung 44/106

61 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (RApp) (AxK) A 0 (Cons True) :: τ 1, E 1, A0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, E 1 {τ 1 = [α 3 ] α 4 } D. Sabel EFP WS 2015/16 Typisierung 44/106

62 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (RApp) (RApp) A 0 Cons :: τ 3, E 3, A 0 True :: τ 4, E 4 A 0 (Cons True) :: α 2, {τ 3 = τ 4 α 2 } E 3 E 4, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {τ 3 = τ 4 α 2 } E 3 E 4 {α 2 = [α 3 ] α 4 } D. Sabel EFP WS 2015/16 Typisierung 44/106

63 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (RApp) (RApp) (AxK) A0 Cons :: α 1 [α 1 ] [α 1 ],, A 0 True :: τ 4, E 4 A 0 (Cons True) :: α 2, {α 1 [α 1 ] [α 1 ] = τ 4 α 2 } E 4, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {α 1 [α 1 ] [α 1 ] = τ 4 α 2 } E 4 {α 2 = [α 3 ] α 4 } D. Sabel EFP WS 2015/16 Typisierung 44/106

64 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (AxK) A0 Cons :: α 1 [α 1 ] [α 1 ],, (AxK) A 0 True :: Bool, (RApp) (RApp) A 0 (Cons True) :: α 2, {α 1 [α 1 ] [α 1 ] = Bool α 2 }, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {α 1 [α 1 ] [α 1 ] = Bool α 2 } {α 2 = [α 3 ] α 4 } D. Sabel EFP WS 2015/16 Typisierung 44/106

65 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (AxK) A0 Cons :: α 1 [α 1 ] [α 1 ],, (AxK) A 0 True :: Bool, (RApp) (RApp) A 0 (Cons True) :: α 2, {α 1 [α 1 ] [α 1 ] = Bool α 2 }, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {α 1 [α 1 ] [α 1 ] = Bool α 2, α 2 = [α 3 ] α 4 } D. Sabel EFP WS 2015/16 Typisierung 44/106

66 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (AxK) A0 Cons :: α 1 [α 1 ] [α 1 ],, (AxK) A 0 True :: Bool, (RApp) (RApp) A 0 (Cons True) :: α 2, {α 1 [α 1 ] [α 1 ] = Bool α 2 }, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {α 1 [α 1 ] [α 1 ] = Bool α 2, α 2 = [α 3 ] α 4 } Löse {α 1 [α 1] [α 1] = Bool α 2, α 2 = [α 3] α 4} mit Unifikation D. Sabel EFP WS 2015/16 Typisierung 44/106

67 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (AxK) A0 Cons :: α 1 [α 1 ] [α 1 ],, (AxK) A 0 True :: Bool, (RApp) (RApp) A 0 (Cons True) :: α 2, {α 1 [α 1 ] [α 1 ] = Bool α 2 }, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {α 1 [α 1 ] [α 1 ] = Bool α 2, α 2 = [α 3 ] α 4 } Löse {α 1 [α 1] [α 1] = Bool α 2, α 2 = [α 3] α 4} mit Unifikation Ergibt: σ = {α 1 Bool, α 2 ([Bool] [Bool]), α 3 Bool, α 4 [Bool]} D. Sabel EFP WS 2015/16 Typisierung 44/106

68 Beispiele: Typisierung von (Cons True Nil) Typisierung von Cons True Nil Starte mit: Anfangsannahme: A 0 = {Cons :: a.a [a] [a], Nil :: a.[a], True :: Bool} (AxK) A0 Cons :: α 1 [α 1 ] [α 1 ],, (AxK) A 0 True :: Bool, (RApp) (RApp) A 0 (Cons True) :: α 2, {α 1 [α 1 ] [α 1 ] = Bool α 2 }, (AxK) A 0 Nil :: [α 3 ], A 0 (Cons True Nil) :: α 4, {α 1 [α 1 ] [α 1 ] = Bool α 2, α 2 = [α 3 ] α 4 } Löse {α 1 [α 1] [α 1] = Bool α 2, α 2 = [α 3] α 4} mit Unifikation Ergibt: σ = {α 1 Bool, α 2 ([Bool] [Bool]), α 3 Bool, α 4 [Bool]} Daher (Cons True Nil) :: σ(α 4) = [Bool] D. Sabel EFP WS 2015/16 Typisierung 44/106

69 Beispiele: Typisierung von λx.x Typisierung von λx.x Starte mit: Anfangsannahme: A 0 = (RAbs) A 0 {x :: α} x :: τ, E A 0 (λx.x) :: α τ, E D. Sabel EFP WS 2015/16 Typisierung 45/106

70 Beispiele: Typisierung von λx.x Typisierung von λx.x Starte mit: Anfangsannahme: A 0 = (AxV) A0 {x :: α} x :: α, (RAbs) A 0 (λx.x) :: α α, D. Sabel EFP WS 2015/16 Typisierung 45/106

71 Beispiele: Typisierung von λx.x Typisierung von λx.x Starte mit: Anfangsannahme: A 0 = (AxV) A0 {x :: α} x :: α, (RAbs) A 0 (λx.x) :: α α, Nichts zu unifizieren, daher (λx.x) :: α α D. Sabel EFP WS 2015/16 Typisierung 45/106

72 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (RApp) (λx.(x x)) :: τ 1, E 1, (λy.(y y)) :: τ 2, E 2 (λx.(x x)) (λy.(y y)) :: α 1, E 1 E 2 {τ 1 = τ 2 α 1 } D. Sabel EFP WS 2015/16 Typisierung 46/106

73 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (RApp) (RAbs) {x :: α 2 } (x x) :: τ 1, E 1 (λx.(x x)) :: α 2 τ 1, E 1, (λy.(y y)) :: τ 2, E 2 (λx.(x x)) (λy.(y y)) :: α 1, E 1 E 2 {τ 1 = τ 2 α 1 } D. Sabel EFP WS 2015/16 Typisierung 46/106

74 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (RApp) {x :: α 2 } x :: τ 3, E 3, {x :: α 2 } x :: τ 4, E 4, {x :: α 2 } (x x) :: α 3, {τ 3 = τ 4 α 3 } E 3 E 4 (λx.(x x)) :: α 2 α 3, {τ 3 = τ 4 α 3 } E 3 E 4, (λy.(y y)) :: τ 2, E 2 (λx.(x x)) (λy.(y y)) :: α 1, {τ 3 = τ 4 α 3 } E 3 E 4 E 2 {α 3 = τ 2 α 1 } (RApp) (RAbs) D. Sabel EFP WS 2015/16 Typisierung 46/106

75 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (RApp) (RApp) (RAbs) (AxV) {x :: α2 } x :: α 2,, {x :: α 2 } x :: τ 4, E 4, {x :: α 2 } (x x) :: α 3, {α 2 = τ 4 α 3 } E 4 (λx.(x x)) :: α 2 α 3, {α 2 = τ 4 α 3 } E 4, (λy.(y y)) :: τ 2, E 2 (λx.(x x)) (λy.(y y)) :: α 1, {α 2 = τ 4 α 3 } E 4 E 2 {α 3 = τ 2 α 1 } D. Sabel EFP WS 2015/16 Typisierung 46/106

76 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (AxV) {x :: α2 } x :: α 2,, (AxV) {x :: α 2 } x :: α 2,, (RApp) (RAbs) (RApp) {x :: α 2 } (x x) :: α 3, {α 2 = α 2 α 3 } (λx.(x x)) :: α 2 α 3, {α 2 = α 2 α 3 }, (λy.(y y)) :: τ 2, E 2 (λx.(x x)) (λy.(y y)) :: α 1, {α 2 = α 2 α 3 } E 2 {α 3 = τ 2 α 1 } D. Sabel EFP WS 2015/16 Typisierung 46/106

77 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (AxV) {x :: α2 } x :: α 2,, (AxV) {x :: α 2 } x :: α 2,, (RApp) (RAbs) {x :: α 2 } (x x) :: α 3, {α 2 = α 2 α 3 } (λx.(x x)) :: α 2 α 3, {α 2 = α 2 α 3 }..., (λy.(y y)) :: τ 2, E 2 (RApp) (λx.(x x)) (λy.(y y)) :: α 1, {α 2 = α 2 α 3 } E 2 {α 3 = τ 2 α 1 } D. Sabel EFP WS 2015/16 Typisierung 46/106

78 Beispiele: Typisierung von Ω Typisierung von (λx.(x x)) (λy.(y y)) Starte mit: Anfangsannahme: A 0 = (AxV) {x :: α2 } x :: α 2,, (AxV) {x :: α 2 } x :: α 2,, (RApp) (RAbs) {x :: α 2 } (x x) :: α 3, {α 2 = α 2 α 3 } (λx.(x x)) :: α 2 α 3, {α 2 = α 2 α 3 }..., (λy.(y y)) :: τ 2, E 2 (RApp) (λx.(x x)) (λy.(y y)) :: α 1, {α 2 = α 2 α 3 } E 2 {α 3 = τ 2 α 1 } Man sieht schon: Die Unifikation schlägt fehl, wegen: α 2 = α 2 α 3 Daher: (λx.(x x)) (λy.(y y)) ist nicht typisierbar! Beachte: (λx.(x x)) (λy.(y y)) ist nicht dynamisch ungetypt aber nicht wohl-getypt D. Sabel EFP WS 2015/16 Typisierung 46/106

79 Beispiele: Typisierung eines Ausdrucks mit SKs (1) Annahme: map und length sind bereits typisierte Superkombinatoren. Wir typisieren: t := λxs.case List xs of {Nil Nil; (Cons y ys) map length ys} Als Anfangsannahme benutzen wir: A 0 = {map :: a, b.(a b) [a] [b], length :: a.[a] Int, Nil :: a.[a] Cons :: a.a [a] [a] } D. Sabel EFP WS 2015/16 Typisierung 47/106

80 Beispiele: Typisierung eines Ausdrucks mit SKs (2) Herleitungsbaum: (RCase) (RAbs) (AxK) B 8, (AxV) B 9 (RApp) B 6, (AxV) B 7 (AxV) B 3, (AxK) B 4, (RApp) Beschriftungen: B 5 (AxSK) (RApp), (AxK) B 10, (RApp) B 2 B 1 B 14, (AxSK) B 15 B 12, (AxV) B 13 B 11 B 1 = A 0 t :: α 1 α 13, {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12, } B 2 = A 0 {xs :: α 1} case List xs of {Nil Nil; (Cons y ys) map length ys} :: α 13, {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12, } D. Sabel EFP WS 2015/16 Typisierung 48/106

81 Beispiele: Typisierung eines Ausdrucks mit SKs (3) Herleitungsbaum: (RCase) (RAbs) (AxK) B 8, (AxV) B 9 (RApp) B 6, (AxV) B 7 (AxV) B 3, (AxK) B 4, (RApp) Beschriftungen: B 5 (AxSK) (RApp), (AxK) B 10, (RApp) B 2 B 1 B 14, (AxSK) B 15 B 12, (AxV) B 13 B 11 B 3 = A 0 {xs :: α 1} xs :: α 1, B 4 = A 0 {xs :: α 1} Nil :: [α 2], B 5 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} (Cons y ys) :: α 7, {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7} B 6 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} (Cons y) :: α 6, {α 5 [α 5] [α 5] = α 3 α 6} B 7 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} ys :: α 4, B 8 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} Cons :: α 5 [α 5] [α 5], B 9 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} y :: α 3, B 10 = A 0 {xs :: α 1} Nil :: [α 14], D. Sabel EFP WS 2015/16 Typisierung 49/106

82 Beispiele: Typisierung eines Ausdrucks mit SKs (4) Herleitungsbaum: (RCase) (RAbs) (AxK) B 8, (AxV) B 9 (RApp) B 6, (AxV) B 7 (AxV) B 3, (AxK) B 4, (RApp) Beschriftungen: B 5 (AxSK) (RApp), (AxK) B 10, (RApp) B 2 B 1 B 14, (AxSK) B 15 B 12, (AxV) B 13 B 11 B 11 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} (map length) ys :: α 12, {(α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12} B 12 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} (map length) :: α 11, {(α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11} B 13 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} ys :: α 4, B 14 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} map :: (α 8 α 9) [α 8] [α 9], B 15 = A 0 {xs :: α 1, y :: α 3, ys :: α 4} length :: [α 10] Int, D. Sabel EFP WS 2015/16 Typisierung 50/106

83 Beispiele: Typisierung eines Ausdrucks mit SKs (5) Beschriftung unten: B 1 = A 0 t :: α 1 α 13, {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12, } D. Sabel EFP WS 2015/16 Typisierung 51/106

84 Beispiele: Typisierung eines Ausdrucks mit SKs (5) Beschriftung unten: B 1 = A 0 t :: α 1 α 13, {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12, } Löse mit Unifikation: {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12} D. Sabel EFP WS 2015/16 Typisierung 51/106

85 Beispiele: Typisierung eines Ausdrucks mit SKs (5) Beschriftung unten: B 1 = A 0 t :: α 1 α 13, {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12, } Löse mit Unifikation: {α 5 [α 5] [α 5] = α 3 α 6, α 6 = α 4 α 7, (α 8 α 9) [α 8] [α 9] = ([α 10] Int) α 11, α 11 = α 4 α 12, α 1 = [α 2], α 1 = α 7, α 13 = [α 14], α 13 = α 12} Ergibt: σ = {α 1 [[α 10]], α 2 [α 10], α 3 [α 10], α 4 [[α 10]], α 5 [α 10], α 6 [[α 10]] [[α 10]], α 7 [[α 10]], α 8 [α 10], α 9 Int, α 11 [[α 10]] [Int], α 12 [Int], α 13 [Int], α 14 Int} Damit erhält man t :: σ(α 1 α 13 ) = [[α 10 ]] [Int]. D. Sabel EFP WS 2015/16 Typisierung 51/106

86 Bsp.: Typisierung von Lambda-geb. Variablen (1) Die Funktion const ist definiert als const :: a -> b -> a const x y = x Typisierung von λx.const (x True) (x A ) Anfangsannahme: A 0 = {const :: a, b.a b a, True :: Bool, A :: Char}. D. Sabel EFP WS 2015/16 Typisierung 52/106

87 Bsp.: Typisierung von Lambda-geb. Variablen (2) A 1 x :: α 1, (AxK) A 1 True :: Bool (AxK)A 1 const :: α 2 α 3 α 2,, (RApp) A 1 (x True) :: α 4, E 1 (RApp) (RApp) (RAbs) (AxV) A 1 const (x True) :: α 5, E 2 (AxV) A 1 x :: α 1, (AxK) A 1 A :: Char, (RApp) A 1 const (x True) (x A ) :: α 7, E 4 A 0 λx.const (x True) (x A ) :: α 1 α 7, E 4 A 1 (x A ) :: α 6, E 3 wobei A 1 = A 0 {x :: α 1} und: E 1 = {α 1 = Bool α 4} E 2 = {α 1 = Bool α 4, α 2 α 3 α 2 = α 4 α 5} E 3 = {α 1 = Char α 6} E 4 = {α 1 = Bool α 4, α 2 α 3 α 2 = α 4 α 5, α 1 = Char α 6, α 5 = α 6 α 7} D. Sabel EFP WS 2015/16 Typisierung 53/106

88 Bsp.: Typisierung von Lambda-geb. Variablen (2) A 1 x :: α 1, (AxK) A 1 True :: Bool (AxK)A 1 const :: α 2 α 3 α 2,, (RApp) A 1 (x True) :: α 4, E 1 (RApp) (RApp) (RAbs) (AxV) A 1 const (x True) :: α 5, E 2 (AxV) A 1 x :: α 1, (AxK) A 1 A :: Char, (RApp) A 1 const (x True) (x A ) :: α 7, E 4 A 0 λx.const (x True) (x A ) :: α 1 α 7, E 4 A 1 (x A ) :: α 6, E 3 wobei A 1 = A 0 {x :: α 1} und: E 1 = {α 1 = Bool α 4} E 2 = {α 1 = Bool α 4, α 2 α 3 α 2 = α 4 α 5} E 3 = {α 1 = Char α 6} E 4 = {α 1 = Bool α 4, α 2 α 3 α 2 = α 4 α 5, α 1 = Char α 6, α 5 = α 6 α 7} Die Unifikation schlägt fehl, da Char Bool D. Sabel EFP WS 2015/16 Typisierung 53/106

89 Bsp.: Typisierung von Lambda-geb. Variablen (3) In Haskell: Main> \x -> const (x True) (x A ) <interactive>:1:23: Couldn t match expected type Char against inferred type Bool Expected type: Char -> b Inferred type: Bool -> a In the second argument of const, namely (x A ) In the expression: const (x True) (x A ) D. Sabel EFP WS 2015/16 Typisierung 54/106

90 Bsp.: Typisierung von Lambda-geb. Variablen (3) In Haskell: Main> \x -> const (x True) (x A ) <interactive>:1:23: Couldn t match expected type Char against inferred type Bool Expected type: Char -> b Inferred type: Bool -> a In the second argument of const, namely (x A ) In the expression: const (x True) (x A ) Beispiel verdeutlicht: Lambda-gebundene Variablen sind monomorph getypt! Das gleiche gilt für case-pattern gebundene Variablen D. Sabel EFP WS 2015/16 Typisierung 54/106

91 Bsp.: Typisierung von Lambda-geb. Variablen (3) In Haskell: Main> \x -> const (x True) (x A ) <interactive>:1:23: Couldn t match expected type Char against inferred type Bool Expected type: Char -> b Inferred type: Bool -> a In the second argument of const, namely (x A ) In the expression: const (x True) (x A ) Beispiel verdeutlicht: Lambda-gebundene Variablen sind monomorph getypt! Das gleiche gilt für case-pattern gebundene Variablen Daher spricht man auch von let-polymorphismus, da nur let-gebundene Variablen polymorph sind. KFPTS+seq hat kein let, aber Superkombinatoren, die wie (ein eingeschränktes rekursives) let wirken D. Sabel EFP WS 2015/16 Typisierung 54/106

92 Rekursive Superkombinatoren Definition (direkt rekursiv, rekursiv, verschränkt rekursiv) Sei SK eine Menge von Superkombinatoren Für SK i, SK j SK sei SK i SK j gdw. SK j den Superkombinator SK i im Rumpf benutzt. + : transitiver Abschluss von ( : reflexiv-transitiver Abschluss) SK i ist direkt rekursiv wenn SK i SK i gilt. SK i ist rekursiv wenn SK i + SK i gilt. SK 1,..., SK m sind verschränkt rekursiv, wenn SK i + SK j für alle i, j {1,..., m} D. Sabel EFP WS 2015/16 Typisierung 55/106

93 Typisierung von nicht-rekursiven Superkombinatoren Nicht-rekursive Superkombinatoren kann man wie Abstraktionen typisieren Notation: A T SK :: τ, bedeutet: unter Annahme A kann man SK mit Typ τ typisieren D. Sabel EFP WS 2015/16 Typisierung 56/106

94 Typisierung von nicht-rekursiven Superkombinatoren Nicht-rekursive Superkombinatoren kann man wie Abstraktionen typisieren Notation: A T SK :: τ, bedeutet: unter Annahme A kann man SK mit Typ τ typisieren Typisierungsregel für (geschlossene) nicht-rekursive SK: (RSK1) A {x 1 :: α 1,..., x n :: α n } s :: τ, E A T SK :: X.σ(α 1... α n τ) wenn σ Lösung von E, SK x 1... x n = s die Definition von SK und SK nicht rekursiv ist, und X die Typvariablen in σ(α 1... α n τ) D. Sabel EFP WS 2015/16 Typisierung 56/106

95 Beispiel: Typisierung von (.) (.) f g x = f (g x) A 0 ist leer, da keine Konstruktoren oder SK vorkommen. A 1 g :: α 2,, (AxV) A 1 x :: α 3, (AxV)A 1 f :: α 1,, (RApp) A 1 (g x) :: α 5, {α 2 = α 3 α 5 } A 1 (f (g x)) :: α 4, {α 2 = α 3 α 5, α 1 = α 5 α 4 } (RApp) (RSK1) (AxV) T (.) :: X.σ(α 1 α 2 α 3 α 4 ) wobei A 1 = {f :: α 1, g :: α 2, x :: α 3 } Unifikation ergibt σ = {α 2 α 3 α 5, α 1 α 5 α 4 }. Daher: σ(α 1 α 2 α 3 α 4) = (α 5 α 4) (α 3 α 5) α 3 α 4 Jetzt kann man X = {α 3, α 4, α 5 } berechnen, und umbenennen: (.) :: a, b, c.(a b) (c a) c b D. Sabel EFP WS 2015/16 Typisierung 57/106

96 Typisierung von rekursiven Superkombinatoren Sei SK x 1... x n = e und SK kommt in e vor, d.h. SK ist rekursiv Warum kann man SK nicht ganz einfach typisieren? D. Sabel EFP WS 2015/16 Typisierung 58/106

97 Typisierung von rekursiven Superkombinatoren Sei SK x 1... x n = e und SK kommt in e vor, d.h. SK ist rekursiv Warum kann man SK nicht ganz einfach typisieren? Will man den Rumpf e typisieren, so muss man den Typ von SK kennen! D. Sabel EFP WS 2015/16 Typisierung 58/106

98 Idee des Iterativen Typisierungsverfahrens Gebe SK zunächst den allgemeinsten Typ (d.h. eine Typvariable) und typisiere den Rumpf unter Benutzung dieses Typs Man erhält anschließend einen neuen Typ für SK Mache mit neuem Typ weiter Stoppe, wenn neuer Typ = alter Typ Dann hat man eine konsistente Typannahme gefunden; Vermutung: auch eine ausreichend allgemeine (allgemeinste?) Allgemeinster Typ: Typ T so dass sem(t ) = {alle Grundtypen}. Das liefert der Typ α (bzw. quantifiziert α.α) D. Sabel EFP WS 2015/16 Typisierung 59/106

99 Iteratives Typisierungsverfahren Regel zur Berechnung neuer Annahmen: (SKRek) A {x 1 :: α 1,..., x n :: α n } s :: τ, E A T SK :: σ(α 1... α n τ) wenn SK x 1... x n = s die Definition von SK, σ Lösung von E Genau wie RSK1, aber in A muss es eine Annahme für SK geben. D. Sabel EFP WS 2015/16 Typisierung 60/106

100 Iteratives Typisierungsverfahren: Vorarbeiten (1) Wegen verschränkter Rekursion: Abhängigkeitsanalyse der Superkombinatoren Berechnung der starken Zusammenhangskomponenten im Aufrufgraph Sei die Äquivalenzrelation passend zu, dann sind die starken Zusammenhangskomponenten gerade die Äquivalenzklassen zu. Jede Äquivalenzklasse wird gemeinsam typisiert Typisierung der Gruppen entsprechend der -Ordnung modulo. D. Sabel EFP WS 2015/16 Typisierung 61/106

101 Iteratives Typisierungsverfahren: Vorarbeiten (2) Beispiel: f x y = if x<=1 then y else f (x-y) (y + g x) g x = if x==0 then (f 1 x) + (h 2) else 10 h x = if x==1 then 0 else h (x-1) k x y = if x==1 then y else k (x-1) (y+(f x y)) Der Aufrufgraph (nur bzgl. f,g,h,k ) ist g h f k Die Äquivalenzklassen (mit Ordnung) sind {h} + {f, g} + {k}. D. Sabel EFP WS 2015/16 Typisierung 62/106

102 Iteratives Typisierungsverfahren: Der Algorithmus Iterativer Typisierungsalgorithmus Eingabe: Menge von verschränkt rekursiven Superkombinatoren SK 1,..., SK m wobei kleinere SK s schon typisiert 1 Anfangsannahme A enthält Typen der Konstruktoren und der bereits bekannten Superkombinatoren. D. Sabel EFP WS 2015/16 Typisierung 63/106

103 Iteratives Typisierungsverfahren: Der Algorithmus Iterativer Typisierungsalgorithmus Eingabe: Menge von verschränkt rekursiven Superkombinatoren SK 1,..., SK m wobei kleinere SK s schon typisiert 1 Anfangsannahme A enthält Typen der Konstruktoren und der bereits bekannten Superkombinatoren 2 A 0 := A {SK 1 :: α 1.α 1,..., SK m :: α m.α m} und j = 0.. D. Sabel EFP WS 2015/16 Typisierung 63/106

104 Iteratives Typisierungsverfahren: Der Algorithmus Iterativer Typisierungsalgorithmus Eingabe: Menge von verschränkt rekursiven Superkombinatoren SK 1,..., SK m wobei kleinere SK s schon typisiert 1 Anfangsannahme A enthält Typen der Konstruktoren und der bereits bekannten Superkombinatoren 2 A 0 := A {SK 1 :: α 1.α 1,..., SK m :: α m.α m} und j = 0. 3 Verwende für jeden Superkombinator SK i (mit i = 1,..., m) die Regel (SKRek) und Annahme A j, um SK i zu typisieren.. D. Sabel EFP WS 2015/16 Typisierung 63/106

105 Iteratives Typisierungsverfahren: Der Algorithmus Iterativer Typisierungsalgorithmus Eingabe: Menge von verschränkt rekursiven Superkombinatoren SK 1,..., SK m wobei kleinere SK s schon typisiert 1 Anfangsannahme A enthält Typen der Konstruktoren und der bereits bekannten Superkombinatoren 2 A 0 := A {SK 1 :: α 1.α 1,..., SK m :: α m.α m} und j = 0. 3 Verwende für jeden Superkombinator SK i (mit i = 1,..., m) die Regel (SKRek) und Annahme A j, um SK i zu typisieren. 4 Wenn die m Typisierungen erfolgreich, d.h. für alle i: A j T SK i :: τ i Dann allquantifiziere: SK 1 :: X 1.τ 1,..., SK m :: X m.τ m Setze A j+1 := A {SK 1 :: X 1.τ 1,..., SK m :: X m.τ m}. D. Sabel EFP WS 2015/16 Typisierung 63/106

106 Iteratives Typisierungsverfahren: Der Algorithmus Iterativer Typisierungsalgorithmus Eingabe: Menge von verschränkt rekursiven Superkombinatoren SK 1,..., SK m wobei kleinere SK s schon typisiert 1 Anfangsannahme A enthält Typen der Konstruktoren und der bereits bekannten Superkombinatoren 2 A 0 := A {SK 1 :: α 1.α 1,..., SK m :: α m.α m} und j = 0. 3 Verwende für jeden Superkombinator SK i (mit i = 1,..., m) die Regel (SKRek) und Annahme A j, um SK i zu typisieren. 4 Wenn die m Typisierungen erfolgreich, d.h. für alle i: A j T SK i :: τ i Dann allquantifiziere: SK 1 :: X 1.τ 1,..., SK m :: X m.τ m Setze A j+1 := A {SK 1 :: X 1.τ 1,..., SK m :: X m.τ m} 5 Wenn A j A j+1, dann gehe mit j := j + 1 zu Schritt (3). Anderenfalls, d.h. wenn A j = A j+1, war A j konsistent. D. Sabel EFP WS 2015/16 Typisierung 63/106

107 Iteratives Typisierungsverfahren: Der Algorithmus Iterativer Typisierungsalgorithmus Eingabe: Menge von verschränkt rekursiven Superkombinatoren SK 1,..., SK m wobei kleinere SK s schon typisiert 1 Anfangsannahme A enthält Typen der Konstruktoren und der bereits bekannten Superkombinatoren 2 A 0 := A {SK 1 :: α 1.α 1,..., SK m :: α m.α m} und j = 0. 3 Verwende für jeden Superkombinator SK i (mit i = 1,..., m) die Regel (SKRek) und Annahme A j, um SK i zu typisieren. 4 Wenn die m Typisierungen erfolgreich, d.h. für alle i: A j T SK i :: τ i Dann allquantifiziere: SK 1 :: X 1.τ 1,..., SK m :: X m.τ m Setze A j+1 := A {SK 1 :: X 1.τ 1,..., SK m :: X m.τ m} 5 Wenn A j A j+1, dann gehe mit j := j + 1 zu Schritt (3). Anderenfalls, d.h. wenn A j = A j+1, war A j konsistent. Ausgabe: Allquantifizierte polymorphen Typen der SK i aus der konsistenten Annahme. Sollte irgendwann ein Fail in der Unifikation auftreten, dann sind SK 1,..., SK m nicht typisierbar. D. Sabel EFP WS 2015/16 Typisierung 63/106

108 Eigenschaften des Algorithmus Die berechneten Typen pro Iterationsschritt sind eindeutig bis auf Umbenennung. = bei Terminierung liefert der Algorithmus eindeutige Typen. Pro Iteration werden die neuen Typen spezieller (oder bleiben gleich). D.h. Monotonie bzgl. der Grundtypensemantik: sem(t j ) sem(t j+1 ) Bei Nichtterminierung gibt es keinen polymorphen Typ. Grund: Monotonie und man hat mit größten Annahmen begonnen. Das iterative Verfahren berechnet einen größten Fixpunkt (bzgl. der Grundtypensemantik): Menge wird solange verkleinert, bis sie sich nicht mehr ändert. D.h. es wird der allgemeinste polymorphe Typ berechnet D. Sabel EFP WS 2015/16 Typisierung 64/106

109 Beispiele: length (1) length xs = case List xs of{nil 0; (y : ys) 1 + length ys} Annahme: A = {Nil :: a.[a], (:) :: a.a [a] [a], 0, 1 :: Int, (+) :: Int Int Int} 1.Iteration: A 0 = A {length :: α.α} (RCase) (SKRek) (a) A 0 {xs :: α 1 } xs :: τ 1, E 1 (b) A 0 {xs :: α 1 } Nil :: τ 2, E 2 (c) A 0 {xs :: α 1, y :: α 4, ys :: α 5 } (y : ys) :: τ 3, E 3 (d) A 0 {xs :: α 1 } 0 :: τ 4, E 4 (e) A 0 {xs :: α 1, y :: α 4, ys :: α 5 }} (1 + length ys) :: τ 5, E 5 A 0 {xs :: α 1 } (case List xs of{nil 0; (y : ys) 1 + length xs}) :: α 3, E 1 E 2 E 3 E 4 E 5 {τ 1 = τ 2, τ 1 = τ 3, α 3 = τ 4, α 3 = τ 5 } A 0 T length :: σ(α 1 α 3 ) wobei σ Lösung von E 1 E 2 E 3 E 4 E 5 {τ 1 = τ 2, τ 1 = τ 3, α 3 = τ 4, α 3 = τ 5 } D. Sabel EFP WS 2015/16 Typisierung 65/106

110 Beispiele: length (2) (a): (AxV) A 0 {xs :: α 1 } xs :: α 1, D.h τ 1 = α 1 und E 1 = (b): (AxK) A 0 {xs :: α 1 } Nil :: [α 6 ], D.h. τ 2 = [α 6 ] und E 2 = (c) (AxK) A 0 (RApp) (RApp) (:) :: α 9 [α 9 ] [α 9 ],, (AxV) A 0 y :: α 4, A 0 ((:) y) :: α 8, {α 9 [α 9 ] [α 9 ] = α 4 α 8 }, (AxV) A 0 ys :: α 5, A 0 (y : ys) :: α 7, {α 9 [α 9 ] [α 9 ] = α 4 α 8, α 8 = α 5 α 7 } wobei A 0 = A 0 {xs :: α 1, y :: α 4, ys :: α 5 } D.h. τ 3 = α 7 und E 3 = {α 9 [α 9 ] [α 9 ] = α 4 α 8, α 8 = α 5 α 7 } D. Sabel EFP WS 2015/16 Typisierung 66/106

111 Beispiele: length (3) (d) (AxK) A 0 {xs :: α 1 } 0 :: Int, D.h. τ 4 = Int und E 4 = (e) (AxK) (RApp) (RApp) A 0 (+) :: Int Int Int,, (AxK) A (AxSK) 0 1 :: Int, A 0 length :: α 13,, (AxV) A 0 (ys) :: α 5, A 0 ((+) 1) :: α 11, {Int Int Int = Int α 11 }, (RApp) A 0 (length ys) :: α 12, {α 13 = α 5 α 12 } A 0 (1 + length ys) :: α 10, {Int Int Int = Int α 11, α 13 = α 5 α 12, α 11 = α 12 α 10 } wobei A 0 = A 0 {xs :: α 1, y :: α 4, ys :: α 5 } D.h. τ 5 = α 10 und E 5 = {Int Int Int = Int α 11, α 13 = α 5 α 12, α 11 = α 12 α 10} D. Sabel EFP WS 2015/16 Typisierung 67/106

112 Beispiele: length (3) Zusammengefasst: wobei σ Lösung von A 0 T length :: σ(α 1 α 3) {α 9 [α 9] [α 9] = α 4 α 8, α 8 = α 5 α 7, Int Int Int = Int α 11, α 13 = α 5 α 12, α 11 = α 12 α 10, α 1 = [α 6], α 1 = α 7, α 3 = Int, α 3 = α 10} Die Unifikation ergibt als Unifikator {α 1 [α 9], α 3 Int, α 4 α 9, α 5 [α 9], α 6 α 9, α 7 [α 9], α 8 [α 9] [α 9], α 10 Int, α 11 Int Int, α 12 Int, α 13 [α 9] Int} daher σ(α 1 α 3) = [α 9] Int A 1 = A {length :: α.[α] Int} Da A 0 A 1 muss man mit A 1 erneut iterieren. 2.Iteration: Ergibt den gleichen Typ, daher war A 1 konsistent. D. Sabel EFP WS 2015/16 Typisierung 68/106

113 Iteratives Verfahren ist allgemeiner als Haskell Beispiel g x = 1 : (g (g c )) A = {1 :: Int, Cons :: a.a [a] [a], c :: Char} A 0 = A {g :: α.α} (und A 0 = A 0 {x :: α 1 }): (AxSK) A 0 g :: α 8,, (AxK) A 0 c :: Char,, (AxK) A 0 Cons :: α 5 [α 5 ] [α 5 ],, (AxK) A (AxSK) 0 1 :: Int, A 0 g :: α 6,, (RApp) A 0 (g c ) :: α 7, {α 8 = Char α 7 } (RApp) A 0 (Cons 1) :: α 3, α 5 [α 5 ] [α 5 ] = Int α (RApp) 3, A 0 (g (g c )) :: α 4, {α 8 = Char α 7, α 6 = α 7 α 4 } (RApp) A 0 Cons 1 (g (g c )) :: α 2, {α 8 = Char α 7, α 6 = α 7 α 4, α 5 [α 5 ] [α 5 ] = Int α 3, α 3 = α 4 α 2 } (SKRek) A 0 T g :: σ(α 1 α 2 ) = α 1 [Int] wobei σ = {α 2 [Int], α 3 [Int] [Int], α 4 [Int], α 5 Int, α 6 α 7 [Int], α 8 Char α 7 } die Lösung von {α 8 = Char α 7, α 6 = α 7 α 4, α 5 [α 5 ] [α 5 ] = Int α 3, α 3 = α 4 α 2 } ist. D.h. A 1 = A {g :: α.α [Int]}. Nächste Iteration zeigt: A 1 ist konsistent. D. Sabel EFP WS 2015/16 Typisierung 69/106

114 Iteratives Verfahren ist allgemeiner als Haskell (2) Beachte: Für die Funktion g kann Haskell keinen Typ herleiten: Prelude> let g x = 1:(g(g c )) <interactive>:1:13: Couldn t match expected type [t] against inferred type Char Expected type: Char -> [t] Inferred type: Char -> Char In the second argument of (:), namely (g (g c )) In the expression: 1 : (g (g c )) D. Sabel EFP WS 2015/16 Typisierung 70/106

115 Iteratives Verfahren ist allgemeiner als Haskell (2) Beachte: Für die Funktion g kann Haskell keinen Typ herleiten: Prelude> let g x = 1:(g(g c )) <interactive>:1:13: Couldn t match expected type [t] against inferred type Char Expected type: Char -> [t] Inferred type: Char -> Char In the second argument of (:), namely (g (g c )) In the expression: 1 : (g (g c )) Aber: Haskell kann den Typ verifizieren, wenn man ihn angibt: let g::a -> [Int]; g x = 1:(g(g c )) Prelude> :t g g :: a -> [Int] Grund: Wenn Typ vorhanden, führt Haskell keine Typinferenz durch, sondern verifiziert nur die Annahme. g wird im Rumpf wie bereits typisiert behandelt. D. Sabel EFP WS 2015/16 Typisierung 70/106

116 Bsp.: Mehrere Iterationen sind nötig (1) g x = x : (g (g c )) A = {Cons :: a.a [a] [a], c :: Char}. A 0 = A {g :: α.α} (AxSK) A 0 g :: α 8,, (AxK) A 0 c :: Char,, (AxK) A 0 Cons :: α 5 [α 5 ] [α 5 ],, (AxV) A (AxSK) 0 x :: α 1, A 0 g :: α 6,, (RApp) A 0 (g c ) :: α 7, {α 8 = Char α 7 } (RApp) A 0 (Cons x) :: α 3, α 5 [α 5 ] [α 5 ] = α 1 α (RApp) 3, A 0 (g (g c )) :: α 4, {α 8 = Char α 7, α 6 = α 7 α 4 } (RApp) A 0 Cons x (g (g c )) :: α 2, {α 8 = Char α 7, α 6 = α 7 α 4, α 5 [α 5 ] [α 5 ] = α 1 α 3, α 3 = α 4 α 2 } (SKRek) A 0 T g :: σ(α 1 α 2 ) = α 5 [α 5 ] wobei σ = {α 1 α 5, α 2 [α 5 ], α 3 [α 5 ] [α 5 ], α 4 [α 5 ], α 6 α 7 [α 5 ], α 8 Char α 7 } die Lösung von {α 8 = Char α 7, α 6 = α 7 α 4, α 5 [α 5 ] [α 5 ] = α 1 α 3, α 3 = α 4 α 2 } ist. D.h. A 1 = A {g :: α.α [α]}. D. Sabel EFP WS 2015/16 Typisierung 71/106

117 Bsp.: Mehrere Iterationen sind nötig (2) Da A 0 A 1 muss eine weitere Iteration durchgeführt werden. Sei A 1 = A 1 {x :: α 1 }: (AxSK) A 1 g :: α 8 [α 8],, (AxK) A 1 c :: Char,, (AxK) A 1 Cons :: α 5 [α 5] [α 5],, (AxV) A (AxSK) 1 x :: α 1, A 1 g :: α 6 [α 6],, (RApp) A 1 (g c ) :: α 7, {α 8 [α 8] = Char α 7} A 1 (Cons x) :: α 3, α 5 [α 5] [α 5] = α 1 α (RApp) 3, A 1 (g (g c )) :: α 4, {α 8 [α 8] = Char α 7, α 6 [α 6] = α 7 α 4} A 1 Cons x (g (g c )) :: α 2, {α 8 [α 8] = Char α 7, α 6 [α 6] = α 7 α 4α 5 [α 5] [α 5] = α 1 α 3, α 3 = α 4 α 2} (RApp) (RApp) (SKRek) A 1 T g :: σ(α 1 α 2) = [Char] [[Char]] wobei σ = {α 1 [Char], α 2 [[Char]], α 3 [[Char]] [[Char]], α 4 [[Char]], α 5 [Char], α 6 [Char], α 7 [Char], α 8 Char} die Lösung von {α 8 [α 8] = Char α 7, α 6 [α 6] = α 7 α 4, α 5 [α 5] [α 5] = α 1 α 3, α 3 = α 4 α 2} ist. Daher ist A 2 = A {g :: [Char] [[Char]]}. D. Sabel EFP WS 2015/16 Typisierung 72/106

118 Bsp.: Mehrere Iterationen sind nötig (3) Da A 1 A 2 muss eine weitere Iteration durchgeführt werden: Sei A 2 = A 2 {x :: α 1 }: (AxSK) A 2 g :: [Char] [[Char]],, (AxK) A 2 c :: Char,, (AxK) A 2 Cons :: α5 [α5] [α5],, (AxV) A (AxSK) 2 x :: α1, A 2 g :: [Char] [[Char]],, (RApp) A 2 (g c ) :: α7, {[Char] [[Char]] = Char α7} A 2 (Cons x) :: α3, α5 [α5] [α5] = α1 (RApp) α3, A 2 (g (g c )) :: α4, {[Char] [[Char]] = Char α7, [Char] [[Char]] = α7 α4} A 2 Cons x (g (g c )) :: α2, {[Char] [[Char]] = Char α7, [Char] [[Char]] = α7 α4α5 [α5] [α5] = α1 α3, α3 = α4 α2} (RApp) (RApp) (SKRek) A2 T g :: σ(α1 α2) wobei σ die Lösung von {[Char] [[Char]] = Char α7, [Char] [[Char]] = α7 α4, α5 [α5] [α5] = α1 α3, α3 = α4 α2} ist. Unifikation: g ist nicht typisierbar. [Char] [[Char]] = Char α 7,... [Char] = Char, [[Char]] = α 7,... F ail D. Sabel EFP WS 2015/16 Typisierung 73/106