College I/O

Transcriptie

1 College I/O Doaitse Swierstra Verteld door Jurriaan Hage Utrecht University

2 Input en Output Tot dusverre: een module bevat een aantal functiedefinities GHCi drukt de waarde af van een ingetikte expressie 2

3 Input en Output Tot dusverre: een module bevat een aantal functiedefinities GHCi drukt de waarde af van een ingetikte expressie We willen ook echte programa s schrijven, zoals: Galaxy Life, Minecraft en Habbo Hotel Haskell compilers Programmeeromgevingen Webservers, Wiki s... 2

4 Wat is het probleem? Haskell s belangrijkste eigenschap is referential transparency, d.w.z. dat elke variabele door zijn definiërende expressie vervangen kan worden en omgekeerd dat aan elke deelexpressie een naam gegeven kan worden zonder dat dat de betekenis van het programma verandert: 3

5 Wat is het probleem? Haskell s belangrijkste eigenschap is referential transparency, d.w.z. dat elke variabele door zijn definiërende expressie vervangen kan worden en omgekeerd dat aan elke deelexpressie een naam gegeven kan worden zonder dat dat de betekenis van het programma verandert: Dus let x = <expr > in... x... x... is dus altijd equivalent met:... < expr >... <expr >... 3

6 Wat is het probleem? Haskell s belangrijkste eigenschap is referential transparency, d.w.z. dat elke variabele door zijn definiërende expressie vervangen kan worden en omgekeerd dat aan elke deelexpressie een naam gegeven kan worden zonder dat dat de betekenis van het programma verandert: Dus let x = <expr > in... x... x... is dus altijd equivalent met:... < expr >... <expr >... En ook: (\ x <expr1>) < expr2 > is per definitie equivalent met: 3 let x = <expr2 > in < expr1 >

7 Wat is dan het voordeel? volgorde van evaluatie blijkt dan niet meer van belang, omdat evaluatie van een expressie geen effect kan hebben op een andere de compiler kan dan zijn eigen volgorde kiezen lazy evaluation is zonder referential transparency praktisch onmogelijk parallelliseren wordt ook gemakkelijker: waar of wanneer een expressie dan ook uitgerekend wordt er komt altijd hetzelfde uit En λ s zijn daar ook heel handig voor: Java Maar...we kunnen niet helemaal zonder 4

8 Side-effects Stel er bestaat een functie random, dan zouden let x = random in x == x en random == random dus ook dezelfde betekenis moeten hebben. 5

9 Side-effects Stel er bestaat een functie random, dan zouden en let x = random in x == x random == random dus ook dezelfde betekenis moeten hebben.en dan voldoet de functie niet aan zijn specificatie. Deze functie bestaat dus niet! 5

10 Neveneffecten Iets soortgelijks gebeurt als we karakter inlezen met bijv. een functie getchar: en let x = getchar in x == x getchar == getchar zouden ook weer hetzelfde moeten zijn, en ook dat is weer moeilijk in te zien. 6

11 Hoe zit dan met deze paradox? Eigenlijk is hier sprake van een extra verborgen argument het filesysteem het toetsenbord de door de random functie al gegenereerde waarden Die bepalen mede de komende toestand en de uitvoer van functies De wereld om ons heen is het impliciete argument dat ervoor zorgt dat dezelfde aanroep verschillende gevolgen heeft Monads zorgen ervoor dat deze wereld impliciet is, en daarom ook niet dupliceerbaar 7

12 We modelleren eerst output We modelleren output door een berekening een resultaat op te laten leveren van type String. We maken dit expliciet d.m.v. een type declaratie: type Output = String 8

13 We modelleren eerst output We modelleren output door een berekening een resultaat op te laten leveren van type String. We maken dit expliciet d.m.v. een type declaratie: type Output = String Functies die een output actie representeren doen dit door de tot dusverre opgebouwde output te veranderen, en dus definiëren we: type O = Output > Output 8

14 We modelleren eerst output We modelleren output door een berekening een resultaat op te laten leveren van type String. We maken dit expliciet d.m.v. een type declaratie: type Output = String Functies die een output actie representeren doen dit door de tot dusverre opgebouwde output te veranderen, en dus definiëren we: type O = Output > Output De functie putchar krijgt verder de Char waarde die afgedrukt moet worden als parameter: 8 putchar :: Char > O putchar c output = output ++ [c]

15 Het combineren van twee output commando s Stel nu dat we de string "ab" aan de output willen toevoegen, gebruik makend van putchar a en putchar b. Hoe stellen we deze commandos dan samen?... putchar a... putchar b... 9

