grundlagen der programmierung 3 a - benutzer-homepagesprg2/ss2017/folien/teil1/fol-3a-typ.pdf ·...
TRANSCRIPT
![Page 1: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/1.jpg)
1
Grundlagen der Programmierung 3 A
Typen, Typberechnung und Typcheck
Prof. Dr. Manfred Schmidt-Schauß
Sommersemester 2017
![Page 2: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/2.jpg)
Haskell, Typen, und Typberechnung
Ziele:
• Haskells Typisierung
• Typisierungs-Regeln
• Typ-Berechnung
• Milners Typcheck (Robin Milner)
Grundlagen der Programmierung 2 (Typen-A) – 2/37 –
![Page 3: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/3.jpg)
Einige andere Programmiersprachen
ab Java 5: generische Typen verwandt mit polymorphenTypen
ML (und CAML, OCAML) hat parametrisch polymorphesTypsystem
JavaScript Nachteile: Es fehlt eine statische Typisierung
TypeScript (Microsoft): Neue JavaScript Variante mitstatischer Typisierung und Typinferenz.
Google Ankundigung: Angular 2 (JavaScript-Webframework)zukunftig auf Basis von TypeScript
Grundlagen der Programmierung 2 (Typen-A) – 3/37 –
![Page 4: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/4.jpg)
Typisierung in Haskell
Haskell hat eine starke, statische Typisierung.mit parametrisch polymorphen Typen.
• jeder Ausdruck muss einen Typ haben
• Der Typchecker berechnet Typen aller Ausdruckeund pruft Typen zur Compilezeit
• Es gibt keine Typfehler zur Laufzeitd.h. kein dynamischer Typcheck notig.
Grundlagen der Programmierung 2 (Typen-A) – 4/37 –
![Page 5: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/5.jpg)
Uberladung und Konversion in Haskell
Haskell: keine Typkonversion
Es gibt Uberladung:z.B. arithmetische Operatoren: +,−.∗, /
Zahlkonstanten fur ganze Zahlen sind uberladen
Typcheck erstmal ohne Uberladungohne Kindsund ohne Typen hoherer Ordnung
Grundlagen der Programmierung 2 (Typen-A) – 5/37 –
![Page 6: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/6.jpg)
Uberladung und Konversion in Haskell
Haskell: keine Typkonversion
Es gibt Uberladung:z.B. arithmetische Operatoren: +,−.∗, /
Zahlkonstanten fur ganze Zahlen sind uberladen
Typcheck erstmal ohne Uberladungohne Kindsund ohne Typen hoherer Ordnung
Grundlagen der Programmierung 2 (Typen-A) – 5/37 –
![Page 7: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/7.jpg)
Typisierung, Begriffe
polymorph: Ein Ausdruck kann viele Typen haben(vielgestaltig, polymorph).
parametrischpolymorph:
Die (i.a. unendliche) Menge der Typenentspricht einem schematischen Typausdruck
Beispiel length
Schema: [a]->Int
Instanzen: [Int]->Int, [Char]->Int, [[Char]]->Intusw.
Grundlagen der Programmierung 2 (Typen-A) – 6/37 –
![Page 8: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/8.jpg)
Syntax von Typen in Haskell (ohne Typklassen)
〈Typ〉 ::= 〈Basistyp〉 | (〈Typ〉) | 〈Typvariable〉
| 〈Typkonstruktorn〉{〈Typ〉}n
(n = Stelligkeit)
〈Basistyp〉 ::= Int | Integer | Float | Rational | Char | . . .
Grundlagen der Programmierung 2 (Typen-A) – 7/37 –
![Page 9: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/9.jpg)
Syntax von Typen
Typkonstruktoren konnen benutzerdefiniert sein (z.B. Baum a)
Vordefinierte Liste [·]Typkonstruktoren: Tupel (.,...,.)
Funktionen · → · (Stelligkeit 2, Infix)
Konvention zu Funktionstypen mit →a→ b→ c→ d bedeutet: a→ (b→ (c→ d)).
Grundlagen der Programmierung 2 (Typen-A) – 8/37 –
![Page 10: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/10.jpg)
Interpretation der Typen
length :: [a] -> Int
Interpretation: Fur alle Typen typ ist length eine Funktion,die vom Typ [typ]→ Int ist.
Grundlagen der Programmierung 2 (Typen-A) – 9/37 –
![Page 11: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/11.jpg)
Komposition
Beispiel: Komposition von Funktionen:
komp::(a -> b) -> (c -> a) -> c -> b
komp f g x = f (g x)
In Haskell ist komp vordefiniert und wird als”.“ geschrieben:
Beispielaufruf:
*Main> suche_nullstelle (sin . quadrat) 1 4 0.00000001
←↩1.772453852929175
(sin . quadrat) entspricht sin(x2)und quadrat . sin entspricht (sin(x))2.
Grundlagen der Programmierung 2 (Typen-A) – 10/37 –
![Page 12: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/12.jpg)
Typ der Komposition
Erklarung zum Typ von komp, wobei {a,b,c} Typvariablen sind.Ausdruck: f ‘komp‘ g bzw. f . g
(a->b) -> (c->a) -> c->b Typ von (.)
(τ1 -> τ2) Typ von f(τ3 -> τ1) Typ von g
τ3 Typ des Arguments xder Komposition f . g
τ2 Typ des Resultatsder Komposition f(g x)
(τ3 -> τ2) Typ von (f . g)
x :: τ3g // τ1
f // τ2
Grundlagen der Programmierung 2 (Typen-A) – 11/37 –
![Page 13: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/13.jpg)
Typ der Komposition
Erklarung zum Typ von komp, wobei {a,b,c} Typvariablen sind.Ausdruck: f ‘komp‘ g bzw. f . g
(a->b) -> (c->a) -> c->b Typ von (.)
(τ1 -> τ2) Typ von f(τ3 -> τ1) Typ von g
τ3 Typ des Arguments xder Komposition f . g
τ2 Typ des Resultatsder Komposition f(g x)
(τ3 -> τ2) Typ von (f . g)
x :: τ3g // τ1
f // τ2
Grundlagen der Programmierung 2 (Typen-A) – 11/37 –
![Page 14: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/14.jpg)
Typ der Komposition
Erklarung zum Typ von komp, wobei {a,b,c} Typvariablen sind.Ausdruck: f ‘komp‘ g bzw. f . g
(a->b) -> (c->a) -> c->b Typ von (.)
(τ1 -> τ2) Typ von f(τ3 -> τ1) Typ von g
τ3 Typ des Arguments xder Komposition f . g
τ2 Typ des Resultatsder Komposition f(g x)
(τ3 -> τ2) Typ von (f . g)
x :: τ3g // τ1
f // τ2
Grundlagen der Programmierung 2 (Typen-A) – 11/37 –
![Page 15: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/15.jpg)
Typen von Konstruktoren
Typen von Konstruktoren werden durch deren data-Definitionautomatisch festgelegt!
data Baum a b = Empty | Blatt b
| Knoten a (Baum a b) Baum a b)
Typen der Konstruktoren:Empty :: Baum a bBlatt :: b→ Baum a bKnoten :: b→ Baum a b→ Baum a b→ Baum a b
Grundlagen der Programmierung 2 (Typen-A) – 12/37 –
![Page 16: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/16.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: ?
Beispiele:
quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 17: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/17.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ
, t :: σ
(s t) :: ?
Beispiele:
quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 18: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/18.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: ?
Beispiele:
quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 19: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/19.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:
quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 20: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/20.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:
quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: ?
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 21: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/21.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int
, 2 :: Int
(quadrat 2) :: ?
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 22: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/22.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: ?
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 23: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/23.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 24: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/24.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 25: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/25.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ?
, 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 26: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/26.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 27: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/27.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int)
, 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 28: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/28.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: ? , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 29: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/29.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: (Int→ Int) , 2:: Int
((1 +) 2) :: ?
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 30: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/30.jpg)
Typregeln
Wie berechnet man Typen von Ausdrucken?
Anwendung von Funktionsausdruck auf Argument
s :: σ → τ , t :: σ
(s t) :: τ
Beispiele:quadrat :: Int→ Int , 2 :: Int
(quadrat 2) :: Int
+ :: Int→ (Int→ Int) , 1 :: Int
(1 +) :: (Int→ Int) , 2:: Int
((1 +) 2) :: Int
Grundlagen der Programmierung 2 (Typen-A) – 13/37 –
![Page 31: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/31.jpg)
Typregel”Anwendung“: mehrere Argumente
s :: σ1 → σ2 . . .→ σn → τ , t1 :: σ1 , . . . , tn :: σn(s t1 . . . tn) :: τ
Beispiele
+ :: Int→ Int→ Int, 1 :: Int , 2 :: Int
(+ 1 2) :: Int
+ :: Int→ Int→ Int
(1 + 2) :: Int
Grundlagen der Programmierung 2 (Typen-A) – 14/37 –
![Page 32: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/32.jpg)
Beispiel
even::Int -> Bool a -> b.= Int -> Bool
(.)::(a -> b) -> ((c -> a) -> (c -> b)) c.= Int; b
.= Bool
quadrat::Int -> Int c -> a.= Int -> Int
even . quadrat :: ???
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 33: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/33.jpg)
Beispiel
even::Int -> Bool
a -> b.= Int -> Bool
(.)::(a -> b) -> (c -> a) -> c -> b
c.= Int; b
.= Bool
quadrat::Int -> Int
c -> a.= Int -> Int
even . quadrat :: ???
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 34: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/34.jpg)
Beispiel
even::Int -> Bool
a -> b.= Int -> Bool
(.)::(a -> b) -> ((c -> a) -> (c -> b))
c.= Int; b
.= Bool
quadrat::Int -> Int
c -> a.= Int -> Int
even . quadrat :: ???
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 35: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/35.jpg)
Beispiel
even::Int -> Bool a -> b.= Int -> Bool
(.)::(a -> b) -> ((c -> a) -> (c -> b))
c.= Int; b
.= Bool
quadrat::Int -> Int
c -> a.= Int -> Int
even . quadrat :: ???
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 36: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/36.jpg)
Beispiel
even::Int -> Bool a -> b.= Int -> Bool
(.)::(a -> b) -> ((c -> a) -> (c -> b))
c.= Int; b
.= Bool
quadrat::Int -> Int c -> a.= Int -> Int
even . quadrat :: ???
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 37: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/37.jpg)
Beispiel
even::Int -> Bool a -> b.= Int -> Bool
(.)::(a -> b) -> ((c -> a) -> (c -> b)) c.= Int; b
.= Bool
quadrat::Int -> Int c -> a.= Int -> Int
even . quadrat :: ???
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 38: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/38.jpg)
Beispiel
even::Int -> Bool a -> b.= Int -> Bool
(.)::(a -> b) -> ((c -> a) -> (c -> b)) c.= Int; b
.= Bool
quadrat::Int -> Int c -> a.= Int -> Int
even . quadrat :: Int -> Bool
Grundlagen der Programmierung 2 (Typen-A) – 15/37 –
![Page 39: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/39.jpg)
Anwendungsregel fur polymorphe Typen
Ziel: Anwendung der Typregel fur z.B. length oder map
Neuer Begriff: γ ist eine Typsubstitutionwenn sie Typen fur Typvariablen einsetztγ(τ) nennt man Instanz von τ
BeispielTypsubstitution: γ = {a 7→ Char, b 7→ Float}Instanz: γ([a]→ Int) = [Char]→ Int
Grundlagen der Programmierung 2 (Typen-A) – 16/37 –
![Page 40: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/40.jpg)
Anwendungsregel fur polymorphe Typen
s :: σ → τ, t :: ρ und γ(σ) = γ(ρ)
(s t) :: γ(τ)
Berechnet den Typ von (s t)wenn die Typen von s, t schon bekannt sind
Hierbei ist zu beachten:Damit alle Freiheiten erhalten bleiben:
die Typvariablen in ρ mussen vorher umbenannt werden,so dass σ und ρ keine gemeinsamen Typvariablen haben.
Grundlagen der Programmierung 2 (Typen-A) – 17/37 –
![Page 41: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/41.jpg)
Beispiel zur polymorphen Anwendungsregel
Typ von (map quadrat) ?
map :: (a→ b) → ([a]→ [b])quadrat :: Int → Int
Instanziiere mit: γ = {a 7→ Int, b 7→ Int}ergibt: map :: (Int→ Int)→ ([Int]→ [Int])
Regelanwendung ergibt:
map :: (Int→ Int)→ ([Int]→ [Int]), quadrat :: (Int→ Int)
(map quadrat) :: [Int]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 18/37 –
![Page 42: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/42.jpg)
Beispiel zur polymorphen Anwendungsregel
Typ von (map quadrat) ?
map :: (a→ b) → ([a]→ [b])quadrat :: Int → Int
Instanziiere mit: γ = {a 7→ Int, b 7→ Int}
ergibt: map :: (Int→ Int)→ ([Int]→ [Int])
Regelanwendung ergibt:
map :: (Int→ Int)→ ([Int]→ [Int]), quadrat :: (Int→ Int)
(map quadrat) :: [Int]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 18/37 –
![Page 43: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/43.jpg)
Beispiel zur polymorphen Anwendungsregel
Typ von (map quadrat) ?
map :: (a→ b) → ([a]→ [b])quadrat :: Int → Int
Instanziiere mit: γ = {a 7→ Int, b 7→ Int}ergibt: map :: (Int→ Int)→ ([Int]→ [Int])
Regelanwendung ergibt:
map :: (Int→ Int)→ ([Int]→ [Int]), quadrat :: (Int→ Int)
(map quadrat) :: [Int]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 18/37 –
![Page 44: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/44.jpg)
Beispiel zur polymorphen Anwendungsregel
Typ von (map quadrat) ?
map :: (a→ b) → ([a]→ [b])quadrat :: Int → Int
Instanziiere mit: γ = {a 7→ Int, b 7→ Int}ergibt: map :: (Int→ Int)→ ([Int]→ [Int])
Regelanwendung ergibt:
map :: (Int→ Int)→ ([Int]→ [Int]), quadrat :: (Int→ Int)
(map quadrat) :: [Int]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 18/37 –
![Page 45: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/45.jpg)
Polymorphe Regel fur n Argumente
s :: σ1 → σ2 . . .→ σn → τ, t1 :: ρ1, . . . , tn :: ρn und ∀i : γ(σi) = γ(ρi)
(s t1 . . . tn) :: γ(τ)
Die Typvariablen in ρ1, . . . , ρn mussen vorher umbenannt werden.
Beachte: verwende moglichst allgemeines γ(kann berechnet werden; s.u.)
Grundlagen der Programmierung 2 (Typen-A) – 19/37 –
![Page 46: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/46.jpg)
Wie berechnet man die Typsubstitutionen?
Unifikation: Berechnung der allgemeinsten Typsubstitutionim Typberechnungsprogramm bzw Typchecker
Unifikation wird benutzt im Typchecker von Haskell!
Grundlagen der Programmierung 2 (Typen-A) – 20/37 –
![Page 47: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/47.jpg)
polymorphe Typen; Unifikation
s :: σ → τ , t :: ρ und γ ist allgemeinster Unifikator von σ.= ρ
(s t) :: γ(τ)
(die Typvariablen in ρ mussen vorher umbenannt werden.)
Grundlagen der Programmierung 2 (Typen-A) – 21/37 –
![Page 48: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/48.jpg)
Unifikation: Regelbasierter Algorithmus
Man braucht 4 Regeln, die auf (E;G) operieren:
E: Menge von Typgleichungen,G: Losung; mit Komponenten der Form x 7→ t.
Beachte: x, y ist Typvariablesi, ti, s, t sind Typen,f, g sind Typkonstruktoren
Grundlagen der Programmierung 2 (Typen-A) – 22/37 –
![Page 49: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/49.jpg)
Unifikation: Die Regeln
Start mit G = ∅;E: zu losende Gleichung(en)
• G; {x .= x} ∪ EG;E
• G; {t .= x} ∪ EG; {x .
= t} ∪ EWenn t keine Variable ist
• G; {x .= t} ∪ E
G[t/x] ∪ {x 7→ t};E[t/x]Wenn x nicht in t vorkommt
• G; {(f s1 . . . sn).= (f t1 . . . tn)} ∪ E
G; {s1.= t1, . . . , sn
.= tn)} ∪ E
Ersetzung: E[t/x]: alle Vorkommen von x werden durch t ersetztEffekt: G[t/x]: jedes y 7→ s wird durch y 7→ s[t/x] ersetzt
Grundlagen der Programmierung 2 (Typen-A) – 23/37 –
![Page 50: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/50.jpg)
Unifikation: Regelbasierter Algorithmus
Fehlerabbruch, wenn:
• x.= t in E, x 6= t und x kommt in t vor. (Occurs-Check)
• (f(. . .).= g(. . .) kommt in E vor und f 6= g. (Clash)
Fehlerabbruch bedeutet: nicht typisierbar
Grundlagen der Programmierung 2 (Typen-A) – 24/37 –
![Page 51: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/51.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) →
(
[a]→ [b]
)
id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 52: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/52.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 53: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/53.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 54: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/54.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 55: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/55.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 56: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/56.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}
{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 57: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/57.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}
{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 58: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/58.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅
{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 59: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/59.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 60: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/60.jpg)
Beispiel mit Typvariablen
Berechne Typ von (map id)
map:: (a→ b) → ([a]→ [b])id:: a′ → a′
Gesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= (a′ → a′):
G E
∅; {(a→ b).= (a′ → a′)}
∅; {a .= a′, b
.= a′}
{a 7→ a′}; {b .= a′}{a 7→ a′, b 7→ a′}; ∅{a 7→ a′, b 7→ a′};
Einsetzen der Losung γ = {a 7→ a′, b 7→ a′}in [a]→ [b] ergibt:
(map id) :: ([a′]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 25/37 –
![Page 61: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/61.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) →
(
[a]→ [b]
)
head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 62: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/62.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 63: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/63.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 64: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/64.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 65: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/65.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 66: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/66.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}
{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 67: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/67.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}
{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 68: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/68.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅
{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 69: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/69.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 70: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/70.jpg)
Noch ein Beispiel
Berechne Typ von (map head)
map:: (a→ b) → ([a]→ [b])head:: [a]→ aGesuchter Typ: γ([a]→ [b])
Regelanwendung benotigt Losung γ von (a→ b).= ([a′]→ a′):
G E
∅; {(a→ b).= ([a′]→ a′)}
∅; {a .= [a′], b
.= a′}
{a 7→ [a′]}; {b .= a′}{a 7→ [a′], b 7→ a′}; ∅{a 7→ [a′], b 7→ a′};
Einsetzen der Losung γ = {a 7→ [a′], b 7→ a′}in [a]→ [b] ergibt:
(map head) :: ([[a′]]→ [a′]).
Grundlagen der Programmierung 2 (Typen-A) – 26/37 –
![Page 71: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/71.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a]
umbenannt: c -> [c] -> [c]
([]) :: [a]
umbenannt: [d]
G E
∅
{a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 72: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/72.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 73: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/73.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 74: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/74.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 75: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/75.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 76: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/76.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 77: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/77.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 78: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/78.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 79: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/79.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 80: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/80.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 81: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/81.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 82: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/82.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 83: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/83.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 84: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/84.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}
{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 85: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/85.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 86: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/86.jpg)
Beispiel (foldr (:) []) :: ??
foldr :: (a -> b -> b) -> b -> [a] -> b
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ b.= c→ [c]→ [c], b
.= [d]}
{b 7→ [d]} {a→ [d]→ [d].= c→ [c]→ [c]}
{b 7→ [d]} {a .= c, [d]
.= [c], [d]
.= [c]}
{b 7→ [d], a 7→ c} {[d] .= [c], [d].= [c]}
{b 7→ [d], a 7→ c} {d .= c, [d]
.= [c]}
{b 7→ [c], a 7→ c, d 7→ c} {[c] .= [c]}{b 7→ [c], a 7→ c, d 7→ c} {c .= c}{b 7→ [c], a 7→ c, d 7→ c} {}
(foldr (:) [])::[c]→ [c] = γ([a]→ b)
Grundlagen der Programmierung 2 (Typen-A) – 27/37 –
![Page 87: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/87.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a]
umbenannt: c -> [c] -> [c]
([]) :: [a]
umbenannt: [d]
G E
∅
{a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 88: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/88.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 89: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/89.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 90: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/90.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 91: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/91.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 92: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/92.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 93: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/93.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 94: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/94.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 95: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/95.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 96: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/96.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 97: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/97.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 98: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/98.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .= [d]}
nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 99: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/99.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .= [d]}
nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 100: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/100.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}
nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 101: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/101.jpg)
Beispiel. Linksfaltung: (foldl (:) [])?
foldl :: (a -> b -> a) -> a -> [b] -> a
(:) :: a -> [a] -> [a] umbenannt: c -> [c] -> [c]
([]) :: [a] umbenannt: [d]
G E
∅ {a→ b→ a.= c→ [c]→ [c], a
.= [d]}
{a 7→ [d]} {[d]→ b→ [d].= c→ [c]→ [c]}
{a 7→ [d]} {[d] .= c, b.= [c], [d]
.= [c]}
{a 7→ [d], b 7→ [c]} {[d] .= c, [d].= [c]}
{a 7→ [d], b 7→ [c]} {c .= [d], [d].= [c]}
{a 7→ [d], b 7→ [[d]], c 7→ [d]} {[d] .= [[d]]}{a 7→ [d], b 7→ [[d]], c 7→ [d]} {d .
= [d]}nicht losbar, da d in [d] echt vorkommt
(foldl (:) []) ist nicht typisierbar!
Grundlagen der Programmierung 2 (Typen-A) – 28/37 –
![Page 102: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/102.jpg)
Beispiel zu Typberechnung
Typ von map length
map :: (a→ b)→ ([a]→ [b]), length :: [a′]→ Int
(map length) :: ? = γ([a]→ [b])
Unifiziere (a→ b).= [a′]→ Int
G E
∅; {(a→ b).= ([a′]→ Int)}
∅; {a .= [a′], b
.= Int}
{a 7→ [a′]}; {b .= Int}{a 7→ [a′], b 7→ Int}; ∅
Somit: (map length) :: γ([a]→ [b]) = [[a′]]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 29/37 –
![Page 103: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/103.jpg)
Beispiel zu Typberechnung
Typ von map length
map :: (a→ b)→ ([a]→ [b]), length :: [a′]→ Int
(map length) :: ? = γ([a]→ [b])
Unifiziere (a→ b).= [a′]→ Int
G E
∅; {(a→ b).= ([a′]→ Int)}
∅; {a .= [a′], b
.= Int}
{a 7→ [a′]}; {b .= Int}{a 7→ [a′], b 7→ Int}; ∅
Somit: (map length) :: γ([a]→ [b]) = [[a′]]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 29/37 –
![Page 104: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/104.jpg)
Beispiel zu Typberechnung
Typ von map length
map :: (a→ b)→ ([a]→ [b]), length :: [a′]→ Int
(map length) :: ? = γ([a]→ [b])
Unifiziere (a→ b).= [a′]→ Int
G E
∅; {(a→ b).= ([a′]→ Int)}
∅; {a .= [a′], b
.= Int}
{a 7→ [a′]}; {b .= Int}{a 7→ [a′], b 7→ Int}; ∅
Somit: (map length) :: γ([a]→ [b]) = [[a′]]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 29/37 –
![Page 105: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/105.jpg)
Beispiel zu Typberechnung
Typ von map length
map :: (a→ b)→ ([a]→ [b]), length :: [a′]→ Int
(map length) :: ? = γ([a]→ [b])
Unifiziere (a→ b).= [a′]→ Int
G E
∅; {(a→ b).= ([a′]→ Int)}
∅; {a .= [a′], b
.= Int}
{a 7→ [a′]}; {b .= Int}
{a 7→ [a′], b 7→ Int}; ∅
Somit: (map length) :: γ([a]→ [b]) = [[a′]]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 29/37 –
![Page 106: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/106.jpg)
Beispiel zu Typberechnung
Typ von map length
map :: (a→ b)→ ([a]→ [b]), length :: [a′]→ Int
(map length) :: ? = γ([a]→ [b])
Unifiziere (a→ b).= [a′]→ Int
G E
∅; {(a→ b).= ([a′]→ Int)}
∅; {a .= [a′], b
.= Int}
{a 7→ [a′]}; {b .= Int}{a 7→ [a′], b 7→ Int}; ∅
Somit: (map length) :: γ([a]→ [b]) = [[a′]]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 29/37 –
![Page 107: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/107.jpg)
Beispiel zu Typberechnung
Typ von map length
map :: (a→ b)→ ([a]→ [b]), length :: [a′]→ Int
(map length) :: ? = γ([a]→ [b])
Unifiziere (a→ b).= [a′]→ Int
G E
∅; {(a→ b).= ([a′]→ Int)}
∅; {a .= [a′], b
.= Int}
{a 7→ [a′]}; {b .= Int}{a 7→ [a′], b 7→ Int}; ∅
Somit: (map length) :: γ([a]→ [b]) = [[a′]]→ [Int]
Grundlagen der Programmierung 2 (Typen-A) – 29/37 –
![Page 108: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/108.jpg)
Beispiele zu polymorpher Typberechnung
Berechne Typ der Liste [1]:
1 : Int (:) :: a→ [a]→ [a] [] :: [b]
1 : [] ::?
Anwendungsregel ergibt Gleichungen: {a .= Int, [a]
.= [b]}
Losung: γ = {a 7→ Int}
Typ (1 : []) :: [Int]
Grundlagen der Programmierung 2 (Typen-A) – 30/37 –
![Page 109: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/109.jpg)
Beispiel zu Typfehler
[1, ’a’] hat keinen Typ:• 1 : ( ’a’ : [])• 1 :: Integer, [] :: [b], ’a’ :: Char (Typen der Konstanten.)• (1 :) :: [Integer]→ [Integer] und
(’a’:[]) :: [Char].
Kein Typ als Resultat, denn:[Integer]
.= [Char] ist nicht losbar.
Grundlagen der Programmierung 2 (Typen-A) – 31/37 –
![Page 110: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/110.jpg)
Beispiel zu Typfehler im Interpreter
Prelude> [1,’a’] ←↩
<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) – 32/37 –
![Page 111: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/111.jpg)
Typ eines Ausdrucks
Typ von (map quadrat [1,2,3,4]) :• map:: (a→ b)→ [a]→ [b]
• 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) – 33/37 –
![Page 112: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/112.jpg)
Typisierung von Funktionen und Ausdrucken
Kompexe Sprachkonstrukte: rekursiv definierte FunktionenLambda-Ausdrucke, let-AusdruckeListen-Komprehensionen.
Typcheckalgorithmus von Robin Milner (in Haskell und ML)• ist schnell, (i.a.)• liefert allgemeinste (Milner-)Typen• benutzt Unifikation (eine optimierte Variante)
• schlechte worst-case Komplexitat:in seltenen Fallen exponentieller Zeitbedarf
• Liefert in seltenen Fallen nichtdie allgemeinsten moglichen polymorphen Typen
Grundlagen der Programmierung 2 (Typen-A) – 34/37 –
![Page 113: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/113.jpg)
Typisierung von Funktionen, Milner
Satz zur Milner-Typisierung in Haskell:
Sei t ein getypter Haskell-Ausdruck, ohne freie Variablen.Dann wird die Auswertung des Ausdrucks tnicht mit einem Typfehler abbrechen.
Allgemeine Aussage zu starken Typsystemen
Es gibt keine dynamischen Typfehler,wenn das Programm statisch korrekt getypt ist
Grundlagen der Programmierung 2 (Typen-A) – 35/37 –
![Page 114: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/114.jpg)
Typisierung und Reduktion
Beachte: Nach Reduktionen kann ein Ausdruckmehr Typen (bzw. einen allgemeineren Typ) habenals vor der Reduktion
Beispiel:if 1 > 0 then [] else [1] :: [Integer]
arithmetische-Reduktion:−→ if True then [] else [1] :: [Integer]
Case-Reduktion:−→ [] :: [a]
Grundlagen der Programmierung 2 (Typen-A) – 36/37 –
![Page 115: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/115.jpg)
Typisierung und Reduktion
Beachte: Nach Reduktionen kann ein Ausdruckmehr Typen (bzw. einen allgemeineren Typ) habenals vor der Reduktion
Beispiel:if 1 > 0 then [] else [1] :: [Integer]
arithmetische-Reduktion:−→ if True then [] else [1] :: [Integer]
Case-Reduktion:−→ [] :: [a]
Grundlagen der Programmierung 2 (Typen-A) – 36/37 –
![Page 116: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/116.jpg)
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) – 37/37 –
![Page 117: Grundlagen der Programmierung 3 A - Benutzer-Homepagesprg2/SS2017/folien/teil1/fol-3A-typ.pdf · Typisierung in Haskell Haskell hat eine starke, statische Typisierung. mitparametrisch](https://reader030.vdocuments.pub/reader030/viewer/2022041207/5d5ff01988c993b2608bde82/html5/thumbnails/117.jpg)
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) – 37/37 –