Programmieren in Haskell Das Haskell Typsystem

Transkript

1 Programmieren in Haskell Das Haskell Typsystem Peter Steffen Robert Giegerich Universität Bielefeld Technische Fakultät Programmieren in Haskell

2 Belauscht... Lisa Lista: Ohne Typen keine korrekten Programme! Harry Hacker: Ach was! Korrekte Programme brauchen keine Typen! Wer hat recht? 2 Programmieren in Haskell

3 Einfache Datentypen (vordefiniert) Die einfachsten Datentypen: Bool (), genannt Void Char Int, Integer Rational, Float, Double Int -> Int, Int -> Musik -> Musik, etc. In einer funktionalen Sprache sind auch Funktionen Daten erster Klasse sie können nicht nur auf Argumente angewandt werden, sondern auch in Datenstrukturen verpackt, als Argumente übergeben, oder zu neuen Funktionen zusamengesetzt werden, also Ergebnisse sein. Nur Vergleichen (EQ) und Ausdrucken (Show) kann man sie nicht. 3 Programmieren in Haskell

4 Algebraische Datentypen Algebraische Datentypen werden durch Konstruktoren gebildet. Eigentlich stellen sie die Formeln dar, mit denen dann gerechnet wird. Musik (mit Konstruktoren Instr, Tempo, Note, Pause, *, +) Bool (mit Konstruktoren True, False) Ordering (mit Konstruktoren LT, EQ, GT) Von diesen Beispielen ist nur Musik ein rekursiver Datentyp, der beliebig viele (und aus viele Teilen zusammengesetzte) Werte enthält. 4 Programmieren in Haskell

5 Monomorphe Listen Listen mit Elementen vom Typ Int: data Intlist = IntNil IntCons Int IntList Einwände: Das ist wenig nützlich für jeden weiteren Element-Datentyp muss man einen neuen Listentyp einführen. (In manchen Programmiersprachen ist das tatsächlich so!) Viele Operationen mit Listen hängen nicht vom Elementtyp ab die möchte man nur einmal programmieren! 5 Programmieren in Haskell

6 Das Haskell-Typkonzept ist so stark, dass Typ-korrrekte Proramme oft auch schon korrekt sind. Das liegt am parametrischen Typ-Polymorphismus. Typen werden dadurch flexibler, aber weiter gilt der alte Grundsatz: Ein typ-korrektes Programm erzeugt zur Laufzeit keine Typfehler. oder auch Well-typed programs don t go wrong. 6 Programmieren in Haskell

7 Haskell erlaubt parametrisierte Typen: data [a] = [] a:[a] -- polymorphe Listen -- beachte: alle Elemente haben den gleichen Typ data Tree a = Leaf a Br (Tree a) (Tree a) data TTree a b = Leaf a Br (Tree b a) [a] (Tree b a) -- hier wechseln die Typen pro Ebene, -- aber streng kontrolliert f g :: [a] -> [a] :: Tree a -> [a] 7 Programmieren in Haskell

8 Typdeklarationen Typdeklarationen in Haskell sind optional. Sie dienen der Dokumentation der bewußten Einschränkung des Typs (enger als nötig), z.b. reversi:: [Int] -> [Int] reversi xs = reverse xs wenn man möchte, dass reversi NUR auf Int-Listen angewandt werden kann. Auch ohne Typdeklarationen können alle Typen bestimmt und geprüft werden. 8 Programmieren in Haskell

9 Typinferenz Grundlegendes zur Typinferenz: Jeder Ausdruck in einem Haskell-Programm hat einen allgemeinsten Typ. Dieser Typ kann automatisch bestimmt werden durch Typinferenz. Beim Rechnen spielen die Typen keine Rolle (mehr). Meistens stimmt der inferierte Typ mit dem deklarierten (sofern vorhanden) überein. Andernfalls gilt: Der deklarierte Typ ist allgemeiner: FEHLER Der deklarierte Typ ist spezieller: Der allgemeine Typ wird entsprechend eingeschränkt. DieTypen sind unvergleichbar: FEHLER 9 Programmieren in Haskell