16 Het combineren van twee output commando s Stel nu dat we de string "ab" aan de output willen toevoegen, gebruik makend van putchar a en putchar b. Hoe stellen we deze commandos dan samen?... putchar a... putchar b... Een eerste poging: putab output = putchar b (putchar a output) of zelfs: putab = putchar b. putchar a 9

17 Het combineren van twee output commando s Stel nu dat we de string "ab" aan de output willen toevoegen, gebruik makend van putchar a en putchar b. Hoe stellen we deze commandos dan samen?... putchar a... putchar b... Een eerste poging: putab output = putchar b (putchar a output) of zelfs: putab = putchar b. putchar a Maar deze volgorde van schrijven in niet erg intuïtief. 9

18 Een natuurlijkere schrijfwijze We gaan nu monad-notatie inzetten voor het stroomlijnen van I/O code. type O = Output > Output (>>) :: O > O > O (>>) p q output = q (p output) -- Als je dat liever hebt: (>>) = flip (.) flip f x y = f y x Nu kunnen we schrijven: putab = putchar a >> putchar b 10

19 Een natuurlijkere schrijfwijze We gaan nu monad-notatie inzetten voor het stroomlijnen van I/O code. type O = Output > Output (>>) :: O > O > O (>>) p q output = q (p output) -- Als je dat liever hebt: (>>) = flip (.) flip f x y = f y x Nu kunnen we schrijven: putab = putchar a >> putchar b 10 Een ; zou een goed alternatief voor >> zijn geweest, maar die is al bezet.

20 Voorbeeldje Met deze operator is het nu makkelijk een hele string af te drukken: putstr "" = id putstr (s : ss) = putchar s >> putstr ss 11

21 Over naar input Als we een Char van de input lezen krijgen we eigenlijk twee resultaten: 1. het element op kop van de huidige input 2. het overblijvende stuk van de input, waar we later verder van kunnen lezen: 12

22 Over naar input Als we een Char van de input lezen krijgen we eigenlijk twee resultaten: 1. het element op kop van de huidige input 2. het overblijvende stuk van de input, waar we later verder van kunnen lezen: Dus definiëren we: type Input = String type I a = Input > (a, Input) -- een paar van waarden getchar :: I Char getchar (x : xs) = (x, xs) 12

23 Over naar input Als we een Char van de input lezen krijgen we eigenlijk twee resultaten: 1. het element op kop van de huidige input 2. het overblijvende stuk van de input, waar we later verder van kunnen lezen: Dus definiëren we: type Input = String type I a = Input > (a, Input) -- een paar van waarden getchar :: I Char getchar (x : xs) = (x, xs) 12 Maar deze kunnen we niet samenstellen zoals putchar; wat te doen met de waarde die we net ingelezen hebben?

24 De bind operator: >>= We besluiten deze waarde door te geven als argument aan de rest van de berekening ; deze rest representeren we dus als een functie: (>>=) :: I b > (b > I a) > I a (p >>= q) input = let (v, input ) = p input in (q v) input De waarde v selecteert de volgende input operatie. 13

25 getline Gebruikmakend van >>= en getchar kunnen we een regel inlezen die eindigt met een newline karakter: getline :: I String getline = getchar >>= (\ c if c == \n then (\ inp ("", inp)) else getline >>= (\ cs inp (c : cs, inp)) ) 14

26 Combineren van I en O Stel we willen nu een functie echo schrijven die een karakter inleest en weer afdrukt, gebruik makend van putchar en getchar. echo = getchar >>= (\ c putchar c) Of zelfs korter: echo = getchar >>= putchar 15

27 IO In de toestand die we nu willen bijhouden zit zowel de nog te lezen Input als de al geproduceerde Output. type World = (Input, Output) -- de twee stromen karakters type IO a = World > (a, World) putchar :: Char > IO () putchar o (ii, oo) = ((), (ii, oo ++ [o])) getchar :: IO Char getchar ((i : ii), oo) = (i, (ii, oo )) 16

28 IO In de toestand die we nu willen bijhouden zit zowel de nog te lezen Input als de al geproduceerde Output. type World = (Input, Output) -- de twee stromen karakters type IO a = World > (a, World) putchar :: Char > IO () putchar o (ii, oo) = ((), (ii, oo ++ [o])) getchar :: IO Char getchar ((i : ii), oo) = (i, (ii, oo )) echo :: IO () echo = getchar >>= putchar 16

