ML 0

1. ML0 Syntax, Typsystem und Semantik

2. -Kalkül • Fromalisierung von funktionaler Berechenbarkeit • Allgemeine Syntax: x TermVar M ::= x // Variable | x.M // Abstraktion | M M // Applikation • Variablenumgebung : TermVar  Werte • Kann auf verschiedene Art und Weise durch Typsystem ergänzt werden • Dabei: Ausdrucksmächtigkeit vs. Sicherheit

3. Ungetyptes -Kalkül • Kein Typsystem • exotische „sinnvolle“ Terme erlaubt: • (f. f( f )) y.y • f.( (x. f( x(x) )) (x.f( x(x) )) )(„paradoxical combinator“) • Jedoch auch unsinnige Terme erlaubt: • zero( zero ) • sehr ausdrucksmächtig, aber genauso unsicher

4. Explizit getyptes -Kalkül • Typen sind explizit gegeben: • Typumgebung H: TermVar  Typen • t ::= Grundtyp | tt • M ::= x | x:t.M | M M • Typregeln: • [Proj] x  H  H├ x:H(x) • [Abs] H, x:s├ M:t  H├ x:s.M : st • [Appl] H├ M: st H├ N: s  H├ M(N) : t

5. Implizit getyptes -Kalkül • Keine Type-TagsM ::= x | x.M | M M • Term korrekt gdw. äquivalenter explizit getypter Term existiert • D.h. Typregeln gleich, nur kein Type-Tag bei Abstraktion: [Abs] H, x:s├ M:t  H├ x.M : st

6. Implizit getyptes -Kalkül: Typinferenz • Gegeben: Term M, Typumgebung HKönnen wir einen Typen für M rekonstruieren ? • Bsp. M  x. f. f(x) • alle Typen der Form r(rs)s möglich („Typschema“) • r und s können als Variablen gesehen werden • Typ t erfüllt M:t gdw. t eine Substitutionsinstanz vom Typschema

7. Implizit getyptes -Kalkül:Mächtigkeitsgrenze • Bsp. M  f. f(f) • Typ von f müsste zwei Typschemata entsprechen: rs und r • Für gleichen Subterm aber nicht mehrere Typen nach Typregeln herleitbar • M kein korrekter Term • Kann aber manchmal sinnvoll seinz.B. (f. f(f)) (y. y)

8. Polymorphismus • Typsystem, das Terme erlaubt mit... gleichem Subterm in verschiedenen Kontexten mit verschiedenen Typen • Deckt „grauen Bereich“ sinnvoller Terme zwischen ungetyptem und implizit getyptem -Kalkül ab • Mehrere mögliche Implementierungen: • ML0 • Girard-Reynolds polymorphes -Kalkül • Typ:Typ Kalkül • ...

9. ML0 • Kern des Typsystems von ML • Verwendet u.a. in Haskell • Polymorphismus an Let-Konstrukt gebunden „Let-bound“ Polymorphismus • Typvariablen und Typschemata im Typsystem • Keine Type-Tags • Typinferenz

10. Syntax von ML0 x TermVar a TypeVar t ::= a | tt // Typen T ::= t | a. T // Typschemata M ::= x | x.M | M M | let x=M in M // let-Konstrukt • Let ähnlich (x.N) M jedoch andere Typregeln

11. Typsystem von ML0 • Typumgebung H: TermVar  TypschemaBsp.H  {zero : a. a,id : a. aa, filter : a.i. (aBool)(ia)(ia) } • Typ s ist Instanz von Typschema T  a1. ... an.t(kurz: s  T)gdw.  Substitution  auf {a1,...,an} mit (t)=sBsp. NatNat  a. aa StringString  a. aa

12. Typsystem von ML0 • Abschluss (closure) eines Typs tbzgl. Typumgebung H: close(H; t) = a1. ... an.t mit {a1,...,an} = Ftv(t) – Ftv(H) • Ftv(t)  freie Typvariablen in t • Ftv(H) = Ftv( H(x) ) mit x  H  freie Typvariablen in Typumgebung Typkonstanten (Nat, Bool, ...) • close verallegmeinert Typ zu passendem TypschemaBsp. H  { x:Bool, id : a. aa } t  aBool Ftv(H) = { Bool } Ftv(t)= { a, Bool } close(H; t) = a. aBool

