College Notatie, Recursie, Lijsten

Transcriptie

1 College Notatie, Recursie, Lijsten Doaitse Swierstra (Jeroen Bransen) Utrecht University September 13, 2016

2 Functieapplicatie functieapplicatie associeert naar links: als x in f x y moet kiezen bij wie hij hoort, kiest hij voor f : lees dus als (f x) y 2

3 Functieapplicatie functieapplicatie associeert naar links: als x in f x y moet kiezen bij wie hij hoort, kiest hij voor f : lees dus als (f x) y eigenlijk neemt elke functie precies één argument en levert dan eventueel een functie die het volgende argument neemt, etc. functieapplicatie bindt sterker dan alle operatoren Dat scheelt in de haakjes 2

4 Functieapplicatie functieapplicatie associeert naar links: als x in f x y moet kiezen bij wie hij hoort, kiest hij voor f : lees dus als (f x) y eigenlijk neemt elke functie precies één argument en levert dan eventueel een functie die het volgende argument neemt, etc. functieapplicatie bindt sterker dan alle operatoren Voorbeeld: Dat scheelt in de haakjes f x y z 1 + g 4 <=> (((f x) y) z) 1 + (g 4) 2

5 Patronen Je kunt een functie definiëren met verschillende patronen als formele parameter: som [ ] = 0 som [x] = x som [x, y] = x + y som [x, y, z] = x + y + z 3

6 Patronen Je kunt een functie definiëren met verschillende patronen als formele parameter: som [ ] = 0 som [x] = x som [x, y] = x + y som [x, y, z] = x + y + z Bij aanroep van de functie kijkt de interpreter of de parameter past op een van de definities; de aanroep som [3, 4] past bijvoorbeeld op de derde regel van de definitie (en op geen andere). 3

7 Patronen Je kunt een functie definiëren met verschillende patronen als formele parameter: som [ ] = 0 som [x] = x som [x, y] = x + y som [x, y, z] = x + y + z Bij aanroep van de functie kijkt de interpreter of de parameter past op een van de definities; de aanroep som [3, 4] past bijvoorbeeld op de derde regel Let op: van als de definitie het argument (en opeen geen lijst is andere). met meer dan 3 elementen gaat dit niet goed! 3

8 Syntax Diagram (ter referentie!) 4

9 Soorten van patronen O.a. de volgende constructies zijn toegestaan als patroon: Getallen (bijvoorbeeld 3) De constanten, zoals True en False; Namen (bijvoorbeeld x); Lijsten, waarvan de elementen ook weer patronen zijn (bijvoorbeeld [1, x, y]); De operator : met patronen links en rechts (bijvoorbeeld (x : y));... 5

10 Voorbeelden uit de Prelude Met behulp van patronen zijn een aantal belangrijke functies te definiëren: True && True = True && = False 6

11 Voorbeelden uit de Prelude Met behulp van patronen zijn een aantal belangrijke functies te definiëren: True && True = True && = False Met de operator : kunnen lijsten worden opgebouwd. Hiermee kunnen twee nuttige standaardfuncties geschreven worden: head (x : y) = x tail (x : y) = y Werken geen van beide voor lege lijsten! 6

12 Over pure talen, en iteratie Pure talen (zonder zijeffecten, waaronder ook assignments als x = x + 1) zijn eenvoudiger om over te redeneren, en te parallelliseren Maar hoe schrijf je dan iteratieve algoritmen? Met functies als map De voorvader van de bekendere foreach Maar map voldoet niet voor alle gevallen, en hoe definiëren we map zelf? Met recursie! 7

13 Faculteit met expliciete recursie Recursieve definities van de faculteit-functie zijn: fac n n == 0 = 1 n > 0 = n fac (n 1) 8

14 Faculteit met expliciete recursie Recursieve definities van de faculteit-functie zijn: fac n n == 0 = 1 n > 0 = n fac (n 1) fac 0 = 1 fac n = n fac (n 1) 8

15 Recursie, en daar gaat het om... Recursieve functies (d.w.z. functies die zichzelf aanroepen) zijn normaalgesproken alleen zinvol onder de volgende twee voorwaarden: de parameter van de recursieve aanroep is eenvoudiger (bijvoorbeeld: numeriek kleiner, of een kortere lijst) dan de parameter van de te definiëren functie; voor een basis-geval is er een niet-recursieve definitie. 9