10 Allgemeiner und spezieller... a -- der allgemeinste Typ, den es gibt -- (a ist beliebige Typvariable) a -> b -- der allgemeinste Funktionstyp, den es gibt Ein Typ ist spezieller als ein anderer, wenn er aus ihm durch (konsistentes) Einsetzen für Typvariablen entsteht. Hier eine Kette von Spezialisierungen: a ==> b ==> (a -> b) => a -> (c -> d) ==> a -> b -> b ==> a -> [a] -> [a] -- das ist der Typ von (:) ==> Tree b -> [Tree b] -> [Tree b] -- (:) in einer Anwendung 10 Programmieren in Haskell

11 Beispiele zur Typinferenz Der Typ einer polymorphen Funktion spezialsiert sich in der Anwendung: (:) :: a -> [a] -> [a] ( a :"braham") :: [Char] (: "xx") :: Char -> [Char] ( x :) :: [Char] -> [Char] ("x":) :: [[Char]] -> [[Char]] Hugs> :type (: a ) ERROR - Type error in application *** Expression : (: a ) *** Term : (:) *** Type : b -> [b] -> [b] *** Does not match : a -> Char -> [b] Scheitert die Typinferenz, liegt ein Fehler vor. 11 Programmieren in Haskell

12 Typinferenz für map Wir gehen von der Definition aus: map f [] = [] map f (x:xs) = f x : map f xs ermittelter Typ Begründung c -> d -> e -- map hat 2 Argumente c -> d -> [b] -- das Ergebnis ist eine Liste c -> [a] -> [b] -- das 2. Argument ist eine Liste (f -> g) -> [a] -> [b] -- das 1.Argument ist eine Funktion, (a -> g) -> [a] -> [b] -- die Argumente vom Typ a erhält, (a -> b) -> [a] -> [b] -- und Ergebnisse vom Typ b liefert. Den allgemeinsten Typ erhalten wir, weil wir nirgendwo eine unnötige Annahme machen. 12 Programmieren in Haskell

13 Typinferenz eines Audrucks Wir gehen von bereits bekannten Typen für Zahlen und vordefinierte Funktionen aus und leiten eine Typaussage für einen Ausdruck ab: map (1:)::h -- der Ausdruck hat einen Typ map:: (a -> b) -> [a] -> [b] -- bereits bekannt (:):: c -> [c] -> [c] -- bereits bekannt 1::Int -- bereits bekannt c == Int -- 1 erstes Argument von (:) (:):: Int -> [Int] -> [Int] -- Typ von (:) in diesem Kontext (1:):: [Int] -> [Int] -- (:) angewandt aufs erste Argument -- bleibt eine Funktion des zweiten 13 Programmieren in Haskell

14 [a] -> [b] == [Int] -> [Int] -- (1:) ist erstes Argument von map a == Int, b == Int -- Konsequenz des vorigen map:: ([Int] -> [Int]) -> [[Int]] -> [[Int]] -- spezieller Typ von -- map in diesem Ausdruck map (1:):: [[Int]] -> ][Int]]-- map angewandt auf erstes Argument -- bleibt eine Funktion des zweiten h == [[Int]] -> [[Int]] -- allgemeinster Typ für map (1:)... und das stimmt überein mit dem, was diese Funktion berechnet: Hugs> map (1:) [[5..9],[20..24],[2,4..8]] [[1,5,6,7,8,9],[1,20,21,22,23,24],[1,2,4,6,8]] 14 Programmieren in Haskell

