Grundlagen der Programmierung 3 A [1.5ex] Typen, Typberechnung

Haskell, Typen, und Typberechnung
Grundlagen der Programmierung 3 A
Ziele:
Typen, Typberechnung und Typcheck
Prof. Dr Manfred Schmidt-Schauß
•
Haskells Typisierung
•
Typisierungs-Regeln
•
Typ-Berechnung
•
Milners Typcheck
Sommersemester 2014
1
Grundlagen der Programmierung 2 (Typen-A)
Typisierung in Haskell
– 2/35 –
Überladung und Konversion in Haskell
Haskell hat eine starke, statische Typisierung.
mit parametrisch polymorphen Typen.
•
jeder Ausdruck muss einen Typ haben
•
Der Typchecker berechnet Typen aller Ausdrücke
und prüft Typen zur Compilezeit
•
Haskell:
keine Typkonversion
Es gibt Überladung:
z.B. arithmetische Operatoren: +, −.∗, /
ganze Zahlkonstanten sind überladen
Es gibt keine Typfehler zur Laufzeit
d.h. kein dynamischer Typcheck nötig.
Grundlagen der Programmierung 2 (Typen-A)
– 3/35 –
Grundlagen der Programmierung 2 (Typen-A)
– 4/35 –
Typisierung, Begriffe
polymorph:
Syntax von Typen in Haskell (ohne Typklassen)
Ein Ausdruck kann viele Typen haben
(vielgestaltig, polymorph).
hTypi
parametrisch Die (i.a. unendliche) Menge der Typen
polymorph:
entspricht einem schematischen Typausdruck
::= hBasistypi | (hTypi) | hTypvariablei
| hTypkonstruktorn i{hTypi}n
(n = Stelligkeit)
Beispiel
Schema:
[a]->Int
Instanzen:
[Int]->Int,
hBasistypi ::= Int | Integer | Float | Rational | Char
[Char]->Int,
[[Char]]->Int
Grundlagen der Programmierung 2 (Typen-A)
– 5/35 –
Syntax von Typen
Grundlagen der Programmierung 2 (Typen-A)
– 6/35 –
Interpretation der Typen
Typkonstruktoren können benutzerdefiniert sein (z.B. Baum a)
Vordefinierte
Typkonstruktoren:
Liste
Tupel
Funktionen
[·]
(.,...,.)
· →·
(Stelligkeit 2, Infix)
length :: [a] ->
Interpretation:
Konvention zu Funktionstypen mit →
a → b → c → d bedeutet: a → (b → (c → d)).
Grundlagen der Programmierung 2 (Typen-A)
– 7/35 –
Grundlagen der Programmierung 2 (Typen-A)
Int
Für alle Typen typ ist length eine Funktion,
die vom Typ [typ] → Int ist.
– 8/35 –
Komposition
Typ der Komposition
Beispiel: Komposition von Funktionen:
Erklärung zum Typ von komp, wobei {a,b,c} Typvariablen sind.
Ausdruck: f ‘komp‘ g bzw. f . g
komp::(a -> b) -> (c -> a) -> c -> b
komp f g x = f (g x)
(a->b) ->
(τ1 -> τ2 )
(c->a) ->
Typ
Typ
Typ
Typ
c->b
(τ3 -> τ1 )
In Haskell ist komp vordefiniert und wird als .“ geschrieben:
”
Beispielaufruf:
τ3
τ2
*Main> suche_nullstelle (sin . quadrat) 1 4 0.00000001
←-
(τ3 -> τ2 )
1.772453852929175
x :: τ3
g
/
τ1
von (.)
von f
von g
des Arguments x
der Komposition f . g
Typ des Resultats
der Komposition f (g x)
Typ von (f . g)
f
/
τ2
sin(x2 )
(sin . quadrat) entspricht
und quadrat . sin entspricht (sin(x))2 .
Grundlagen der Programmierung 2 (Typen-A)
– 9/35 –
Typregeln
Grundlagen der Programmierung 2 (Typen-A)
– 10/35 –
Typregel Anwendung“: mehrere Argumente
”
Wie berechnet man Typen von Ausdrücken?
Anwendung von Funktionsausdruck auf Argument
s :: σ1 → σ2 . . . → σn → τ , t1 :: σ1 , . . . , tn :: σn
(s t1 . . . tn ) :: τ
s :: σ → τ , t :: σ
(s t) :: ?
Beispiele
Beispiele:
quadrat :: Int → Int ,
(quadrat 2) :: ?
+ :: Int → (Int → Int)
(1 +) :: ?
+ :: Int → Int → Int, 1 :: Int , 2 :: Int
(+ 1 2) :: Int
2 :: Int
,
+ :: Int → Int → Int
(1 + 2) :: Int
1 :: Int
,
2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A)
– 11/35 –
Grundlagen der Programmierung 2 (Typen-A)
– 12/35 –
Beispiel
Anwendungsregel für polymorphe Typen
even::Int -> Bool
(.)::(a -> b) -> (c -> a) -> c -> b
quadrat::Int -> Int
.
a -> b = Int -> Bool
.
c -> b = Int -> Bool
.
c -> a = Int -> Int
Neuer Begriff: γ ist eine Typsubstitution
wenn sie Typen für Typvariablen einsetzt
γ(τ ) nennt man Instanz von τ
Beispiel
Typsubstitution:
Instanz:
even . quadrat :: Int -> Bool
Grundlagen der Programmierung 2 (Typen-A)
Ziel: Anwendung der Typregel für z.B. length oder map
– 13/35 –
Anwendungsregel für polymorphe Typen
γ = {a 7→ Char, b 7→ Float}
γ([a] → Int) = [Char] → Int
Grundlagen der Programmierung 2 (Typen-A)
– 14/35 –
Beispiel zur polymorphen Anwendungsregel
Typ von (map quadrat) ?
s :: σ → τ, t :: ρ und γ(σ) = γ(ρ)
(s t) :: γ(τ )
map :: (a → b) → ([a] → [b])
Berechnet den Typ von (s t) wenn Typen von s, t schon bekannt
sind
Instanziiere mit:
ergibt:
γ = {a 7→ Int, b 7→ Int}
map :: (Int → Int) → ([Int] → [Int])
Regelanwendung ergibt:
Hierbei ist zu beachten:
die Typvariablen in ρ müssen vorher umbenannt werden,
so dass σ und ρ keine gemeinsamen Typvariablen haben.
Grundlagen der Programmierung 2 (Typen-A)
map :: (Int → Int) → ([Int] → [Int]), quadrat :: (Int → Int)
(map quadrat) :: [Int] → [Int]
– 15/35 –
Grundlagen der Programmierung 2 (Typen-A)
– 16/35 –
Polymorphe Regel für n Argumente
Wie berechnet man die Typsubstitutionen?
s :: σ1 → σ2 . . . → σn → τ, t1 :: ρ1 , . . . , tn :: ρn und ∀i : γ(σi ) = γ(ρi )
(s t1 . . . tn ) :: γ(τ )
Unifikation:
Unifikation wird benutzt im Typchecker von Haskell!
Die Typvariablen in ρ1 , . . . , ρn müssen vorher umbenannt werden.
Beachte:
Berechnung der allgemeinsten Typsubstitution
im Typberechnungsprogramm bzw Typchecker
verwende möglichst allgemeines γ
(kann berechnet werden; s.u.)
Grundlagen der Programmierung 2 (Typen-A)
– 17/35 –
polymorphe Typen; Unifikation
Grundlagen der Programmierung 2 (Typen-A)
– 18/35 –
Unifikation: Regelbasierter Algorithmus
Man braucht 4 Regeln, die auf (E; G) operieren:
s :: σ → τ ,
.
t :: ρ und γ ist allgemeinster Unifikator von σ = ρ
(s t) :: γ(τ )
Hierbei ist zu beachten:
die Typvariablen in ρ müssen vorher umbenannt werden.
Grundlagen der Programmierung 2 (Typen-A)
E:
G:
Menge von Typgleichungen,
Lösung; mit Komponenten der Form x 7→ t.
Beachte; x sind Typvariablen, t sind Typen, f, g sind
Typkonstruktoren
– 19/35 –
Grundlagen der Programmierung 2 (Typen-A)
– 20/35 –
Unifikation: Die Regeln
Unifikation: Regelbasierter Algorithmus
Start mit G = ∅; E
•
•
•
•
.
G; {x = x} ∪ E
G; E
.
G; {t = x} ∪ E
Wenn t keine Variable ist
.
G; {x = t} ∪ E
.
G; {x = t} ∪ E
Wenn x nicht in t
G[t/x] ∪ {x 7→ t}; E[t/x]
.
G; {(f s1 . . . sn ) = (f t1 . . . tn )} ∪ E
.
.
G; {s1 = t1 , . . . , sn = tn )} ∪ E
Ersetzung:
Effekt:
Fehlerabbruch, wenn:
.
• x = t in E, x 6= t und x kommt in t vor.
•
.
(f (. . .) = g(. . .) kommt in E vor und f 6= g.
Fehlerabbruch bedeutet: nicht typisierbar
E[t/x]: alle Vorkommen von x werden durch t ersetzt
G[t/x]: jedes y 7→ s wird durch y 7→ s[t/x] ersetzt
Grundlagen der Programmierung 2 (Typen-A)
– 21/35 –
Beispiel mit Typvariablen
Grundlagen der Programmierung 2 (Typen-A)
– 22/35 –
Beispiel mit Typvariablen
Berechne Typ von (map id)
map::
id::
(a → b)
a0 → a0
→ [a] → [b]
map :: (a → b) → ([a] → [b]), id :: a0 → a0
(map id) :: γ([a] → [b])
.
Regelanwendung benötigt Lösung von (a → b) = (a0 → a0 ):
G
∅;
∅;
{a 7→ a0 };
{a 7→ a0 , b 7→ a0 };
{a 7→ a0 , b 7→ a0 };
Grundlagen der Programmierung 2 (Typen-A)
E
.
{(a → b) = (a0 → a0 )}
.
.
{a = a0 , b = a0 }
. 0
{b = a }
∅
Einsetzung der Lösung γ = {a 7→ a0 , b 7→ a0 } ergibt
(map id) :: ([a0 ] → [a0 ]).
– 23/35 –
Grundlagen der Programmierung 2 (Typen-A)
– 24/35 –
Beispiel (foldr (:) []) :: ??
Beispiel. Linksfaltung: (foldl (:) [])?
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a]
([]) :: [a]
G
∅
{b 7→ [d]}
{b 7→ [d]}
{b 7→ [d], a 7→ c}
{b 7→ [d], a 7→ c}
{b 7→ [c], a 7→ c, d 7→ c}
{b 7→ [c], a 7→ c, d 7→ c}
{b 7→ [c], a 7→ c, d 7→ c}
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a]
([]) :: [a]
E
.
.
{a → b → b = c → [c] → [c], b = [d]}
.
{a → [d] → [d] = c → [c] → [c]}
.
.
.
{a = c, [d] = [c], [d] = [c]}
.
.
{[d] = [c], [d] = [c]}
.
.
{d = c, [d] = [c]}
.
{[c] = [c]}
.
{c = c}
{}
(foldr (:) [])::[c] → [c]
= γ([a] → b)
Grundlagen der Programmierung 2 (Typen-A)
– 25/35 –
Beispiel zu Typberechnung
G
∅
{a 7→ [d]}
{a 7→ [d]}
{a 7→ [d], b 7→ [c]}
{a 7→ [d], b 7→ [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]}
nicht lösbar
E
.
.
{a → b → a) = c → [c] → [c], a = [d]}
.
{[d] → b → [d] = c → [c] → [c]}
.
.
.
{[d] = c, b = [c], [d] = [c]}
.
.
{[d] = c, [d] = [c]}
.
.
{c = [d], [d] = [c]}
.
{[d] = [[d]]}
.
{d = [d]}
Grundlagen der Programmierung 2 (Typen-A)
– 26/35 –
Beispiele zu polymorpher Typberechnung
Typ von map length
map :: (a → b) → ([a] → [b]), length :: [a0 ] → Int
(map length) :: ?
Berechne Typ der Liste [1]:
1 : Int
.
Unifiziere (a → b) = [a0 ] → Int
G
∅;
∅;
{a 7→ [a0 ]};
{a 7→ [a0 ], b 7→ Int};
(:) :: a → [a] → [a]
1 : [] ::?
[] :: [b]
.
.
Anwendungsregel ergibt Gleichungen: {a = Int, [a] = [b]}
E
.
{(a → b) = ([a0 ] → Int)}
. 0
.
{a = [a ], b = Int}
.
{b = Int}
∅
Lösung: γ = {a 7→ Int}
Typ (1 : []) :: [Int]
Somit: (map length) :: γ([a] → [b]) = [[a0 ]] → [Int]
Grundlagen der Programmierung 2 (Typen-A)
– 27/35 –
Grundlagen der Programmierung 2 (Typen-A)
– 28/35 –
Beispiel zu Typfehler
[1, ’a’] hat keinen Typ:
• 1 : ( ’a’ : [])
• 1 :: Integer, [] :: [b], ’a’ :: Char
• (1 :) :: [Integer] → [Integer] und
(’a’:[]) :: [Char].
Beispiel zu Typfehler im Interpreter
Prelude> [1,’a’] ←-
(Typen der Konstanten.)
Kein Typ als Resultat, denn:
.
[Integer] = [Char] ist nicht lösbar.
Grundlagen der Programmierung 2 (Typen-A)
– 29/35 –
Typ eines Ausdrucks
<interactive>:1:1:
No instance for (Num Char)
arising from the literal ‘1’ at <interactive>:1:1
Possible fix: add an instance declaration for (Num Char)
In the expression: 1
In the expression: [1, ’a’]
In the definition of ‘it’: it = [1, ’a’]
Grundlagen der Programmierung 2 (Typen-A)
– 30/35 –
Typisierung von Funktionen und Ausdrücken
Problematik:
Typ von (map quadrat [1,2,3,4]) :
• map::
(a → b) → [a] → [b]
rekursiv definierte Funktionen
Lambda-Ausdrücke, let-Ausdrücke
Listen-Komprehensionen.
Typcheckalgorithmus von Robin Milner (in Haskell und ML)
• ist schnell,
• liefert allgemeinste (Milner-)Typen
• benutzt Unifikation (eine optimierte Variante)
•
quadrat::
Integer → Integer, und [1, 2, 3, 4] :: [Integer].
•
γ=
{a 7→ Integer, b 7→ Integer}.
•
Das ergibt:
γ(a) = Integer, γ([a]) = [Integer], γ([b]) = [Integer].
•
•
Resultat:
γ([b]) = [Integer]
•
Grundlagen der Programmierung 2 (Typen-A)
– 31/35 –
schlechte worst-case Komplexität:
in seltenen Fällen exponentieller Zeitbedarf
Liefert in seltenen Fällen nicht
die allgemeinsten möglichen polymorphen Typen
Grundlagen der Programmierung 2 (Typen-A)
– 32/35 –
Typisierung von Funktionen, Milner
Typisierung und Reduktion
Beachte:
Satz zur Milner-Typisierung in Haskell:
Sei t ein getypter Haskell-Ausdruck, ohne freie Variablen.
Dann wird die Auswertung des Ausdrucks t
nicht mit einem Typfehler abbrechen.
Beispiel:
if 1 > 0 then [] else [1]
Allgemeine Aussage zu starken Typsystemen
Es gibt keine dynamischen Typfehler,
wenn das Programm statisch korrekt getypt ist
Grundlagen der Programmierung 2 (Typen-A)
– 33/35 –
Typisierung und Reduktion
weiteres Beispiel:
(if 1 > 0 then foldr else foldl) ::
(a -> a -> a) -> a -> [a] -> a
Reduktion ergibt als Resultat:
foldr:: (a -> b -> b) -> b -> [a] -> b
der Typ ist allgemeiner geworden!
Grundlagen der Programmierung 2 (Typen-A)
Nach Reduktionen kann ein Ausdruck
mehr Typen (bzw. einen allgemeineren Typ) haben
als vor der Reduktion
– 35/35 –
:: [Integer]
arithmetische-Reduktion:
−→ if True then [] else [1]
:: [Integer]
Case-Reduktion:
−→ []
:: [a]
Grundlagen der Programmierung 2 (Typen-A)
– 34/35 –