ML 0 Syntax, Typsystem und Semantik

-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

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

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

Implizit getyptes -Kalkül Keine Type-Tags M ::= 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

Implizit getyptes -Kalkül: Typinferenz Gegeben: Term M, Typumgebung H Kö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

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 sein z.B.( f. f(f)) ( y. y)

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

ML 0 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

Syntax von ML 0 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

Typsystem von ML 0 Typumgebung H: TermVar  Typschema Bsp. H  {zero :  a. a, id :  a. a  a, filter:  a.  i. (a  Bool)  (i  a)  (i  a) } Typ s ist Instanz von Typschema T   a  a n.t (kurz: s  T) gdw.  Substitution  auf {a 1,...,a n } mit  (t)=s Bsp.Nat  Nat   a. a  a String  String  a. a  a

Typsystem von ML 0 Abschluss (closure) eines Typs t bzgl. Typumgebung H: close(H; t) =  a  a n.t mit {a 1,...,a n } = 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 Typschema Bsp. H  { x:Bool, id :  a. a  a } t  a  Bool Ftv(H) = { Bool }Ftv(t)= { a, Bool } close(H; t) =  a. a  Bool

Typsystem von ML 0 [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 : sH, x:close(H; s)├ N : t  H├ let x=M in N : t

Typsystem von ML 0 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   a  a n.t : mehrere Instanziierungen möglich X kann mehrere Typen haben

Typsystem von ML 0 „Let-bound“ Polymorphismus [Let]H├ M : sH, 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

Typsystem von ML 0 Bsp.N  let f = x.x in f(f) [Proj] [Abs]x:a├ x:a  ├ x.x : a  aund 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  af:  a.a  a├ f(f) : a  a   ├ let f = x.x in f(f) : a  a

Semantik von ML 0 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

Semantik von ML 0 Universum U semantische Interpretation von Typen Rekursiv definiert: D 0 = {X 0 } mit X 0 Interpretation des Grundtyps D n+1 = D n  { X  Y | X,Y  D n } U =  n  |N D n D 0 = { X 0 }// Konstanten D 1 = D 0  { X 0  X 0 }// 2-st. Funktionen D 2 = D 1  { X 0  (X 0  X 0 ), (X 0  X 0 )  X 0 }...// 3-st. Funktionale

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

Semantik von ML 0 Von F abhängiges Produkt  X  U F(X) Hilfsmittel zur Darstellung der Interpretation von Typschemata als Funktionen   X  U F(X) = F(X 1 )×...×F(X n ) = {  : U   X  U F(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} }

Semantik von ML 0 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

Semantik von ML 0 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 

Semantik von ML 0 Interpretation von Termen Termvariablen x mit H├ x:t und t  H(x)   a  a n.s D.h.  Substitution  mit  (s)  t Sei X i = |[  (a i )]|  für i  {1,...,n} |[H├ x:t]|  =  (x)(X 1 )...(X n ) 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

Semantik von ML 0 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]|  )

Semantik von ML 0 Let-Term polymorpher Typ s mit close(H; s) =  a  a n.s H├M:s Sei   |[close(H; s)]|  mit  (X 1 )...(X n ) = |[H├ M : s]|(  [a 1,...,a n |  X 1...X n ])  |[H├ let x=M in N : t]|  =|[H, x:close(H; s)├ N : t]|  [x|  ]

Semantik von ML 0 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) )

Typinferenz in ML 0 Für Term M in Typumgebung H lässt sich ein Typ rekonstruieren („inferieren“)

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

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

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