29 >>= en >> veranderen mee type World = (Input, Output) -- de twee stromen karakters type IO a = World > (a, World) (>>=) :: IO b > (b > IO a) > IO a (iob >>= b2ioa) w = let (bval, w ) = iob w in b2ioa bval w (>>) :: IO b > IO a > IO a Aan het type van (>>) kun je zien dat deze sterk op (>>=) lijkt, maar het resultaat van de eerste berekening alleen niet doorgeeft. Dit kan als de tweede operatie het resultaat van de eerste niet nodig heeft. 17

30 De function main De Haskell main functie heeft type World > World, en je kan bij de aanroep van de functie main door het systeem denken aan iets als: run :: IO () > Input > Output run main input = main (input, "") >>= (\ () state > snd state) We beginnen met de lege output "" en als we klaar zijn leveren we het output gedeelte van de state op. 18

31 putchar Vergelijk: Prelude> a a Prelude> :t putchar putchar :: Char -> IO () Prelude> putchar a a 19

32 putchar Vergelijk: Prelude> a a Prelude> :t putchar putchar :: Char -> IO () Prelude> putchar a a Als we een expressie intikken in GHCi dan wordt er gekozen: 1. als het type van de expressie geen IO.. is: converteer het resultaat naar een String en druk die af 19

33 putchar Vergelijk: Prelude> a a Prelude> :t putchar putchar :: Char -> IO () Prelude> putchar a a Als we een expressie intikken in GHCi dan wordt er gekozen: 1. als het type van de expressie geen IO.. is: converteer het resultaat naar een String en druk die af 2. het type is IO (): voer de rij IO-acties uit (een imperatief programma) 19

34 De do-notatie maakt het weer leesbaarder Om de volgorde waarin de IO acties worden uitgevoerd helder in het programma naar voren te laten komen gebruiken we weer de do-notatie: zeggedag :: IO () zeggedag = do putchar H putchar i zeggedag = putchar H >> putchar i 20

35 De do-notatie maakt het weer leesbaarder Om de volgorde waarin de IO acties worden uitgevoerd helder in het programma naar voren te laten komen gebruiken we weer de do-notatie: zeggedag :: IO () zeggedag = do putchar H putchar i zeggedag = putchar H >> putchar i Indentatie doet er weer toe! 20

36 Recursieve acties De meeste functies die een lijst gebruiken zijn recursief: putstr :: String > IO () putstr (x : xs) = do putchar x putstr xs 21

37 Recursieve acties putstr :: String > IO () putstr (x : xs) = do putchar x putstr xs putstr [ ] = return () Hier staat return () voor een lege lijst van IO-acties. return :: a > IO a 21

38 Vervangen van >>= door do-notatie We kunnen in do-notatie ook een naam geven aan het resultaat van een actie: echo :: IO () echo = do x < getchar putchar x 22

39 Vervangen van >>= door do-notatie We kunnen in do-notatie ook een naam geven aan het resultaat van een actie: echo :: IO () echo = do x < getchar putchar x Test> :t getchar getchar :: IO Char Test> echo a a Test> 22

40 ... Wat zou het resultaat van het volgende programma zijn? sayhi :: IO () sayhi = do putchar H return "does nothing" putchar i 23

41 ... Wat zou het resultaat van het volgende programma zijn? sayhi :: IO () sayhi = do putchar H return "does nothing" putchar i Test> sayhi Hi Test> 23

42 ... Wat zou het resultaat van het volgende programma zijn? sayhi :: IO () sayhi = do putchar H return "does nothing" putchar i Test> sayhi Hi Test> Dus return krijgt hier een argument, dat teruggegeven wordt en vervolgens wordt weggegooid. 23

43 Iets explicieter sayhi :: IO () sayhi = do < putchar H < return "does nothing" putchar i 24

44 Iets explicieter sayhi :: IO () sayhi = do < putchar H < return "does nothing" putchar i De return aanroep levert weliswaar een waarde op, maar die krijgt geen naam, en is verderop dus niet beschikbaar. 24

45 Vergelijk dit met... sayhi :: IO () sayhi = do putchar H text < return ", FP students" putchar i putstr text 25

46 Vergelijk dit met... sayhi :: IO () sayhi = do putchar H text < return ", FP students" putchar i putstr text Test> sayhi Hi, FP students Test> 25

47 Enigszins ontsuikerd is dat... sayhi :: IO () sayhi = do < putchar H text < return ", FP students" < putchar i < putstr text 26

48 IO waarden zijn gewoon waarden! printlater = do < putchar H pr text < return (putstr ", FP students") < putchar i pr text 27