13. Typsystem von ML0 • [Proj] x:TH tT •  H├ x:t • [Abs] H, x:s├ M:t  H├ x.M : st • [Appl] H├ M: st H├ N: s  H├ M(N) : t • [Let] H├ M : s H, x:close(H; s)├ N : t  H├ let x=M in N : t

14. Typsystem von ML0 Projektion einer Variablen aus der Typumgebung[Proj] x:TH tT •  H├ x:t • Für „herkömmliche“ Variablen x:t H: • einzige Instanzierung: Typ t • Entspricht alter Projektionsregel • Für polymorphe Variablen x:T H mit Typschema T  a1. ... an.t : • mehrere Instanziierungen möglich • X kann mehrere Typen haben

15. Typsystem von ML0 „Let-bound“ Polymorphismus [Let] H├ M : s H, x:close(H; s)├ N : t  H├ let x=M in N : t • Voraussetzung: • x bekommt Verallgemeinerung von Typ s close(H; s)und damit soll N:t sein • D.h. x kann beliebig oft frei in N vorkommen und jedesmal einen anderen Typ t mit t  close(H; s) haben • Folge: • Term M vom Typ s kann typkorrekt für x in N eingesetzt werden

16. Typsystem von ML0 Bsp. N  let f = x.x in f(f) [Proj] [Abs] x:a├ x:a  ├x.x : aa und close(, aa) = a.aa [Proj] [Appl] f:a.aa├ f : aa f:a.aa├ f : (aa)(aa)  f:a.aa├ f(f) : aa [Let] ├x.x : aa f:a.aa├ f(f) : aa   ├ let f = x.x in f(f) : aa

17. Semantik von ML0 • Für freie Typvariablen a  Ftv(H):Typvariablen-Umgebung : Ftv(H)  D • Für freie Termvariablen x  H:Termvariablen-Umgebung mit (x)  |[ H(x) ]|(H(x) ist i.A. ein Typschema) • D.h. wir arbeiten auf der semantischen Seite mit zwei Universen: • Universum U der semantischen Interpretation von Typen • Universum V der semantischen Interpretation von Typschemata

18. Semantik von ML0 Universum U • semantische Interpretation von Typen • Rekursiv definiert: • D0 = {X0} mit X0 Interpretation des Grundtyps • Dn+1 = Dn { XY | X,Y  Dn } • U = n  |N Dn D0 = { X0 } // Konstanten D1 = D0 { X0X0 } // 2-st. Funktionen D2 = D1 { X0(X0X0),(X0 X0)X0 } ... // 3-st. Funktionale

19. Semantik von ML0 Universum V • semantische Interpretation von Typschemata(als Funktionen  von Typen auf Typen) • Rekursiv definiert: • V0 = U (Universum der Interpret. der Typen) • Vn+1 = Vn UVn • V = n  |N Vn V0 = U // einfache Typen V1 = V0  UU // einfach parametr. T.S. = U { : UU } V2 = V1  { : U U { : UU }}... // 2-fach parametr. T.S.

20. Semantik von ML0 Von F abhängiges Produkt XUF(X) • Hilfsmittel zur Darstellung der Interpretation von Typschemata als Funktionen  • XUF(X) = F(X1)×...×F(Xn) = { : U XUF(X) | (X)  F(X)}Für jedes Tupel Projektionsfunktion , um Element des Tupels herauszuprojezieren • Bsp. F(1)={a, b}; F(2)={c, d} X{1,2}F(X)= {a, b}×{c, d} = { (a,c), (a,d), (b,c), (b,d) }= { : {1,2} X{1,2}F(X) | (X)  F(X) }= { {1|a, 2|c}, {1|a, 2|d},{1|b, 2|c}, {1|b, 2|d} }

