Monaden. 14. Januar 2015

Transkript

1 Universität Bielefeld AG Praktische Informatik 14. Januar 2015

2 Imperativ nennt man Progamiersprachen, die mit Anweisungen operieren. Jede Anweisung hat Wirkungen auf einen globalen Zustand, der wiederum die nächsten Anweisugen beeinflusst. Solche imperativen Elemente braucht man auch in einer funktionalen Sprache, zum Beispiel zur Kommunikation mit der Außenwelt, sei es Ein- oder Ausgabe von Benutzerdaten, oder die Steuerung von Prozessen. Allgemeines

3 Was heißt imperativ? Ein imperatives Programm besteht aus Anweisungen. Sie modifizieren einen globalen Zustand (Speicherzellen, Variablen, Drucker, Datei, ), und hängen auch von ihm ab. imp. Funktionen sind oft keine Funktionen im mathematischen Sinn, Wert von f (x) hängt nicht nur von x, sondern auch vom gerade vorliegenden Zustand ab, d.h. das Prinzip der referential transparency ist verletzt. Die Ausführungsreihenfolge ist wesentlich und im Detail festgelegt. Beispiel: URM-Programme, C, Pascal, Java,... Allgemeines

4 Referential Transparency (Wiederholung) ein Funktionsaufruf hat keine Seiteneffekte bei gleichen Argumentwerten bleibt der Funktionswert gleich wesentliches Merkmal von (puren) funktionalen Programmiersprachen Vorteile bei der Analyse (Korrektheit, Effizienz,... ) und Optimierung von Code Allgemeines

5 Referential Transparency (Wiederholung) ein Funktionsaufruf hat keine Seiteneffekte bei gleichen Argumentwerten bleibt der Funktionswert gleich wesentliches Merkmal von (puren) funktionalen Programmiersprachen Vorteile bei der Analyse (Korrektheit, Effizienz,... ) und Optimierung von Code Beispiel für eine C-Funktion mit Seiteneffekten 1 int a = 0; Allgemeines 2 3 int f( int x) 4 { 5 a = a + 1; 6 return x * x * a; 7 }

6 Funktionale im Unterschied zur imperativen Funktionale Sprache: Es werden nur Datenabhängigkeiten beschrieben, diese sind explizit ( referential transparency ), eine Berechnungsreihenfolge ist nicht festgelegt. Es gibt keine Anweisungen, keinen Zustand, kein vorher/nachher Kann man eine zustandsbasierte Rechnung simulieren, wenn man sie unbedingt braucht? Allgemeines

7 Expliziter Zustand Simulation der zustandsbasierten Rechnung: Expliziten Zustand s einführen. Statt z = f x y; r = g z nun überall Zustand angeben, z.b. 1 (s,z) = f s x y 2 (s,u) = f s x y 3 (s,r) = g s z und ein Zustand s darf nie zweimal benutzt werden. Allgemeines Jedoch: Im normalen Haskell gibt es aber keine Hindernis, alle drei gleichzeitig zu benutzen

8 Erwünschte Zustände Wo wünscht man sich die imperative : Ein-und Ausgabe sind inhärent zustandsabhängig und müssen in ihrer Abfolge koordiniert werden Funktionen mit Nebenergebnis, das überall behandelt werden muss, möchten dies in einem Zustand verstecken. Beispiel: Rechnen mit dem Typ Int Dafür gibt es ein besonderes Konzept und eine spezielle Notation do-notation. Allgemeines

9 wie es nicht geht Erster Ansatz wäre vielleicht: 1 readcharfromkeyboard :: Char 2 readintfromkeyboard :: Int 3 4 stringtoscreen :: String - > Bool

10 wie es nicht geht Erster Ansatz wäre vielleicht: 1 readcharfromkeyboard :: Char 2 readintfromkeyboard :: Int 3 4 stringtoscreen :: String - > Bool Probleme dabei Auswertungsreihenfolge Verletzung der Referential Transparency von Funktionen

11 Auswertungsreihenfolge besonders bei Lazy-Evaluation

12 Auswertungsreihenfolge besonders bei Lazy-Evaluation Example f x = x + readintfromkeyboard - readintfromkeyboard

13 Auswertungsreihenfolge besonders bei Lazy-Evaluation Example f x = x + readintfromkeyboard - readintfromkeyboard printlist [] =? printlist ( x: xs) = stringtoscreen x...?... printlist xs main... =... printlist l