49 IO waarden zijn gewoon waarden! printlater = do < putchar H pr text < return (putstr ", FP students") < putchar i pr text De types zijn: return :: a > IO a 27

50 IO waarden zijn gewoon waarden! printlater = do < putchar H pr text < return (putstr ", FP students") < putchar i pr text De types zijn: return :: a > IO a putstr ", FP students" :: IO () 27

51 IO waarden zijn gewoon waarden! printlater = do < putchar H pr text < return (putstr ", FP students") < putchar i pr text De types zijn: return :: a > IO a putstr ", FP students" :: IO () return (putstr ", FP students") :: IO (IO ()) 27

52 IO waarden zijn gewoon waarden! printlater = do < putchar H pr text < return (putstr ", FP students") < putchar i pr text De types zijn: return :: a > IO a putstr ", FP students" :: IO () return (putstr ", FP students") :: IO (IO ()) pr text :: IO () 27

53 getline De functie getline :: IO String leest een regel: greeting :: IO () greeting = do putstr "What is your name? " name < getline putstrln ("Hello, " ++ name) 28

54 getline De functie getline :: IO String leest een regel: greeting :: IO () greeting = do putstr "What is your name? " name < getline putstrln ("Hello, " ++ name) Test> greeting What is your name? Doaitse Hello, Doaitse De functie putstrln zet een extra \n aan het eind. 28

55 Eenvoudige IO uit de Prelude (1) print :: Show a => a > IO () print e = putstrln (show e) -- of print = putstrln. show getline :: IO String getline = do x < getchar if c == \n then return "" else do xs < getline return (x : xs) 29

56 Eenvoudige IO uit de Prelude (1) print :: Show a => a > IO () print e = putstrln (show e) -- of print = putstrln. show getline :: IO String getline = do x < getchar if c == \n then return "" else do xs < getline return (x : xs) Merk op dat beide takken van de if... then... else... type IO... hebben. Vergelijk deze getline eens met de eerdere versie: de input buffer is verborgen in de monad. 29

57 Eenvoudige IO uit de Prelude (2) De basis IO acties return :: a > IO a putchar :: Char > IO () putstr :: String > IO () putstrln :: String > IO () print :: Show a => a > IO () getline :: IO String writefile :: FilePath > String > IO () readfile :: FilePath > IO String 30

58 Nog even over types Als monads een mode representeren waarin je evalueert. Dan representeert IO Int een berekening die I/O kan doen en uiteindelijk een Int oplevert (bv. de grootte van een bestand). Maar niet alle I/O operaties die je hiervoor doet hoeven van type IO Int te zijn: je kunt een file openen, IO () karakters uitlezen IO Char en nog veel meer Het type geeft dus aan wat je uiteindelijk oplevert in welke mode de gehele functie opereerde Die eerste kan variëren, de tweede is constant 31

59 Nieuwe control structures Omdat iets van type IO... een waarde heeft, kunnen we ze dus opleveren als resultaat van een functie, of als parameter meegeven: sequence sequence :: [IO a] > IO [a] 32

60 Nieuwe control structures Omdat iets van type IO... een waarde heeft, kunnen we ze dus opleveren als resultaat van een functie, of als parameter meegeven: sequence sequence :: [IO a] > IO [a] sequence [ ] = return [ ] sequence (s : ss) = do x < s xs < sequence ss return (x : xs) 32

61 Nieuwe control structures Omdat iets van type IO... een waarde heeft, kunnen we ze dus opleveren als resultaat van een functie, of als parameter meegeven: sequence sequence :: [IO a] > IO [a] sequence [ ] = return [ ] sequence (s : ss) = do x < s xs < sequence ss return (x : xs) 32 De functie sequence krijgt een lijst van commando s, voert deze uit, en levert de lijst van corresponderende resultaten op.

62 sequence sequence sequence :: [IO a] > IO () sequence [ ] = return () sequence (s : ss) = do s sequence ss 33

63 sequence sequence sequence :: [IO a] > IO () sequence [ ] = return () sequence (s : ss) = do s sequence ss En nu: putstr str = sequence (map putchar str) 33

64 sequence sequence sequence :: [IO a] > IO () sequence [ ] = return () sequence (s : ss) = do s sequence ss En nu: putstr str = sequence (map putchar str) Of korter: putstr = sequence. map putchar 33

65 Een Real World Program We schijven een number guessing programma: "Pick a number between 1 and 100. Is it 50? (g = greater, l = less, c = correct) g Is it 75? (g = greater, l = less, c = correct) l Is it 62? (g = greater, l = less, c = correct) g Is it 68? (g = greater, l = less, c = correct) l Is it 65? (g = greater, l = less, c = correct) c Guessed 34

