ML0

Syntax, Typsystem und Semantik

-Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax:

x TermVarM ::= 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 | tt 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 : st [Appl] H├ M: st 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 : st

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(rs)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:rs 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 Subtermin verschiedenen Kontexten mit verschiedenen Typen

Deckt „grauen Bereich“ sinnvoller Terme zwischenungetyptem und implizit getyptem -Kalkül ab

Mehrere mögliche Implementierungen: ML0 Girard-Reynolds polymorphes -Kalkül Typ:Typ Kalkül ...

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

Syntax von ML0

x TermVara TypeVar

t ::= a | tt // TypenT ::= 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 ML0

Typumgebung H: TermVar Typschema

Bsp.

H {zero : a. a, id : a. aa,

filter : a.i. (aBool)(ia)(ia) }

Typ s ist Instanz von Typschema T a1. ... an.t

(kurz: s T)

gdw. Substitution auf {a1,...,an} mit (t)=s

Bsp. NatNat a. aa

StringString a. aa

Typsystem von ML0

Abschluss (closure) eines Typs tbzgl. Typumgebung H:

close(H; t) = a1. ... an.tmit {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. aa }

t aBoolFtv(H) = { Bool } Ftv(t)= { a, Bool }close(H; t) = a. aBool

Typsystem von ML0 [Proj] x:TH tT

H├ x:t

[Abs] H, x:s├ M:t

H├ x.M : st

[Appl] H├ M: st 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

Typsystem von ML0

Projektion einer Variablen aus der Typumgebung[Proj] x:TH tT

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

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

Typsystem von ML0

Bsp. N let f = x.x in f(f)

[Proj] [Abs] x:a├ x:a

├ x.x : aa und close(, aa) = a.aa

[Proj][Appl] f:a.aa├ f : aa f:a.aa├ f : (aa)(aa)

f:a.aa├ f(f) : aa

[Let] ├ x.x : aa f:a.aa├ f(f) : aa

├ let f = x.x in f(f) : aa

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

Semantik von ML0

Universum U semantische Interpretation von Typen Rekursiv definiert:

D0 = {X0} mit X0 Interpretation des Grundtyps Dn+1 = Dn { XY | X,Y Dn } U = n |N Dn

D0 = { X0 } // Konstanten

D1 = D0 { X0X0 } // 2-st. Funktionen

D2 = D1 { X0(X0X0), (X0 X0)X0 }... // 3-st. Funktionale

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 UVn

V = n |N Vn

V0 = U // einfache Typen

V1 = V0 UU // einfach parametr. T.S.

= U { : UU }

V2 = V1 { : U U { : UU }} ... // 2-fach parametr. T.S.

Semantik von ML0

Von F abhängiges Produkt XU F(X) Hilfsmittel zur Darstellung der Interpretation von

Typschemata als Funktionen XU F(X) = F(X1)×...×F(Xn)

= { : U XU 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 ML0

Interpretation von Typen und Typschemata Typvariablen a: |[a]| = (a) Funktionstypen: |[st]| = |[s]||[t]| Typschemata: |[a.T]| =

XU |[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 ML0

Bsp. U = {Bool, Nat}|[a.a]|

= XU |[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}BoolNat | (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 ML0

Interpretation von TermenTermvariablen 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

Semantik von ML0

Abstraktion|[H├ x.M : st]| ist Funktion |[s]||[t]| mitd | |[H, x:s├ M : t]|[x|d]

Bsp.|[├ x.x : NatNat]| ist Funktion |[Nat]||[Nat]| mitd | |[x:s├ x : Nat]|[x|d] = d

Applikation|[H├ M(N) : t]|

= (|[H├ M : st]|) (|[H├ N : s]|)

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|]

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) )

Typinferenz in ML0

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 ML0

Abstraktion und Applikation für Typvariablen explizit in Termen

D.h. eigene Syntax für Typen in Termen

Syntax des polymorphen -Kalküls

x TermVara TypeVar

t ::= a // Typen

| tt

| 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)