16 Recursie, en daar gaat het om... Recursieve functies (d.w.z. functies die zichzelf aanroepen) zijn normaalgesproken alleen zinvol onder de volgende twee voorwaarden: de parameter van de recursieve aanroep is eenvoudiger (bijvoorbeeld: numeriek kleiner, of een kortere lijst) dan de parameter van de te definiëren functie; voor een basis-geval is er een niet-recursieve definitie. Terug naar het voorbeeld: fac 0 = 1 fac n = n fac (n 1) 9

17 Recursie gaat goed met lijsten samen.. Vrijwel alle functies op lijsten hebben het volgende patroon: som :: [Int] > Int som [ ] = 0 som (kop : staart) = kop + som staart 10

18 Recursie gaat goed met lijsten samen.. Vrijwel alle functies op lijsten hebben het volgende patroon: som :: [Int] > Int som [ ] = 0 som (kop : staart) = kop + som staart Tip: als je zelf zo n functie schrijft, begin dan altijd met het lege geval, controleer het type, en kijk of dat je aanstaat. 10

19 Niet alle recursie gaat goed... De volgende functie is niet erg zinvol: f x = f x 11

20 Niet alle recursie gaat goed... De volgende functie is niet erg zinvol: f x = f x Gaat zoiets altijd fout? 11

21 Niet alle recursie gaat goed... De volgende functie is niet erg zinvol: f x = f x Gaat zoiets altijd fout? Belangrijk in geval van zo n identieke aanroep is dat een functie productief is, d.w.z. dat er iets geproduceerd is voordat er dieper in een expressie een recursieve aanroep plaatsvindt: 11

22 Niet alle recursie gaat goed... De volgende functie is niet erg zinvol: f x = f x Gaat zoiets altijd fout? Belangrijk in geval van zo n identieke aanroep is dat een functie productief is, d.w.z. dat er iets geproduceerd is voordat er dieper in een expressie een recursieve aanroep plaatsvindt: repeat repeat x = x : repeat x 11

23 repeat is zinvol In tegenstelling tot wat je zou kunnen denken is repeat niet onzinnig: head :: [a] > a head (x : xs) = x head (repeat 3) => head (3 : repeat 3) => 3 In Haskell wordt een expressie niet verder uitgerekend dan nodig is! Voor de pattern match (in head) is het voldoende om de definitie van repeat één keer uit te vouwen, en zo : zichtbaar te maken, zodat pattern matching slaagt. 12

24 repeat is zinvol In tegenstelling tot wat je zou kunnen denken is repeat niet onzinnig: head :: [a] > a head (x : xs) = x head (repeat 3) => head (3 : repeat 3) => 3 In Haskell wordt een expressie niet verder uitgerekend dan nodig is! Voor de pattern match (in head) is het voldoende om de definitie van repeat één keer uit te vouwen, en zo : zichtbaar te maken, zodat pattern matching slaagt. Het is de pattern matching in Haskell die de evaluatie aandrijft. 12

25 Eisen aan recursie (heroverweging) Recursieve functies zijn zinvol onder de volgende voorwaarden: de parameter van de recursieve aanroep is eenvoudiger (bijvoorbeeld: numeriek kleiner, of een kortere lijst) dan de parameter van de te definiëren functie; voor een basis-geval is er een niet-recursieve definitie. of: de functie is productief! Dit laatste is uniek voor lazy geëvalueerde talen. 13

26 Aansluiten bij bekende notatie De wiskundige definitie van machtsverheffen kan vrijwel letterlijk als Haskell-functie worden gebruikt: xˆ0 = 1 xˆn = x xˆ(n 1) 14

27 Aansluiten bij bekende notatie De wiskundige definitie van machtsverheffen kan vrijwel letterlijk als Haskell-functie worden gebruikt: xˆ0 = 1 xˆn = x xˆ(n 1) Een recursieve definitie waarin voor het gevalsonderscheid patronen worden gebruikt (in plaats van Boolese expressies) wordt daarom ook wel een inductieve definitie genoemd (over het type van het patroon). 14

28 Tussendoortje: meer dan één manier We kunnen schrijven: som lijst null lijst = 0 otherwise = head lijst + som (tail lijst) 15

29 Tussendoortje: meer dan één manier We kunnen schrijven: som lijst null lijst = 0 otherwise = head lijst + som (tail lijst) Maar meestal schrijven we: som [ ] = 0 som (kop : staart) = kop + som staart omdat we dit duidelijker vinden. 15