14 do-notation do-notation erlaubt Folge von Aktionen zu programmieren: Sie werden der Reihe nach ausgeführt können Werte berechnen und an Variable übergeben (aber nur einmal!) oder auch nur etwas ausführen Werte aus zuvor berechneten Variablen benutzen

15 Abstrakter Datentyp Ein- und Ausgabefunktionen sind Aktionen eines abstrakten Datentyps a werden importiert wie üblich: import System. Eingaben haben den Typ z.b. String oder Int Ausgabe-Aktionen liefern den Typ () Für die Verkettung von Aktionen gibt es eine besondere Notation Beispiel: do x <- getline; print (length x)

16 Verkettung von Aktionen 1 > do 2 x <- act1 3 act2 4 y <- act3 x 5 act4 x y 6 return (f x y) Ausführung der Aktionen 1-4 in der angegebenen Reihefolge, Erzeugung und Wiederverwendung von Zwischenergebnissen

17 -Beispiel: Ausgabe 1 putstr :: String - > () -- vordefiniert 2 3 putstrln :: String - > () 4 5 putstrln str = do putstr str 6 putstr \n 1 put4times str = do putstrln str 2 putstrln str 3 putstrln str 4 putstrln str

18 -Beispiel: Eingabe 1 getline :: String -- vordefiniert 2 getchar :: Char -- vordefiniert 3 4 read2lines :: () 5 read2lines = do getline 6 getline 7 putstrln " Two lines read 8 and used for nothing " Die Zeilen werden zwar von der Eingabe entnommen, aber dann nicht weiter verwendet...

19 -Beispiel: Eingabeverarbeitung und Ausgabe 1 reverse2lines :: () 2 reverse2lines = do line1 <- getline 3 line2 <- getline 4 putstrln ( reverse line2 ) 5 putstrln ( reverse line1 ) Die eingelesenen Strings werden an Namen gebunden und können so in anderen Funktionen verwendet werden

20 Weitere -Funktionen Weitere -Funktionen für Lesen und Schreiben von Dateien Kommunikation mit dem Betriebssystem...

21 -Funktionen 1 getchar :: Char 2 getline :: String 3 4 putchar :: Char -> () 5 putstr :: String - > () 6 putstrln :: String - > () 7 print :: Show a => a -> ()

22 -Funktionen 1 getchar :: Char 2 getline :: String 3 4 putchar :: Char -> () 5 putstr :: String - > () 6 putstrln :: String - > () 7 print :: Show a => a -> () Wiederholung () ist der Unit-Datentyp, der nur den Wert () enthält Die Typen der -Funktionen erklären, warum man sie in der do-notation (s.o.) gebrauchen kann

23 Main bei kompilierten Programmen per Standard wird bei einem kompilierten Programm die Funktion main in dem Module Main als Programmeinsprung verwendet: > module Main > where > main :: () Zugriff auf Kommandozeilenargumente: import System. Environment getargs :: [ String ] Exit-Status: data ExitCode = ExitSuccess ExitFailure Int deriving ( Eq, Ord, Read, Show ) exitwith :: ExitCode - > a

24 Main btw Falls ein Modul keine module-deklaration enthält, ist das äquivalent zu: 1 > module Main ( main ) 2 > where

25 Convenience--Funktionen 1 readfile :: FilePath - > String 2 writefile :: FilePath - > String - > () 3 appendfile :: FilePath - > String - > ()

26 Convenience--Funktionen 1 readfile :: FilePath - > String 2 writefile :: FilePath - > String - > () 3 appendfile :: FilePath - > String - > () Sonstige -Funktionen: 1 openfile :: FilePath - > Mode - > Handle 2...

27 Einfaches Beispiel Datei lesen, verarbeiten, schreiben in Hugs 1 > import System. 2 > import Data. Char 3 4 > gross :: String - > String 5 > gross t = map toupper t 6 7 > encode file = do 8 > inp <- readfile ( file ) 9 > writefile ( file ++". enc ") ( gross inp )

28 Stellenwert der do-notation Die do-notation ist überaus hilfreich für zustandsbasierte Programmierug, aber sie ist nur syntaktischer Zucker, also eine bequeme Schreibweise für Programme, die man auch ohne sie programmieren kann diese andere erklärt die do-notation in normalem Haskell, aber diese Erklärung der do-notation muss man nicht kennen, um sie zu benutzen... es sei denn, man will sie erweitern für den eigenen Bedarf

29 Imperativ funktional... Wie bringt man die Aktionen auf Zuständen in einer funktionalen Welt unter?