21. Semantik von ML0 Interpretation von Typen und Typschemata • Typvariablen a: |[a]| = (a) • Funktionstypen: |[st]| = |[s]||[t]| • Typschemata: |[a.T]| = XU|[T]|[a|X] • Typschemafunktion F(X) = |[T]|[a|X] liefert uns für jede konkrete Typeinsetzung X in den formalen Typparameter a die Interpretation... • einer Typinstanz des Schemas • Oder eines weiteren Typschemas (Schema war mehrfach parametrisiert) • Abhängiges Produkt liefert uns Tupel, die alle möglichen Werte bei Einsetzung aller möglichen Typen beschreiben

22. Semantik von ML0 Bsp. U = {Bool, Nat} |[a.a]| = XU|[a.a]|[a|X]= |[a]|[a|Bool] × |[a]|[a|Nat]=  [a|Bool](a) × [a|Nat](a)= Bool × Nat={ (T, 0), (T, 1), ..., (F, 0), (F, 1), ... }= { : {Bool, Nat}BoolNat| (X)  F(X) }= { {Bool|T, Nat|0}, {Bool|T, Nat|1},...{Bool|F, Nat|0}, {Bool|F, Nat|1},...} • Für alle möglichen Typen und alle möglichen dazu passenden Werte haben wir ein 

23. Semantik von ML0 Interpretation von Termen Termvariablen x • mit H├ x:t und t  H(x)  a1. ... an.s • D.h.  Substitution  mit (s)  t • Sei Xi = |[(ai)]| für i {1,...,n}|[H├ x:t]| = (x)(X1)...(Xn) Bsp. x:a.a├ x:Bool • Bool  H(x)  a.a mit (a)  Bool • X = |[(a)]| = |[Bool]| = Bool • (x)  |[H(x)]| = { {Bool|T, Nat|0}, ...{Bool|F, Nat|0},...}z.B. (x) = {Bool|T, Nat|0} • |[x: a.a├ x:Bool]| = (x)(Bool) = T

24. Semantik von ML0 Abstraktion |[H├ x.M : st]| ist Funktion |[s]||[t]| mit d | |[H, x:s├ M : t]|[x|d] Bsp. |[├ x.x : NatNat]| ist Funktion |[Nat]||[Nat]| mit d | |[x:s├ x : Nat]|[x|d] = d Applikation |[H├ M(N) : t]| = (|[H├ M : st]|) (|[H├ N : s]|)

25. Semantik von ML0 Let-Term • polymorpher Typ s mit close(H; s) = a1. ... an.s • H├M:s • Sei   |[close(H; s)]| mit (X1)...(Xn) = |[H├ M : s]|([a1,...,an| X1...Xn]) |[H├ let x=M in N : t]| = |[H, x:close(H; s)├ N : t]|[x|]

26. Semantik von ML0 Bsp. Let-Term • close(H; s) = a.a und H├y:s • Sei   |[close(H; s)]| mit  = |[H├ y : s]|([a| X]) = (y) : |[s]|[a| X] = {Bool |T, Nat|0} ist eine mögliche Belegung |[H├ let x=y in pair(succ(x), not(y)) : t]| = |[H, x:close(H; s)├ pair(succ(x), not(x)) : t]|[x|] = pair( succ(|[H, x:close(H; s)├ x:s]|[x|] ), not( |[H, x:close(H; s)├ x:s]|[x|])) = pair( succ([x|](x)(Nat)), not([x|](x)(Bool))) = pair( succ(0), not(T) )

27. Typinferenz in ML0 • Für Term M in Typumgebung H lässt sich ein Typ rekonstruieren („inferieren“)

28. Polymorphes -Kalkül • Eigentlich: Girard-Reynolds polymorphes -Kalkül(wegen großer Bekanntheit meist einfach nur „ polymorphes -Kalkül“) • Verallgemeinerung von ML0 • Abstraktion und Applikation für Typvariablen explizit in Termen • D.h. eigene Syntax für Typen in Termen

29. Syntax des polymorphen -Kalküls x TermVar a TypeVar t ::= a // Typen | tt | a. T M ::= x | x:t.M | M M | a.M // Typabstraktion | M{t} // Typapplikation

30. Polymorphes -Kalkül - Ausblick • Zur Beschreibung der Semantik Mengentheorethisches Modell nicht ausreichend • Partielle Äquivalenzrelationen • Domains • Typinferenz ist nicht entscheidbar (1994)