View
222
Download
0
Category
Preview:
Citation preview
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 TypeVart ::= a | tt // TypenT ::= t | a. T // TypschemataM ::= 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 TypschemaBsp.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 t
bzgl. 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 ML0Universum 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 } // KonstantenD1 = D0 { X0X0 } // 2-st. FunktionenD2 = D1 { X0(X0X0), (X0 X0)X0 }... // 3-st. Funktionale
Semantik von ML0Universum 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 TypenV1 = 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 ML0Bsp. 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 ML0Interpretation 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 TypeVart ::= a // Typen| tt| a. TM ::= 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)
Recommended