30 Imperativ funktional... Wie bringt man die Aktionen auf Zuständen in einer funktionalen Welt unter? Funktionsanwendung z = f x y oder z = (f $ x ) $ y ersetzen durch Operation, die besagt Wende f auf s, x, und y an und produziere s und z Wende f auf s, x, y und z an und produziere s und z und so weiter, ohne dass man die Folge s, s,... explizit hinschreiben muss.

31 sind eine mathematisches Struktur, wie Gruppe, Ring, Körper, usw. dort untersucht in der der Kategorientheorie Hier: eine Klasse von Daten mit Operationen auf diesen, die bestimmte Eigenschaften besitzen

32 sind eine mathematisches Struktur, wie Gruppe, Ring, Körper, usw. dort untersucht in der der Kategorientheorie Hier: eine Klasse von Daten mit Operationen auf diesen, die bestimmte Eigenschaften besitzen Grundidee: Statt Datentyp a verwendet man Typ M a Funktionsanwendung f a ersetzt durch a >>= f, direkte Anwendung f (M a) ist durch den Typ ausgeschlossen wobei >>= neben der Berechnung von f a weitere Geschäfte verrichten kann...

33 Besonderheit der sind nicht einfach zu verstehen, weil die Funktionsanwendung die grundlegendste Operation der funktionalen ist, genau diese jetzt durch etwas (fast) Beliebiges ersetzt wird, das in jeder Monade anders ist und was wir auch selbst definieren können für neue Konkrete sind Typen, die Instanz der Typklasse Monad sind

34 Funktionen auf In Haskell-Notation: 1 ( > >=) :: m a -> (a -> m b) -> m b 2 return :: a -> m a 3 4 (>>) :: m a -> m b -> m b 5 fail :: String - > m a a und b: beliebige Typen m a und m b: ihre Werte in Monade verpackt (>>=) und (>>) werden bind oder bindto ausgesprochen

35 funktionen 1 ( > >=) :: m a -> (a -> m b) -> m b 2 return :: a -> m a 3 4 (>>) :: m a -> m b -> m b 5 fail :: String - > m a Was leistet >>=? Entpackt a aus der Monade, wendet f darauf an, liefert verpacktes Ergebnis, das weiter verwendet werden kann in der Form x >>= f >>= g >>= h... Das Auspacken geschieht bei jeder Monade auf eigene Art und es kann auch direkt das Ergebnis erzeugen.

36 funktionen 1 ( > >=) :: m a -> (a -> m b) -> m b 2 return :: a -> m a 3 4 (>>) :: m a -> m b -> m b 5 fail :: String - > m a Was leistet return? Verpacken eines Werts a in der Monade, damit man mit >>= und >> darauf arbeiten kann

37 funktionen 1 ( > >=) :: m a -> (a -> m b) -> m b 2 return :: a -> m a 3 4 (>>) :: m a -> m b -> m b 5 fail :: String - > m a Was leistet >>? Machmal möchte man eine Konstante für eine Funktion einsetzen: 1 > count xs = sum ( map (\ x - >1) xs) x >> f setzt x voraus, um f zu berechnen, also werden Ketten von Operationen sequenzialisiert durch x >> f1 >> f2 >> f3...

38 funktionen 1 ( > >=) :: m a -> (a -> m b) -> m b 2 return :: a -> m a 3 4 (>>) :: m a -> m b -> m b 5 fail :: String - > m a Was leistet >>? Machmal möchte man eine Konstante für eine Funktion einsetzen: 1 > count xs = sum ( map (\ x - >1) xs) x >> f setzt x voraus, um f zu berechnen, also werden Ketten von Operationen sequenzialisiert durch x >> f1 >> f2 >> f3... Beispiel: Sukzessives Schreiben von Output

39 funktionen 1 ( > >=) :: m a -> (a -> m b) -> m b 2 return :: a -> m a 3 4 (>>) :: m a -> m b -> m b 5 fail :: String - > m a Was leistet fail? Erzeugen eines Fehler-Strings, mit dem die Rechnung abbricht

40 als Instanzen sind eine Typklasse: Monad ihr gehören alle Typen an, auf denen man die funktionen definiert hat Monad ist vordefiniert, vergleichbar anderen Typklassen wie Show, Eq, Ord, Num jeder konkrete Typ kann zur Instanz der Typklasse gemacht werden

41 Typklasse Monad Vordefinierte Typklasse: (Achtung: m ist eine Variable für einen einstelligen Typ-Konstruktor!) 1 infixl 1 > >=, >> 2 class Monad m where 3 ( > >=) :: m a -> (a -> m b) -> m b 4 return :: a -> m a 5 6 (>>) :: m a -> m b -> m b 7 fail :: String - > m a