30 Anonieme waarden De standaardfunctie length, die het aantal elementen in een lijst bepaalt, kan ook inductief worden gedefinieerd: length [ ] = 0 length (kop : staart) = 1 + length staart 16

31 Anonieme waarden De standaardfunctie length, die het aantal elementen in een lijst bepaalt, kan ook inductief worden gedefinieerd: length [ ] = 0 length (kop : staart) = 1 + length staart Als kop niet nodig is, mag het teken gebruikt worden: length [ ] = 0 length ( : staart) = 1 + length staart 16

32 Anonieme waarden DeOp standaardfunctie deze manier wordt length, ervoor die het gezorgd aantal dat elementen iets wat in je een nietlijst wilt bepaalt, gebruiken, kan ook inductief niet kuntworden gebruiken. gedefinieerd: length [ ] = 0 length (kop : staart) = 1 + length staart Als kop niet nodig is, mag het teken gebruikt worden: length [ ] = 0 length ( : staart) = 1 + length staart 16

33 Layout is belangrijk Anders dan in de meeste andere programmeertalen is een regelovergang niet helemaal zonder betekenis. Bekijk bijvoorbeeld de volgende twee where-constructies: where v = f x y w = g z where v = f x y w = g z 17

34 Layout is belangrijk Anders dan in de meeste andere programmeertalen is een regelovergang niet helemaal zonder betekenis. Bekijk bijvoorbeeld de volgende twee where-constructies: where v = f x y w = g z where v = f x y w = g z De plaats van de regelovergang (tussen x en y, of tussen y en w) maakt nogal wat uit. 17

35 Layout regels (zo ongeveer) In een rij definities gebruikt Haskell de volgende methode om te bepalen wat bij elkaar hoort: een regel die precies even ver is ingesprongen als de vorige, wordt als nieuwe definitie beschouwd; is de regel verder ingesprongen, dan hoort hij bij de vorige regel; is de regel minder ver ingesprongen, dan hoort hij niet meer bij de huidige lijst definities. 18

36 Layout regels (zo ongeveer) In een rij definities gebruikt Haskell de volgende methode om te bepalen wat bij elkaar hoort: een regel die precies even ver is ingesprongen als de vorige, wordt als nieuwe definitie beschouwd; is de regel verder ingesprongen, dan hoort hij bij de vorige regel; is de regel minder ver ingesprongen, dan hoort hij niet meer bij de huidige lijst definities. Dat laatste is van belang als een where-constructie binnen een andere where-constructie voorkomt. Bijvoorbeeld in 18 f x y = g (x + w) where g u = u + v where v = u u w = 2 + y

37 In de praktijk volstaat meestal: In de praktijk gaat alles vanzelf goed als je één ding in het oog houdt: gelijkwaardige definities moeten even ver worden ingesprongen Dit betekent ook dat alle globale functiedefinities even ver moeten worden ingesprongen (bijvoorbeeld allemaal nul posities). 19

38 Commentaar Er zijn in Haskell twee soorten commentaar: met de symbolen -- begint commentaar dat tot het eind van de regel doorloopt; met de symbolen {- begint genest commentaar dat doorloopt tot de symbolen -}. Maar wie hoort bij wie: {- allemaal even niet nodig...code... {- code commentaar -}...code... -} 20

39 Commentaar Er zijn in Haskell twee soorten commentaar: met de symbolen -- begint commentaar dat tot het eind van de regel doorloopt; met de symbolen {- begint genest commentaar dat doorloopt tot de symbolen -}. Maar wie hoort bij wie: {- allemaal even niet nodig...code... {- code commentaar -}...code... -} 20 Maar wat als -- deel uitmaakt van een operator zoals <-->?

40 Syntactische fouten Als een functie-definitie niet aan de vorm-eisen voldoet, krijg je daarvan een melding zodra deze functie geanalyseerd wordt: isnul x = x = 0 Wat is er fout? 21

41 Syntactische fouten Als een functie-definitie niet aan de vorm-eisen voldoet, krijg je daarvan een melding zodra deze functie geanalyseerd wordt: isnul x = x = 0 Wat is er fout? Bij de analyse van deze functie meldt de ghci interpreter: Prelude> let isnul x = x = 0 interactive:1:16: parse error on input = 21

42 Typering en type inferentie Typerings-fouten treden bijvoorbeeld op bij het toepassen van de functie length op iets anders dan een lijst, zoals in length 3: Prelude> length 3 interactive:1:7: No instance for (Num [a]) arising from the literal 3 at... Possible fix: add an instance declaration for (Num [a]) In the first argument of length, namely

