Programmieren in Haskell

Transkript

1 Programmieren in Haskell Monaden Programmieren in Haskell 1

2 Sequenzierung mit Dollar und Euro Die Atommüll-Metapher Maybe- und Listen-Monaden Return Die do-notation Monaden als Berechnungen Listenbeschreibungen und Monaden State-Monaden Die IO-Monade Was wir heute machen Programmieren in Haskell 2

3 Dollar i (h (g (f x))) i $ h $ g $ f x Programmieren in Haskell 3

4 Dollar i (h (g (f x))) i $ h $ g $ f x infixr 0 $ ($) :: (a -> b) -> a -> b f $ x = f x Programmieren in Haskell 3

5 Euro infixl 0 > ( >) :: a -> (a -> b) -> b x > f = f x i $ h $ g $ f x f x > g > h > i f x > g > h > i Programmieren in Haskell 4

6 Atommüll-Metapher Abfall-Prozessoren sind eine Metapher für Funktionen. Sie nehmen Atommüll, verarbeiten ihn und spucken Atommüll aus: Programmieren in Haskell 5

7 Abfall-Container Atommüll ist gefährlich, also wird er verpackt: Programmieren in Haskell 6

8 bind-roboter Ein bind-roboter entpackt einen Container und steckt den Inhalt (Atommüll) in einen Prozessor: Programmieren in Haskell 7

9 bind (>>=) container >>= fn = let a = extractwaste container in fn a (>>=) :: m a -> (a -> m b) -> m b Programmieren in Haskell 8

10 bind (>>=) container >>= fn = let a = extractwaste container in fn a (>>=) :: m a -> (a -> m b) -> m b Mit dem bind-roboter können wir Prozessoren hintereinanderschalten: wasteinacontainer >>= (\a1 -> putincontainer (decompose a1)) >>= (\a2 -> putincontainer (decay a2)) >>= (\a3 -> putincontainer (melt a3)) Programmieren in Haskell 8

11 Bisherige Metaphern 1. Prozessoren (Funktionen) 2. Atommüll (Eingaben) 3. Container (monadische Werte) 4. Der bind-roboter >>= 5. Fabriken (Monaden) Programmieren in Haskell 9

12 Die Maybe-Monade Zur Erinnerung der Maybe-Datentyp: data Maybe a = Nothing Just a Programmieren in Haskell 10