42 Typklasse Monad Vordefinierte Typklasse: (Achtung: m ist eine Variable für einen einstelligen Typ-Konstruktor!) 1 infixl 1 > >=, >> 2 class Monad m where 3 ( > >=) :: m a -> (a -> m b) -> m b 4 return :: a -> m a 5 6 (>>) :: m a -> m b -> m b 7 fail :: String - > m a 6 7 m >> k = m >>= \_ -> k -- default 8 fail s = error s -- default

43 Monad-Laws 1 return gibt nur sein Argument zurück und führt keine weiteren Berechnungen durch: m >>= return = m return x >>= f = f x 2 >>= ist assoziativ: (m >>= f) >>= g = m >>= (\x -> (f x >>= g)) analog zur Komposition von Funktionen (m. f ). g = m. (f. g)

44 Monad-Laws 1 return gibt nur sein Argument zurück und führt keine weiteren Berechnungen durch: m >>= return = m return x >>= f = f x 2 >>= ist assoziativ: (m >>= f) >>= g = m >>= (\x -> (f x >>= g)) analog zur Komposition von Funktionen (m. f ). g = m. (f. g) Analog muss (>>) assoziativ sein: (a >> b) >> c = a >> (b >> c) fail muss die Berechnung abbrechen NB: Diese Eigenschaften werden von -Instanzen gefordert, können aber vom Compiler nicht überprüft werden!

45 Beispiel: Monad 1 data a = Just a 2 Nothing 3 4 deriving ( Show, Eq)

46 Beispiel: Monad 1 data a = Just a 2 Nothing 3 4 deriving ( Show, Eq) 5 6 instance Monad where 7 ( Just x) >>= k = k x 8 Nothing > >= k = Nothing 9 return x = Just x

47 Beispiel: Monad 1 data a = Just a 2 Nothing 3 4 deriving ( Show, Eq) 5 6 instance Monad where 7 ( Just x) >>= k = k x 8 Nothing > >= k = Nothing 9 return x = Just x Beispiele: Just 1 >>= \x -> Just 2 >>= \y -> return (x+y) ( ) Just 1 >>= \x -> Nothing >>= \y -> return (x+y) ( )

48 Notation...? Im wesentlichen hat man einen monadischen Wert m darauf angewandte Ketten von >>= und >> Operationen Das ist einfach, sieht aber nicht besonders übersichtlich aus...

49 (Do-Expression) Syntaktischer Zucker, um >>= Ketten schöner hinschreiben zu können.

50 (Do-Expression) Syntaktischer Zucker, um >>= Ketten schöner hinschreiben zu können. m > >= f = do { x <- m; f x }

51 (Do-Expression) Syntaktischer Zucker, um >>= Ketten schöner hinschreiben zu können. m > >= f = do { x <- m; f x } bzw. m >>= f = do x <- m f x

52 (Do-Expression) Syntaktischer Zucker, um >>= Ketten schöner hinschreiben zu können. m > >= f = do { x <- m; f x } bzw. m >>= f = do x <- m und m1 >> m2 = do f x <- m1 <- m2

53 (Do-Expression) Syntaktischer Zucker, um >>= Ketten schöner hinschreiben zu können. m > >= f = do { x <- m; f x } bzw. m >>= f = do x <- m und m1 >> m2 = do _ f x _ bzw. m1 >> m2 = do m1 m2 <- m1 <- m2

54 Allgemeines Übersetzungsschema: 1 m1 >>= \ x_1 -> m_2 >>= \ x_2 -> m_n >>= \ x_n -> return = do 5 x_1 <- m_1 6 x_2 <- m_2 7 x_3 <- m_ x_n <- m_n 10 return...

55 Beobachtungen >>= (bind-operator) gibt eine Reihenfolge vor Schachtelung ist beliebig (Assoziativität)

56 -Beispiel 1 do 2 x <- Just 1 3 y <- Just 2 4 return (x+y)

57 -Beispiel 1 do 2 x <- Just 1 3 y <- Just 2 4 return (x+y) Zum Ausprobieren in Hugs: do {x<- Just 1; y <- Just 2; return (x+y)} 2 Just 3 == do { x <- Just 1; y <- Just 2; return ( x + y)}