43 Typering en type inferentie Typerings-fouten treden bijvoorbeeld op bij het toepassen van de functie length op iets anders dan een lijst, zoals in length 3: Prelude> length 3 interactive:1:7: No instance for (Num [a]) arising from the literal 3 at... Possible fix: add an instance declaration for (Num [a]) In the first argument of length, namely 3... Foutmeldingen van de type checker kunnen wat cryptisch zijn, omdat ze teveel van de onderliggende mechanismen laten zien. 22

44 Opvragen van het type van een expressie Het type van een expressie kan bepaald worden met de interpreter-opdracht :t (afkorting van type ). Achter :t staat de expressie die getypeerd moet worden. Bijvoorbeeld:? :t True && False True && False :: Bool Het symbool :: kan gelezen worden als heeft het type. De expressie wordt met de :type-opdracht niet uitgerekend; alleen het type wordt bepaald. 23

45 De basistypes Er zijn aantal basis-types: Int: het type van de gehele getallen (integer numbers of integers), tot een maximum van ruim 2 miljard; Integer: het type van gehele getallen, zonder praktische begrenzing Float: het type van de floating-point getallen; Bool: het type van de Boolese waardes True en False; Char: het type van letters, cijfers en symbolen op het toetsenbord (characters) 24

46 Lijsten kunnen verschillende types hebben? :t [ a, b, c ] [ a, b, c ] :: [Char]? :t [True,False] [True,False] :: [Bool]? :t [ [1,2], [3,4,5] ] [[1,2],[3,4,5]] :: [[Int]] 25

47 Lijsten kunnen verschillende types hebben? :t [ a, b, c ] [ a, b, c ] :: [Char]? :t [True,False] [True,False] :: [Bool]? :t [ [1,2], [3,4,5] ] [[1,2],[3,4,5]] :: [[Int]] Alle waarden in een lijst moeten hetzelfde type hebben. 25

48 Zo niet... Zo niet, dan verschijnt er een melding van een typerings-fout: Prelude> :t [2,True] No instance for (Num Bool) arising from the literal 2 at... Possible fix: add an instance declaration for (Num Bool)... 26

49 Zo niet... Zo niet, dan verschijnt er een melding van een typerings-fout: Prelude> :t [2,True] No instance for (Num Bool) arising from the literal 2 at... Possible fix: add an instance declaration for (Num Bool)... Ook voor deze cryptische melding is er een reden. De 2 kan namelijk heel veel verschillende dingen betekenen. 26

50 Ook functies hebben een type Het type van een functie wordt bepaald door het type van de parameter en het type van het resultaat:? :t sum sum :: [Int] -> Int 27

51 Ook functies hebben een type Het type van een functie wordt bepaald door het type van de parameter en het type van het resultaat:? :t sum sum :: [Int] -> Int De functie sum neemt als argument een lijst van integer waarden (dat is de [Int]) en levert een enkele integer op. 27

52 En dit kan ook Je mag alles in een lijst zetten, dus ook functies:? :t [sin,cos,tan] [sin,cos,tan] :: [Float -> Float] 28

53 Expliciet types opgeven Een functiedefinitie met een expliciet opgegeven type: sum :: [Int] > Int sum [ ] = 0 sum (x : xs) = x + sum xs 29

54 Voordelen: er wordt gecontroleerd of de functie inderdaad het type heeft dat je ervoor hebt gedeclareerd; de declaratie maakt het voor een menselijke lezer eenvoudiger om een functie te begrijpen. als je alle types aan het begin zet heb je een soort inhoudsopgave je kunt het type gebruiken om een functie in Hoogle op te zoeken 30

55 Parametrische polymorfie Voor sommige functies op lijsten maakt het niet uit wat het type van de elementen van die lijst is. Het type van de functie length wordt dan ook als volgt genoteerd: length :: [a] > Int 31

56 Parametrische polymorfie Voor sommige functies op lijsten maakt het niet uit wat het type van de elementen van die lijst is. Het type van de functie length wordt dan ook als volgt genoteerd: length :: [a] > Int Het type van deze elementen wordt aangegeven door een typevariabele, in het voorbeeld a. Typevariabelen worden, in tegenstelling tot de vaste types als Int en Bool, met een kleine letter geschreven. NB: deze polymorfie noemt men vaak generics in de OO wereld. 31