15 Typinferenz mit In Wirklichkeit ist es noch etwas komplizierter. Man weiss ja nur, dass 1 eine Zahl ist, also der Typklasse NUM angehört. Hugs> :type 1 1 :: Num a => a Hugs> :type (1:) (1 :) :: Num a => [a] -> [a] Hugs> :type map (1:) map (1 :) :: Num a => [[a]] -> [[a]] Hugs> :type map ((1::Integer):) map (1:) :: [[Integer]] -> [[Integer]] Hugs> :type map (1.5:) map (1.5 :) :: Fractional a => [[a]] -> [[a]] 15 Programmieren in Haskell

16 können auf alle Daten angewandt werden, zu deren Typ sich ihr allgemeiner Typ spezialisieren lässt. Vorteil: Kompakter Code, wenig Fehler. 16 Programmieren in Haskell

17 Was sagt ihr Typ über die Funktion? Wir kennen: id :: a -> a ix x = x Welche andere Funktionen gibt es noch von diesem recht allgemeinen Typ, (abgesehen von umständlicheren Definitionen der gleichen Funktion)? Keine. 17 Programmieren in Haskell

18 Was sagt ihr Typ über die Funktion? Wir kennen: id :: a -> a ix x = x Welche andere Funktionen gibt es noch von diesem recht allgemeinen Typ, (abgesehen von umständlicheren Definitionen der gleichen Funktion)? Keine. 17 Programmieren in Haskell

19 Was sagt ihr Typ über die Funktion? (2) Welche Funktion hat den noch allgemeineren Typ f :: a -> b 18 Programmieren in Haskell

20 Was sagt ihr Typ über die Funktion? (2) Welche Funktion hat den noch allgemeineren Typ f :: a -> b Die überall undefinierte Funktion... f :: a -> b f x = f x... und sonst keine. 19 Programmieren in Haskell

21 Fluch der Allgemeinheit Auf der ersten Blick scheint es paradox: Die Funktionen mit den allgemeinsten Typen f:: a -> b f:: a -> a sind die nutzlosesten Funktionen! 20 Programmieren in Haskell

22 höherer Ordnung (1) Was mag das sein: srol:: solution -> (a -> [a] -> solution -> solution)-> [a] -> solution srol base extend = rec where rec [] = base rec (x:xs) = extend x xs (rec xs) 21 Programmieren in Haskell

23 höherer Ordnung (1) Was mag das sein: srol:: solution -> (a -> [a] -> solution -> solution)-> [a] -> solution srol base extend = rec where rec [] = base rec (x:xs) = extend x xs (rec xs) 21 Programmieren in Haskell

24 srol in Worten srol ist eine Funktion, die als Arfumente einen Wert und eine Funktion erwartet. Angewandt auf diese, ergibt sie eine Funktion, die Listen verarbeitet und dabei für die leere Liste den Wert einsetzt, und ansonsten den Listenrest verarbeitet und sodann das Ergebnis abhängig vom Listenkopf modifiziert. Oder anders gesagt: srol ist das SCHEMA der strukturellen Rekursion auf Listen. 22 Programmieren in Haskell

25 srol in Worten srol ist eine Funktion, die als Arfumente einen Wert und eine Funktion erwartet. Angewandt auf diese, ergibt sie eine Funktion, die Listen verarbeitet und dabei für die leere Liste den Wert einsetzt, und ansonsten den Listenrest verarbeitet und sodann das Ergebnis abhängig vom Listenkopf modifiziert. Oder anders gesagt: srol ist das SCHEMA der strukturellen Rekursion auf Listen. 22 Programmieren in Haskell

26 srol angewandt isort = srol [] (\a _ s -> insert a s) insert a = srol [a] (\b x s -> if a <= b then a:b:x else b:s) Man muss sich klarmachen, dass s jeweils die (rekursiv errechnete) Lösung der Aufgabe für x darstellt! 23 Programmieren in Haskell

