(S)DT 2012-20131 Haskell Functioneel programmeren.

Presentatie over: "(S)DT 2012-20131 Haskell Functioneel programmeren."— Transcript van de presentatie:

1 (S)DT 2012-20131 Haskell Functioneel programmeren

2 Bijkomend materiaal de Haskell website http://www.haskell.org/.http://www.haskell.org/. Op de "Learning Haskell" pagina http://www.haskell.org/haskellwiki/Learning_Haskell vind je veel bijkomende informatie. http://www.haskell.org/haskellwiki/Learning_Haskell Je vindt er online materiaal, bijvoorbeeld Learn You a Haskell for Great Good (tutorial) http://learnyouahaskell.com/ Yet Another Haskell Tutorial http://www.cs.utah.edu/~hal/docs/daume02yaht.pdfhttp://learnyouahaskell.com/ http://www.cs.utah.edu/~hal/docs/daume02yaht.pdf of een nederlandstalige cursustekst (http://people.cs.uu.nl/jeroen/courses/fp-nl.pdf).http://people.cs.uu.nl/jeroen/courses/fp-nl.pdf (S)DT 2012-2013 2

3 Bijkomend materiaal In de didactische cluster van de CBA vind je Programming in Haskell Graham Hutton, University of Nottingham Cambridge University Press, January 2007 (http://www.cs.nott.ac.uk/~gmh/book.html).http://www.cs.nott.ac.uk/~gmh/book.html Ook video lectures gebaseerd op het boek!! !!!!! Er is een online manual die je ook tijdens het examen lokaal kan raadplegen: not (http://zvon.org/comp/r/ref-Haskell.html)http://zvon.org/comp/r/ref-Haskell.html (S)DT 2012-2013 3

4 Bijkomend materiaal !!!!! Er is een online manual die je ook tijdens het examen lokaal kan raadplegen: not (http://zvon.org/comp/r/ref-Haskell.html)http://zvon.org/comp/r/ref-Haskell.html Maar, http://zvon.org/other/haskell/Outputglobal http://zvon.org/other/haskell/Outputglobal (Gequoteerde) oefeningen + modeloplossingen (S)DT 2012-2013 4

5 5 Haskell Deel 1 Introductie; lijsten in Haskell; lui uitvoeringsmechanisme; polymorfe functies

6 (S)DT 2012-2013 6 Een eenvoudig Haskell programma fib :: Int -> Int -- een typedeclaratie voor fib fib 0 = 1 fib 1 = 1 fib n = (fib (n-1)) + (fib (n-2)) fib is een recursieve functie die kan toegepast worden op 1 argument dat een integer moet zijn en dan als waarde een integer teruggeeft. zet definitie in een bestand, bijvoorbeeld f.hs laad in in ghci (Haskell platform http://hackage.haskell.org/platform/) doe functie-oproepen

7 (S)DT 2012-2013 7 # GHCi, version 6.12.3: http://www.haskell.org/ghc/ :? for help... -- commentaar tot einde lijn Prelude> :load f -- :load is directief Main> fib 3 -- pas fib toe op 3 3 -- resultaat is 3 Main> fib 6 13 Main> fib (-1) ……………………………… computatie gebeurt door.... Functionele taal …. Bouwstenen in je programma’s: herbruikbare functies (die modelleren algoritmen) Expressies in een functionele taal : waarde gebaseerd

8 (S)DT 2012-2013 8 Main> :type fib fib :: Int -> Int Main> :type (+) (+) :: Num a => a -> a -> a “Voor alle types a die de Num operaties ondersteunen”, (+) is een functie die twee argumenten van het type a afbeeldt op een resultaat van het type a. Int is een voorbeeld van een type dat de Num operaties ondersteunt: de funties (+), (-), (*),...

9 (S)DT 2012-2013 9 -- variabele a Main> fib a :1:4: Not in scope: `a‘ Main> fib "asd“ -- de string "asd“ is in feite een lijst van Char -- [Char] -- type fout: [Char] is geen Int :1:0: Couldn't match expected type `Int' against inferred type `[Char]' In the first argument of `fib', namely `"asd"' In the expression: fib "asd" In the definition of `it': it = fib "asd"

10 (S)DT 2012-2013 10 Haskell: merk op Haskell is getypeerd (statisch en sterk) een functie wordt gedefinieerd aan de hand van verschillende clauses (pattern) matching gebeurt van boven naar onder en eerste argumenten-match wordt genomen er zijn “ingebouwde” functies (+ - ) veranderlijken en functienamen beginnen met kleine letter type begint met een hoofdletter (enkel al Int) functies met letter in prefix (kan anders) speciale tekens in infix

11 (S)DT 2012-2013 11 Syntactisch alternatieve definitie van fib fib n = if n == 0 then 1 -- else verplicht else if n == 1 then 1 else (fib (n-1)) + (fib (n-2)) Maar fib n = if n == 0 then 1 else if n == 1 then 1 else (fib (n-1)) + (fib (n-2)) Prelude>:l f.hs [1 of 1] Compiling Main ( fib.hs, interpreted ) f.hs:14:0: parse error (possibly incorrect indentation) Failed, modules loaded: none.

12 (S)DT 2012-2013 12 Andere versies van fib fib :: Int -> Int fib2 :: Int -> Int -> Int -> Int fib n = fib2 n 1 0 fib2 0 n _ = n fib2 i n m = fib2 (i-1) (m+n) n vroeger Main> fib 100 -1869596475 nu Main> fib 100 1298777728820984005

13 Interactieve evaluatie (:set +t) Main> 8 + 2 10 it :: Integer Main> it + 3 13 it :: Integer Main> let x = 3+4 x :: Integer Main> x 7 it :: Integer Main> :show bindings x :: Integer = 7 it :: Integer = 7 (S)DT 2012-2013 13

14 (S)DT 2012-2013 14 Haskell: merk verder op waar zijn de typedeclaraties bij sommige vb? het type van een functie die meerdere argumenten kan hebben wordt genoteerd door A1 -> A2 -> A3 -> R

15 (S)DT 2012-2013 15 Type-declaraties, -inferentie en -checking f a b = g a (h b) -- haakjes zijn nodig g :: R -> S -> T … -- definitie van g h :: Q -> P … -- definitie van h 1. het type van f moet dan zijn: f :: R -> Q -> T 2. is het type van g en h consistent? enkel indien P == S -- beetje te straf Haskell kan types infereren (1) en nakijken (2) gebaseerd op Hindley-Milner type systeem (van ML)

16 (S)DT 2012-2013 16 Currying en waarom de haakjes? eigenlijk heeft een functie altijd maar 1 argument en is dus een “curried” functie voor een functie f :: A -> B -> C hebben we dat (f a) :: B -> C dus, een functie met n argumenten, toegepast op 1 argument geeft als resultaat een functie met n-1 argumenten bovenstaande declaratie is equivalent met f :: A -> (B -> C) en totaal verschillend van f :: (A -> B) -> C tenslotte, g a h b == (((g a) h) b) en niet g a (h b)

17 (S)DT 2012-2013 17 Curried versie van de optelling -- versie met tuple als argument add :: (Int,Int) -> Int add (x,y) = x + y -- curried versie cadd cadd :: Int -> Int -> Int cadd x y = x + y -- hetzelfde resultaat maar voor cadd wordt er eerst (cadd x) berekend en dan … -- -> is rechts-associatief dus geen haakjes nodig in cadd :: Int -> (Int -> Int) -- functie-oproepen zijn links-associatief dus geen haakjes nodig in cadd 3 4 want is in feite ((cadd 3) 4) --

18 Curried functies Meer flexibel dan functies met tuples Partieel toegepaste functies kunnen erg nuttig zijn plus4 = (cadd 4) -- enkele nuttige functies gedefinieerd door sections isNul = (== 0) verdubbel = (2*) tweeTotde = (2^) Een infix operator is in feite ook een curried functie (+) 1 2 (S)DT 2012-2013 18

19 (S)DT 2012-2013 19 Operator section partieel toegepaste operator: (+ 3) en (3 +) (op a) b = b op a (a op) b = a op b Main>:t (-3) (-3) :: (Num a) => a

20 (S)DT 2012-2013 20 Currying, genoemd naar Haskell Curry 1900- 1982 Logicus die rond functie theorie werkte een simpel theoretisch model: enkel functies met 1 argument, bv. lambda calculus f :: (Int -> Int) -> Int -> Int f g a = g a -- apply g to a Main> f (+3) 4 7 Main> f (3-) 4 Main> f (*4) 4 16 Wat is (f (3+))? Alternatieve def voor f? (3+) $ 4

21 (S)DT 2012-2013 21 Verschil f :: ( Int -> Int -> Int) -> Int -> Int -> Int f g a b = g a b Main> f (+) 3 4 7 Main> f (-) 3 4 Wat is (f (+))? Wat is f?

22 (S)DT 2012-2013 22 Hogere orde functies functies kunnen als argument een functie hebben functies kunnen als resultaat een functie teruggeven functies kunnen als parameter van andere functies worden gebruikt -- later toepassen van een functie f op 1 argument a noteren we door (f a) eventueel zonder haakjes vergelijk met Lisp (f a b)!!!

23 (S)DT 2012-2013 23 Geschiedenis 1920-1930: functies als berekeningsmodel, M. Schönfinkel, Haskell Curry en Alonzo Church (lambda calculus) 1950: eerste functionele programmeertaal, Lisp van John McCarthy (emacs) 1978: Backus (Fortran;Backus Naur Form) in zijn Turing Award Lecture: “Can programming be liberated from the Von Neumann style” pleidooi voor echt functioneel programmeren 1980: getypeerde functionele talen programmeertalen: ML, Scheme (een aanpassing van Lisp), Miranda, Gofer, Clean

24 (S)DT 2012-2013 24 Geschiedenis 1987: groep onderzoekers definieren de taal Haskell Richard Bird, Paul Hudak, John Hughes, Neil Jones, Simon Peyton Jones, Philip Wadler,.... “referential” transparantie “substitute equals for equals” http://www.defmacro.org/ramblings/fp.html

25 (S)DT 2012-2013 25

26 Prelude The Prelude: a standard module imported by default into all Haskell modules. For more documentation, see the Haskell 98 Report http://www.haskell.org/onlinereport/.http://www.haskell.org/onlinereport/ GHC Documentation (Basic) Libraries Prelude, Data.List specificaties + source (S)DT 2012-2013 26

27 (S)DT 2012-2013 27 !!!!http://zvon.org/comp/r/ref- Haskell.html (en ook oude versie) The Haskell reference is based on Haskell 98 Report and Haskell 98 Libraries Report and a substantial part of descriptions comes from these specifications.

28 (S)DT 2012-2013 28 Let expressies fib n = if n == 0 then 0 else if n == 1 then 1 else let a = fib (n-1) b = fib (n-2) in a + b a en b zijn lokale variabelen binnen de laatste else tak de = is geen toekenning!!! Maar … let y = a*b f x = (x+y)/y in f c + f d

29 (S)DT 2012-2013 29 Where clauses fib :: Int -> Int fib n = fib2 n 1 0 where fib2 0 n _ = n fib2 i n m = fib2 (i-1) (m+n) n fib2 is lokaal aan fib (clause die er juist voor staat) fib2 is elders niet zichtbaar fib2 heeft geen type declaratie genest gebruik van syntax mogelijk

30 (S)DT 2012-2013 30 To do start ergens ghci op type wat kleine programma’s in laad en voer de oproepen uit maak fouten tegen types, indentatie en syntax definieer max :: Int -> Int -> Int max a b en ook maxdrie a b c schrijf minstens 1 nieuwe hogere orde functie ontdek een probleem met fib (2^100)

31 LIJSTEN IN HASKELL (S)DT 2012-2013 31

32 (S)DT 2012-2013 32 Lijsten in Haskell een lijst is een rij zonder constante tijd random toegang en gegeven een lijst kan er in constante tijd een element aan toegevoegd worden (van voor). (anders is het een array) een lijst is leeg of een element gevolgd door een lijst een lijst heeft elementen die alle hetzelfde type hebben.

33 (S)DT 2012-2013 33 Een lijst van Int een lege lijst [] lijst met elementen 4 5 1 [4,5,1] alternatieve notaties voor [4,5,1] 4 : [5,1] 4 : 5 : 1 : [] Prelude> :t (:) (:) :: a -> [a] -> [a] Hoe in Prolog??

34 (S)DT 2012-2013 34 Lijsten aan elkaar hangen append :: [Int] -> [Int] -> [Int] append [] l = l append (x:xs) a = x : (append xs a) Is er een verschil met het concateren van lijsten in Prolog of linked lists in Java? In Prelude [] ++ ys = ys (x:xs) ++ ys = x : (xs ++ ys) Let op: append x:xs wordt opgevat als (append x) : xs

35 Herschrijven als uitvoeringsmodel [] ++ ys = ys (x:xs) ++ ys = x : (xs ++ ys) [1,2] ++ [4,5] = (1:2:[]) ++ (4:5:[]) = 1 : ((2:[]) ++ (4:5:[])) = 1 : 2 : ([] ++ (4:5:[])) = 1 : 2 : 4 : 5 : [] (S)DT 2012-2013 35

36 (S)DT 2012-2013 36 Let op: vergelijk [2] ++ [3,4,5] 2 ++ [3,4,5] :1:0: No instance for (Num [a]) arising from the literal `2' at :1:0 Possible fix:add an instance declaration for (Num [a]) In the first argument of `(++)', namely `2' In the expression: 2 ++ [3, 4, 6] In the definition of `it': it = 2 ++ [3, 4, 6]

37 (S)DT 2012-2013 37 Let op: vergelijk 2 : [3,4,5] [2] : [3,4,5] No instance for (Num [t]) arising from the literal `5' at :1:11 Possible fix:add an instance declaration for (Num [t]) In the expression: 5 In the second argument of `(:)', namely `[3, 4, 5]' In the expression: [2] : [3, 4, 5]

38 (S)DT 2012-2013 38 Lengte van een lijst listlength :: [Int] -> Int listlength [] = 0 listlength (x:xs) = 1 + (listlength xs) of listlength l = ll l 0 where ll [] acc = acc ll (x:xs) acc = ll xs (acc+1) Is er een reden om de ene beter te vinden dan de andere?

39 (S)DT 2012-2013 39 Insertion sort isort :: [Int] -> [Int] isort [] = [] isort (x:xs) = insert x (isort xs) where insert x [] = [x] insert x (y:ys) = if x < y then (x: y : ys) else (y: (insert x ys))

40 (S)DT 2012-2013 40 To do schrijf een functie die van een lijst van Ints enkel de positieve getallen behoudt schrijf een functie die de som teruggeeft van de positieve getallen in een lijst van Ints. schrijf een functie die het maximum van een lijst van Ints teruggeeft

41 LUI UITVOERINGSMECHANSIME (S)DT 2012-2013 41

42 (S)DT 2012-2013 42 Parameter passing mechanisme Wat ken je al?  Java: call by value actueel argument wordt geëvalueerd voor de methode wordt opgeroepen  ?? Haskell: actueel argument wordt geëvalueerd wanneer de waarde ervan nodig is Haskell is lui Haskell heeft call by need

43 (S)DT 2012-2013 43 Wat betekent lui? g a b = h (a+b) h i = 9 > g 3 4 Waarom ooit de (3+4) uitrekenen als geen enkele functie die waarde ooit zal gebruiken?

44 (S)DT 2012-2013 44 De essentie van luiheid Een expressie wordt maar gereduceerd tot een waarde indien de waarde nodig is. Een expressie wordt slechts één keer gereduceerd tot een waarde kwadraat i = i * i telop x y = x + y kwadraat (telop 6 2) contrasteer met call by value, call by name

45 (S)DT 2012-2013 45 Voorbeeld && : luie evaluatie van argumenten (&&), (||) :: Bool -> Bool -> Bool False && x = False True && x = x False || x = x True || x = True Prelude> 4 < 5 && 3 < (5/0) Program error???? Ghci: True -- 3 < Infinitity !! Prelude> 5 < 4 && 3 < (5/0) False

46 (S)DT 2012-2013 46 Voorbeeld: luie matching f :: [Int] -> [Int] -> Int f [] y = 0 add1 [] = [] f (a:x) [] = 0 add1 (x:xs) = (x+1): add1 xs f (a:x) (b:y) = a + b f (add1 [4,5,6]) (add1 [10,20,30]) = f ((4+1):add1 [5,6]) (add1 [10,20,30]) = f (5:add1 [5,6]) (add1 [10,20,30]) = f (5:add1 [5,6]) (11: add1 [20,30]) = 5 + 11 = 16

47 Wat met accumulator versie van listlength?? listlength l = ll l 0 where ll [] acc = acc ll (x:xs) acc = ll xs (acc+1) Wat gebeurt er met (acc+1)??? De hele som wordt opgebouwd voor ze wordt berekend!! where llstrict [] l = l llstrict (x:xs) l = llstrict xs $! (l+1) -- f $! x behaves as f x, except that the evaluation of the argument x is forced before f is applied (S)DT 2012-2013 47

48 (S)DT 2012-2013 48 Luiheid en oneindige lijsten plus1 :: [Int] -> [Int] plus1 [] = [] plus1 (x: xs) = (x+1) : (plus1 xs) langelijst :: [Int] langelijst = (1 : (plus1 langelijst)) -- (*) langelijst is een functie zonder argumenten, enkel resultaat langelijst is een waarde die voldoet aan de vergelijking (*) met call by value is (*) een onmogelijke definitie zolang we maar eindig veel delen van langelijst nodig hebben is er geen probleem: Haskell zal er niet meer berekenen

49 (S)DT 2012-2013 49 Hoe eindig veel elementen van een oneindige lijst gebruiken? take :: Int -> [Int] -> [Int] take 0 _ = [] take n (x:xs) = x : take (n-1) xs fib :: [Int] fib = (1:1: (f 1 1 )) where f a b = (a+b): (f b (a+b)) Main> take 3 [1,2,3,4,5] [1,2,3] Main> take 10 fib [1,1,2,3,5,8,13,21,34,55] Wat is de waarde van fib ? Welke functie zorgt voor welke evaluatie?

50 (S)DT 2012-2013 50 Kijk zelf na Main> take 3 langelijst [1,2,3] Welke functie zorgt voor de evaluatie van welke uitdrukking???

51 isSorted :: [Int] -> Bool isSorted [] = True isSorted [_] = True isSorted (x:y:ys) = (x <= y) && isSorted (y:ys) iterate :: (a -> a) -> a -> [a] iterate next x = x : iterate next (next x) Main> isSorted (iterate (`div` 2) 8) Main> isSorted (iterate (`div` 2) (-100)) Main> iterate (`div` 2) (factorial 100) (S)DT 2012-2013 51 Extra voorbeeld

52 POLYMORFE FUNCTIES (S)DT 2012-2013 52

53 (S)DT 2012-2013 53 Een voorbeeld listlength:: [Int] -> Int listlength [] = 0 listlength (_:xs) = 1 + listlength xs Wat is er aan de clauses van listlength dat maakt dat het alleen zou werken voor [Int] ? Kan het ook werken met elementen van een ander type? een willekeurig type? Niet met die typedeclaratie natuurlijk!!

54 (S)DT 2012-2013 54 Nu als polymorfe functie listlength:: [t] -> Int listlength [] = 0 listlength (_:xs) = 1 + listlength xs t is een type-veranderlijke !! lees bv. als: voor elk type t is listlength een functie die toegepast op een lijst met type t elementen een Int berekent belangrijk: alle elementen van de lijst moeten van hetzelfde type zijn!!!

55 (S)DT 2012-2013 55 Bekende functies: polymorfe versie append :: [t] -> [t] -> [t] append [] l = l append (x:xs) a = x : append xs a -- waarom niet [a] -> [b] -> [c] ??? take :: Int -> [t] -> [t] take 0 _ = [] take n (x:xs) = x : take (n-1) xs

56 (S)DT 2012-2013 56 Nieuwe polymorfe functies id :: a -> a -- identiteits-functie id x = x map :: (a -> b) -> [a] -> [b] map f [] = [] map f (h: r) = (f h) : map f r Main> map (+1) [1,2,3] [2,3,4] g i = if i > 0 then True else False > map g [-1,3,-4,4] meer dan 1 type parameter!!! soms a == b

57 (S)DT 2012-2013 57 Tuples lijsten versmelten en een nieuw data type zip :: [a] -> [b] -> [(a,b)] zip []_ = [] zip _ [] = [] zip (x:xs) (y:ys) = ( (x,y) : (zip xs ys)) Main> zip [1,2,3,4] [True,False,True] [ (1,True), (2,False), (3,True)] tuples van elke grootte zijn ingebouwd en pattern matchen enkel met tuples van gelijke grootte

58 (S)DT 2012-2013 58 Guards als syntactische suiker merge :: [Int] -> [Int] -> [Int] merge [] l = l merge l [] = l merge (x:xs) (y:ys) = if (x < y) then (x : merge xs (y:ys)) else if x > y then (y : merge (x:xs) ys) else (x : merge xs ys) -- of ook : laatste clause met guards merge (x:xs) (y:ys) | x < y = (x : merge xs (y:ys)) | x > y = (y : merge (x:xs) ys) | True = (x : merge xs ys)

59 (S)DT 2012-2013 59 Verschillende stijlen in Haskell: declaratie expressie een functie-definitie is een opeenvolging van onafhankelijke gelijkheden sign x | x>0 = 1 | x==0 = 0 | x<0 = -1 een functie-definitie is een expressie sign x = if x>0 then 1 else if x==0 then 0 else -1

60 (S)DT 2012-2013 60 Schrijf nu zelf een functie quicksort voor [Int] een functie die een oneindige lijst van alle positieve oneven getallen specifieert een functie die een oneindige lijst van alle priemgetallen specifieert een functie die nagaat of een gegeven getal een priemgetal is probeer een polymorfe sort te schrijven

61 (S)DT 2012-2013 61 Nog eens: luie evaluatie Actueel argument van een functie: uitgestelde berekening Werkt met een closure: te evalueren expressie + relevante bindingen Closures nemen plaats in op de heap (ook ints, lists, …) Call by need en call by value: zelfde antwoord als het programma eindigt MAAR nooit meer reductie-stappen want.. Soms toch waarde berekenen: wanneer?

62 (S)DT 2012-2013 62 Stricte functies Argument van een functie: als de waarde ervan altijd nodig is, dan is de functie strict in dat argument. Voorbeeld: fact n, kwadraad i, telop x y Maar project x y = x constPi x = 3.14 Voor stricte argumenten: compiler kan beslissen toch uit te rekenen Voor niet-stricte argumenten: (keten van) closures nemen plaats op heap

63 (S)DT 2012-2013 63 Nut van oneindige lijsten? lui? Programma: abstracter, eenvoudiger Producer + consumer toepassingen met corouting Een tijdelijke lijst wordt “on demand” opgebouwd Enkel berekenen wat nodig is voor het vinden van een oplossing

64 (S)DT 2012-2013 64 Wat met andere functionele talen?? Stricte talen (call by value): Lisp, Scheme, ML, Erlang (concurrent) Niet-stricte/luie talen (call by need): Miranda (inspiratie voor Haskell), Hope, Clean (concurrent) Wat is het beste?? Implicaties van luiheid? Puur functioneel!!

65 (S)DT 2012-2013 65 De lambda notatie Een functie hoeft geen naam te hebben Enkel een voorschrift om de functie te evalueren Mogelijk in Haskell met de λ-notatie voor functies plus1list = map plus1 where plus1 i = i + 1 -- ofwel ook plus1list = map (\x -> x+1) Meer algemeen (\a b c d -> (fib a) + (head b) * c +d ) Wat is (\x y -> x * y) 3 ?

66 (S)DT 2012-2013 66 filter :: (t -> Bool) -> [t] -> [t] filter p [] = [] filter p (x:xs) | p x = x : rest | otherwise = rest where rest = filter p xs Miranda Lisp, ML, Scheme filter = \p -> \xs -> case xs of [] -> [] (x:xs) -> let rest = filter p xs in if (p x) then x : rest else rest

67 (S)DT 2012-2013 67 Lijsten van gehele getallen Alsof Haskell vooraf definieerde: [n..m] = if n > m then [] else n : [ (n+1).. m] [i..] = (i : [(i+1).. ]) dus Main> [3..8] [3,4,5,6,7,8] Main> [-5..1] [-5,-4,-3,-2,-1,0,1] Main> take 4 [21..] [21,22,23,24]

68 (S)DT 2012-2013 68 Functie samenstelling filterpos::[Int] -> [Int] filterpos [] = [] filterpos (x:xs) | x > 0 = x : filterpos xs | otherwise = filterpos xs suml :: [Int] -> Int suml [] = 0 suml (x:xs) = x + suml xs addpos l = suml (filterpos l) addpos2 = suml. filterpos -- suml na filterpos addpos3 = suml. (filter (>0)) addpos4 = foldr (+) 0. filter (>0)

69 Functie samenstelling Prelude> :t (.) (.) :: (b -> c) -> (a -> b) -> a -> c (f.g) x = f ( g x) foldr :: (a->b->b) -> b -> [a] -> b it takes the second argument and the last item of the list and applies the function, then it takes the penultimate item from the end and the result, and so on. See scanr for intermediate results.scanr Input: foldr (+) 5 [1,2,3,4] Output: 15 -- (1 + ( 2 + (3 + (4 +5)))) Input: scanr (+) 5 [1,2,3,4] Output: [15,14,12,9,5] (S)DT 2012-2013 69

70 (S)DT 2012-2013 70 Haskell: einde deel 1 wordt vervolgd….