66 Het hoofdprogramma main main :: IO () main = do putstrln "Pick a number between 1 and 100" guess

67 De functie guess guess :: Int > Int > IO () guess lower upper = let mid = (upper + lower) div 2 in do putstr ("Is it " ++ showint mid ++ "? ") putstrln "(g = greater, l = less, c = correct)" (v: ) < getline case v of g guess (mid + 1) upper l guess lower (mid 1) c putstrln "Guessed" do putstrln "Please type (g/l/c)!" guess lower upper 36

68 Samenvatting IO het type IO a representeert een rij neveneffecten 37

69 Samenvatting IO het type IO a representeert een rij neveneffecten gebruik makend van een do constructie kunnen we dergelijke commando s samenstellen; een sequentiële bewerkstelliging van deze side-effects 37

70 Samenvatting IO het type IO a representeert een rij neveneffecten gebruik makend van een do constructie kunnen we dergelijke commando s samenstellen; een sequentiële bewerkstelliging van deze side-effects met de x < expr constructie kunnen we het opgeleverde resultaat beschikbaar maken in de rest van het programma main heeft type IO () 37

71 Veel voorkomende structuren in een Haskell programma De functie main heeft type IO () 38

72 Veel voorkomende structuren in een Haskell programma De functie main heeft type IO () Op top-niveau hebben we te maken met de executie van een rij commandos (IO.. waarden) die de control aan elkaar doorgeven. Dit is gepresenteerd door het onder water doorgeven van de World, waarvan er maar één is. 38

73 Veel voorkomende structuren in een Haskell programma De functie main heeft type IO () Op top-niveau hebben we te maken met de executie van een rij commandos (IO.. waarden) die de control aan elkaar doorgeven. Dit is gepresenteerd door het onder water doorgeven van de World, waarvan er maar één is. Dit doorgeven van het stokje maakt dat de input/output actions sequentieel worden afgehandeld. 38

74 Voorbeeldprobleem Schijf een functie posequestions: posequestions :: [String] > IO [Bool] die een lijst vragen meekrijgt, die vragen stelt, een yes/no antwoord accepteerd, and tenslotte de verzamelde antwoorden afdrukt: 39

75 Voorbeeldprobleem Schijf een functie posequestions: posequestions :: [String] > IO [Bool] 39 die een lijst vragen meekrijgt, die vragen stelt, een yes/no antwoord accepteerd, and tenslotte de verzamelde antwoorden afdrukt: Test> posequestion Is it Sunday? (y) of (n)? n Is your name Doaitse? (y) of (n)? y [False,True] Test> ["Is it Sunday?", "Is your name Doaitse?"]

76 Oplossing posequestions :: [String] > IO [Bool] Let the types do the work 40

77 Oplossing posequestions :: [String] > IO [Bool] Let the types do the work posequestions qs = sequence (map posequestion qs) 40

78 Oplossing posequestions :: [String] > IO [Bool] Let the types do the work posequestions qs = sequence (map posequestion qs) posequestion q = do putstrln q putstrln "(y) of (n)?" (v: ) < getline if v == y then return True else if v == n then return False else posequestion q 40

79 Oplossing posequestions :: [String] > IO [Bool] Let the types do the work posequestions qs = sequence (map posequestion qs) posequestion q = do putstrln q putstrln "(y) of (n)?" (v: ) < getline if v == y then return True else if v == n then return False else posequestion q 40 demo qs = do answers < posequestions qs print answers

80 Nogmaals getline We lezen een karakter, gaan in de recusie, en bouwen een resultaat: getline1 = do x < getchar if x == \n then return [ ] else do xs < getline1 return (x : xs) 41

81 Nogmaals getline De meeste mensen hebben de drang het resultaat al te bouwen tijdens het inlezen; daar is de accumulerende parameter weer: getline2 = getline2 [ ] where getline2 r = do x < getchar if x == \n then return r else getline2 (r ++ [x]) 41

82 Nogmaals getline getline3 = getline3 [ ] where getline3 r = do x < getchar if x == \n then return (reverse r) else getline3 (x : r) 41

83 Tot besluit Als je kunt omgaan met file I/O dan ook met globale muteerbare variabelen (MVars) de random functie Hoe kom je van de monad af? Operaties in de IO monad vind je vooral toplevel, want als je I/O functies gebruikt, doe je zelf ook I/O. Maar je kunt eruit ontsnappen met unsafeperformio unsafe in de naam suggereert: use with extreme caution, not during this course 42