27 srol Varianten srol bezieht sich explizit auf den Datentyp Liste. Es werden ja die beiden Konstruktoren [] und (:) explizit benutzt. Für andere Datentypen wie Musik oder Tree muss ein eigenes Schema definiert werden. Das wird noch eleganter bei der Wohlfundierten Rekursion! 24 Programmieren in Haskell

28 Schema der Wohlfundierten Rekursion problem steht für den Datentyp, für den wir ein Problem mit Wohlfundierter Rekursion lösen wollen. dac:: (problem -> Bool) -> (problem -> solution) -> (problem -> [problem]) -> ([solution] -> solution) -> problem -> solution -- easy -- solve -- divide -- conquer dac easy solve divide conquer = rec where rec x = if easy x then solve x else conquer [rec y y <- divide x] 25 Programmieren in Haskell

29 Anwendung von dac Implementierung des mergesort: msort = dac (\x -> drop 1 x == []) (\x -> x) (\x -> let k = length x div 2 in [take k x, drop k x] (\[s,t] -> merge s t) Wo ist die Rekursion geblieben? Sie wird vom Scheme dac eingebracht das, worauf merge angewandt wird, ist der msort von (take k x) und (drop k x). 26 Programmieren in Haskell

30 Anwendung von dac Implementierung des mergesort: msort = dac (\x -> drop 1 x == []) (\x -> x) (\x -> let k = length x div 2 in [take k x, drop k x] (\[s,t] -> merge s t) Wo ist die Rekursion geblieben? Sie wird vom Scheme dac eingebracht das, worauf merge angewandt wird, ist der msort von (take k x) und (drop k x). 26 Programmieren in Haskell

31 Schlussfolgerungen Funktionen höherer Ordnung sind ein machtvolles Hilfsmittel: Sie erlauben, beliebige Schemata der Benutzung von funktionellen Bauteilen zu definieren Sie ersetzen das, was man in anderen Sprachen Kontrollstruktur nennt. Sie erlauben dem Programmierer, seine eigenen Kontrollstrukturen zu definieren. Dadurch lassen sich anwendungsbezogene Programmierstile entwickeln Beispiele sind Pretty printing Combinator Parsing Algebraic Dynamic Programming 27 Programmieren in Haskell

32 Eine Typklasse ist eine Menge von Typen. Sie ist charakterisiert durch eine Menge von Funktionen, die auf allen Typen dieser Klasse und mit dem gleichen Namen definiert sind. Diese Funktionen nennt man in diesem Zusammenhang gerne Methoden. Vordefinierte sind Show mit Methoden show, read,... Eq mit Methoden ==, / = Ord mit Methoden <, >,,... Num mit Methoden +,,,... und viele andere. 28 Programmieren in Haskell

33 Neue Neue werden durch Klassendefinitionen eingeführt, die die Typen der Operationen (hier gerne Methoden genannt) deklarieren. Es können auch einige der Methoden als Default definiert werden, indem sie sich gegenseitig benutzen. Wenn ein Typ zur Instanz einer Klasse erklärt wird, müssen die Methoden implementiert werden. 29 Programmieren in Haskell

34 Beispiel: Klasse Sequenzen class Sequence s where empty :: s a single :: a -> s a isempty :: s a -> Bool issingle :: s a -> Bool vorndran :: a -> sa -> s a hintan :: sa -> a -> s a hd :: s a -> a tl :: s a -> s a app :: s a -> s a -> s a len :: s a -> Int single a = vorndran a empty issingle s = not(isempty s) && isempty (tl s) len s = if empty s then 0 else 1 + len (tl s) 30 Programmieren in Haskell

35 Instanziierung Ein Datentyp kann zur Instanz einer Klasse erklärt werden: instance Sequence [] where... instance Tree [] where... Hier müssen jeweils die Methoden implementiert werden. Fehlt eine Implementierung, werden die Defaults aus der Klassendefinition eingesetzt. Diverse Instanziierungen von Sequence findet man im Skript. 31 Programmieren in Haskell