13 Die Maybe-Monade Zur Erinnerung der Maybe-Datentyp: data Maybe a = Nothing Just a Die bind-funktion: container >>= fn = case container of Nothing -> Nothing Just a -> fn a (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Programmieren in Haskell 10

14 Die Listen-Monade container >>= fn = case container of [] -> [] xs -> concat (map fn xs) (>>=) :: [a] -> (a -> [b]) -> [b] Programmieren in Haskell 11

15 Return Was machen wir mit Maschinen, die direkt Atommüll ausgeben ohne ihn vorher in Container zu verpacken? return :: a -> m a Das ist unsere Funktion putincontainer von vorhin. Programmieren in Haskell 12

16 Return Was machen wir mit Maschinen, die direkt Atommüll ausgeben ohne ihn vorher in Container zu verpacken? return :: a -> m a Das ist unsere Funktion putincontainer von vorhin. Die return-funktion für Maybe: return a = Just a Programmieren in Haskell 12

17 Return Was machen wir mit Maschinen, die direkt Atommüll ausgeben ohne ihn vorher in Container zu verpacken? return :: a -> m a Das ist unsere Funktion putincontainer von vorhin. Die return-funktion für Maybe: return a = Just a und für Listen: return a = [a] Programmieren in Haskell 12

18 Die do-notation Monadischer Code wie bisher: wasteinacontainer >>= \a1 -> foo a1 >>= \a2 -> bar a2 >>= \a3 -> baz a3 Programmieren in Haskell 13

19 Die do-notation Monadischer Code wie bisher: wasteinacontainer >>= \a1 -> foo a1 >>= \a2 -> bar a2 >>= \a3 -> baz a3 Etwas anders geschrieben: wasteinacontainer >>= \a1 -> foo a1 >>= \a2 -> bar a2 >>= \a3 -> baz a3 Programmieren in Haskell 13

20 Die do-notation Monadischer Code wie bisher: wasteinacontainer >>= \a1 -> foo a1 >>= \a2 -> bar a2 >>= \a3 -> baz a3 Etwas anders geschrieben: wasteinacontainer >>= \a1 -> foo a1 >>= \a2 -> bar a2 >>= \a3 -> baz a3 Und mit syntaktischem Zucker: do a1 <- wasteinacontainer a2 <- foo a1 a3 <- bar a2 baz a3 Programmieren in Haskell 13

21 Monaden als Berechnungen Unserer bisherige Metapher sah Monaden als Container. Jetzt interpretieren wir Monaden als Berechnungen: >>=: verkettet zwei monadische Berechnungen (lässt die erste Berechnung laufen, füttert das Ergebnis in die zweite Berechung und lässt auch diese laufen) return x: die Berechung, die einfach x als Ergebnis hat Programmieren in Haskell 14

22 Rechnen mit der Maybe-Monade Beginnen wir mit einem Telefonbuch: phonebook :: [(String,String)] phonebook = [ ("Bob", " "), ("Fred", " "), ("Alice", " "), ("Jane", " ") ] Programmieren in Haskell 15

23 Rechnen mit der Maybe-Monade Beginnen wir mit einem Telefonbuch: phonebook :: [(String,String)] phonebook = [ ("Bob", " "), ("Fred", " "), ("Alice", " "), ("Jane", " ") ] Darin können wir nach Namen und dazu gespeicherten Telefonnummern suchen: lookup :: a -- Schluessel -> [(a, b)] -- Lookup-Tabelle -> Maybe b -- Ergebnis des Lookups Programmieren in Haskell 15

24 Programmieren in Haskell 16

25 Beispiel: Prelude> lookup "Bob" phonebook Just " " Prelude> lookup "Jane" phonebook Just " " Prelude> lookup "Zoe" phonebook Nothing Programmieren in Haskell 16

26 Kombination von Lookups comb :: Maybe a -> (a -> Maybe b) -> Maybe b comb Nothing _ = Nothing comb (Just x) f = Just $ f x Programmieren in Haskell 17

27 Kombination von Lookups comb :: Maybe a -> (a -> Maybe b) -> Maybe b comb Nothing _ = Nothing comb (Just x) f = Just $ f x comb ist nichts anderes als der bind-operator (>>=) für Maybe-Berechnungen. Also: gettaxowed :: String -- Name -> Maybe Double -- Steuerschuld gettaxowed name = lookup name phonebook >>= (\number -> lookup number governmentaldatabase) >>= (\registration -> lookup registration taxdatabase) Programmieren in Haskell 17

28 Kombination von Lookups comb :: Maybe a -> (a -> Maybe b) -> Maybe b comb Nothing _ = Nothing comb (Just x) f = Just $ f x comb ist nichts anderes als der bind-operator (>>=) für Maybe-Berechnungen. Also: gettaxowed :: String -- Name -> Maybe Double -- Steuerschuld gettaxowed name = lookup name phonebook >>= (\number -> lookup number governmentaldatabase) >>= (\registration -> lookup registration taxdatabase) Oder in der do-notation: Programmieren in Haskell 17

29 gettaxowed name = do number <- lookup name phonebook registration <- lookup number governmentaldatabase lookup registration taxdatabase Programmieren in Haskell 18

30 Die weiteren Tabellen: governmentaldatabase :: [(String,String)] governmentaldatabase = [ (" ", "B "), (" ", "F "), (" ", "A "), (" ", "J ") ] taxdatabase :: [(String,String)] taxdatabase = [ ("B ", "lots of"), ("F ", "not so much"), ("A ", "gets something back"), ("J ", "criminal") ] Programmieren in Haskell 19

31 do number <- lookup "Bob" phonebook registration <- lookup number governmentaldatabase taxowed <- lookup registration taxdatabase return taxowed => Just "lots of" Programmieren in Haskell 20

32 do number <- lookup "Bob" phonebook registration <- lookup number governmentaldatabase taxowed <- lookup registration taxdatabase return taxowed => Just "lots of" do number <- lookup "Zoe" phonebook registration <- lookup number governmentaldatabase taxowed <- lookup registration taxdatabase return taxowed Programmieren in Haskell 20

33 do number <- lookup "Bob" phonebook registration <- lookup number governmentaldatabase taxowed <- lookup registration taxdatabase return taxowed => Just "lots of" do number <- lookup "Zoe" phonebook registration <- lookup number governmentaldatabase taxowed <- lookup registration taxdatabase return taxowed => Nothing Programmieren in Haskell 20

34 Eigenschaften der Maybe-Monade Die Maybe-Monade repräsentiert Berechnungen, die versagen können Versagen wird propagiert! Programmieren in Haskell 21

35 Die Listen-Monade Berechnungen in der Listen-Monade reprässentieren null oder mehr gültige Antworten: instance Monad [] where return a = [a] xs >>= f = concat (map f xs) Programmieren in Haskell 22

36 Tic-Tac-Toe Wir wollen alle Brett-Konfigurationen ausrechnen, die sich nach drei Zügen ergeben können: getnextconfigs :: Board -> [Board] getnextconfigs = details not important tick :: [Board] -> [Board] tick bds = concatmap getnextconfigs bds find3rdconfig :: Board -> [Board] find3rdconfig bd = tick $ tick $ tick [bd] Programmieren in Haskell 23

37 Tic-Tac-Toe Wir wollen alle Brett-Konfigurationen ausrechnen, die sich nach drei Zügen ergeben können: getnextconfigs :: Board -> [Board] getnextconfigs = details not important tick :: [Board] -> [Board] tick bds = concatmap getnextconfigs bds find3rdconfig :: Board -> [Board] find3rdconfig bd = tick $ tick $ tick [bd] Mit der Listen-Monade: Programmieren in Haskell 23

38 find3rdconfig :: Board -> [Board] find3rdconfig bd0 = do bd1 <- getnextconfigs bd0 bd2 <- getnextconifgs bd1 bd3 <- getnextconfigs bd2 return bd3 Programmieren in Haskell 24

39 Listenbeschreibungen und Monaden pythags = [ (x, y, z) x <- [1..], y <- [x..], z <- [y..], x^2 + y^2 == z^2 ] Programmieren in Haskell 25

40 Listenbeschreibungen und Monaden pythags = [ (x, y, z) x <- [1..], y <- [x..], z <- [y..], x^2 + y^2 == z^2 ] pythags = do x <- [1..] y <- [x..] z <- [y..] guard (x^2 + y^2 == z^2) return (x, y, z) Programmieren in Haskell 25

41 guard :: Bool -> [()] guard True = [()] guard False = [] Programmieren in Haskell 26

42 guard :: Bool -> [()] guard True = [()] guard False = [] pythags = let ret x y z = [(x, y, z)] gd x y z = concatmap (\_ -> ret x y z) (guard $ x^2 + y^2 == z^2) doz x y = concatmap (gd x y) [y..] doy x = concatmap (doz x ) [x..] dox = concatmap (doy ) [1..] in dox Programmieren in Haskell 26

43 start... x y z Programmieren in Haskell 27

44 Seiteneffekte mit der State-Monade Container werden mit einem Ticket gefüttert und geben ihren Inhalt und ein neues Ticket (eine Quittung) aus: Programmieren in Haskell 28

45 bind in der State-Monade Programmieren in Haskell 29

46 Input/Output Die IO-Monade ist eine State-Monade, in der der Zustand die komplette Umgebung ist. Dies erlaubt sequentielle Ein-/Ausgabe: f = do putstrln "What is your name?" name <- getline putstrln ("Nice to meet you, " ++ name ++ "!") Programmieren in Haskell 30

47 Input/Output Die IO-Monade ist eine State-Monade, in der der Zustand die komplette Umgebung ist. Dies erlaubt sequentielle Ein-/Ausgabe: f = do putstrln "What is your name?" name <- getline putstrln ("Nice to meet you, " ++ name ++ "!") Diese Konstruktion legt die Auswertungsreihenfolge fest! Programmieren in Haskell 30

48 Copyright notice Programmieren in Haskell 31