57 Typering door beperking Het type van een definitie wordt bepaald door de beperkingen die worden opgelegd door de expressie: id x = x legt geen beperking op aan het argument, dat dan willekeurig mag zijn. Dus id :: a >?, en omdat het argument wordt opgeleverd is het dan id :: a > a. Bij eenbijeerste [ ] = 1 eenbijeerste (x : xs) = x bepaalt het patroon dat het argument een lijst is, en de rechterkanten dat het resultaat een Int is, en dat x ook een integer is. Alles bij elkaar: [Int] > Int.

58 Voorbeelden head :: [a] > a tail :: [a] > [a] 33

59 Voorbeelden head :: [a] > a tail :: [a] > [a] Polymorfe functies, zoals length en head, hebben met elkaar gemeen dat ze alleen de structuur van de lijst gebruiken. Een niet-polymorfe functie, zoals sum, gebruikt ook eigenschappen van de elementen van de lijst, zoals optelbaarheid. 33

60 Exploiteer polymorfie Niet alleen functies op lijsten kunnen polymorf zijn. De eenvoudigste polymorfe functie is de identiteits-functie (de functie die zijn parameter onveranderd oplevert): id :: a > a id x = x De functie id kan op elementen van willekeurig type werken (en het resultaat is dan van hetzelfde type). 34

61 Exploiteer polymorfie Niet alleen functies op lijsten kunnen polymorf zijn. De eenvoudigste polymorfe functie is de identiteits-functie (de functie die zijn parameter onveranderd oplevert): id :: a > a id x = x De functie id kan op elementen van willekeurig type werken (en het resultaat is dan van hetzelfde type). De functie kan zelfs worden toegepast op functies, zoals in id sqrt. 34

62 Quizvraag Wat denk je van: id id (id id) (id id id) 35

63 Quizvraag Wat denk je van: id id (id id) (id id id) Vraag je het type van beide aan ghci dan krijg je b > b (of a > a, of c > c,...). Zoals het type al aangeeft kan id worden toegepast op parameters van een willekeurig type, dus ook zichzelf. 35

64 Quizvraag Wat denk je van: id id (id id) (id id id) Vraag je het type van beide aan ghci dan krijg je b > b (of a > a, of c > c,...). Zoals het type al aangeeft kan id worden toegepast op parameters van een willekeurig type, dus ook zichzelf. Welke functies zijn dit? 35

65 Meer dan één parameter De functie abcformule heeft drie floating-point getallen als parameter en een lijst met floating-point getallen als resultaat. De type-declaratie luidt daarom: abcformule :: Float > Float > Float > [Float] 36

66 Meer dan één parameter De functie abcformule heeft drie floating-point getallen als parameter en een lijst met floating-point getallen als resultaat. De type-declaratie luidt daarom: abcformule :: Float > Float > Float > [Float] En de functie map map :: (a > b) > [a] > [b] 36 De eerste parameter van map is een functie tussen willekeurige types (a en b), die dus niet eens hetzelfde hoeven te zijn. De tweede parameter van map is een lijst, waarvan de elementen hetzelfde type (a) moeten hebben als de parameter van de functie-parameter. En idem voor b.

67 Quizvraag Denk je dat de volgend expressie goed getypeerd is, en zo ja wat is dan het type: [sin, id] 37

68 Quizvraag Denk je dat de volgend expressie goed getypeerd is, en zo ja wat is dan het type: [sin, id] Antwoord: Prelude> :t sin sin :: Float -> Float Prelude> :t id id :: a -> a Prelude> :t [sin, id] [sin, id] :: [Float -> Float] 37

69 Quizvraag Denk je dat de volgend expressie goed getypeerd is, en zo ja wat is dan het type: [length, head] 38

70 Quizvraag Denk je dat de volgend expressie goed getypeerd is, en zo ja wat is dan het type: [length, head] Antwoord: Prelude> :t length length :: [a] -> Int Prelude> :t head head :: [a] -> a Prelude> :t [length,head] [length,head] :: [[Int] -> Int] Prelude> 38

71 Operator naar functie en terug een operator tussen haakjes wordt gebruikt als een functie: Prelude> Prelude> (+)

72 Operator naar functie en terug een operator tussen haakjes wordt gebruikt als een functie: Prelude> Prelude> (+) andersom: een functie tussen back quotes gedraagt zich als de overeenkomstige operator. Prelude> div Prelude> 8 div 4 2 Prelude> (1 abcformule 2)