58 -Beispiel 1 do 2 x <- Just 1 3 y <- Just 2 4 return (x+y) Zum Ausprobieren in Hugs: do {x<- Just 1; y <- Just 2; return (x+y)} 2 Just 3 == do { x <- Just 1; y <- Just 2; return ( x + y)} 5 6 do 7 x <- Just 1 8 y <- Nothing 9 return (x+y)

59 -Beispiel 1 f dict = do 2 x <- lookup " alpha " dict 3 y <- lookup " beta " dict 4 z <- lookup " gamma " dict 5 return (x + y + z) 6 lookup :: String - > Dict - > Int

60 -Beispiel 1 f dict = do 2 x <- lookup " alpha " dict 3 y <- lookup " beta " dict 4 z <- lookup " gamma " dict 5 return (x + y + z) 6 lookup :: String - > Dict - > Int statt sowas wie: 6 f dict = if isjust x && isjust y && isjust z 7 then Just ( fromjust x + fromjust y + fr 8 else Nothing 9 where 10 x = lookup " alpha " dict 11 y = lookup " beta " dict 12 z = lookup " gamma " dict

61 Monad-Laws in do-notation 1 do { x <- m ; return x } = m 2 do { y <- return x ; f y } = f x 3 Assoziativität von >>=: do { y <- do { x <- m; f x} ; g y } = do { x <- m; do { y <- f x ; g y } } = do { x <- m; y <- f x; g y}

62 let-deklaration Weiterer syntaktischer Zucker statt 1 let a = 42 2 in do 3 print a kann man auch schreiben: 1 do 2 let a = 42 3 print a

63 -Beispiel 1 -- data [a] = a : [a] 2 -- [] 3 4 instance Monad [] where 5 ( > >=) l f = concat ( map f l) 6 return x = [x]

64 -Beispiel mit selbstdefinierten Datentyp 1 data List a = Cons a ( List a) 2 Nil 3 4 instance Monad List where 5 ( > >=) l f = concatlist ( maplist f l) 6 return x = [x]

65 -Beispiel 1 -- data [a] = a : [a] 2 -- [] 3 4 instance Monad [] where 5 ( > >=) l f = concat ( map f l) 6 return x = [x]

66 -Beispiel 1 -- data [a] = a : [a] 2 -- [] 3 4 instance Monad [] where 5 ( > >=) l f = concat ( map f l) 6 return x = [x] do x <- [1,2] y <- [3,4] return (x * y)

67 -Beispiel 1 -- data [a] = a : [a] 2 -- [] 3 4 instance Monad [] where 5 ( > >=) l f = concat ( map f l) 6 return x = [x] do x <- [1,2] y <- [3,4] return (x * y) => [3,4,6,8]

68 -Beispiel 1 -- data [a] = a : [a] 2 -- [] 3 4 instance Monad [] where 5 ( > >=) l f = concat ( map f l) 6 return x = [x] do x <- [1,2] y <- [3,4] return (x * y) => [3,4,6,8] Analog zu folgender beschreibung: [ x * y x <- [1,2], y <- [3,4] ]

69 Beobachtungen zur do-notation sieht sehr imperativ aus Zuweisungen zu Variablen aber nur in Single-Assignment (SA) Form

70 Zurück zum mit der Monade als einstelliger Typkonstruktor als ADT importieren mit import System. Ausgabe mit Typ () Eingabe mit Typ String, Int, etc

71 Zurück zum mit der Monade als einstelliger Typkonstruktor als ADT importieren mit import System. Ausgabe mit Typ () Eingabe mit Typ String, Int, etc eigenschaft definiert die Reihenfolge -Fehler durch error

72 -Monad Beobachtungen Referential-Transparency?

73 -Monad Beobachtungen Referential-Transparency? ja nur sind die Werte von a verborgen (ADT-Eigenschaft) wie kommt der eigene Code z.b. an den Char-Wert bei String?

74 -Monad Beobachtungen Referential-Transparency? ja nur sind die Werte von a verborgen (ADT-Eigenschaft) wie kommt der eigene Code z.b. an den Char-Wert bei String? durch die Definition von >>=

75 -Monad Beobachtungen Referential-Transparency? ja nur sind die Werte von a verborgen (ADT-Eigenschaft) wie kommt der eigene Code z.b. an den Char-Wert bei String? durch die Definition von >>= eindeutige Sequenzierung der -Funktionen durch eigenschaft

76 Anwendungsgebiete Wichtigste Anwendung der Input / Output Fehlerbehandlung zustandbasierte Programme destructive updates (!!) Pssst: Verpackung des Zustands in einer Monade erlaubt dem Compiler speichereffiziente Implementierung durch destruktive Updates.