Hogere-ordefuncties nEen lijst langs lopen en met elk element iets doen nEen lijst langs lopen en sommige elementen selecteren map filter.

Presentatie over: "Hogere-ordefuncties nEen lijst langs lopen en met elk element iets doen nEen lijst langs lopen en sommige elementen selecteren map filter."— Transcript van de presentatie:

1 Hogere-ordefuncties nEen lijst langs lopen en met elk element iets doen nEen lijst langs lopen en sommige elementen selecteren map filter

2 map en filter > map even [1, 2, 3, 4, 5, 6] [False, True, False, True, False, True] > filter even [1, 2, 3, 4, 5, 6] [2, 4, 6] doe dit overal neem alleen wie hieraan voldoet

3 Definitie van map nGeef een recursieve definitie: map :: (a  b)  [a]  [b] map f [ ]= map f (x:xs)= [ ] map f xsf x :

4 Definitie van filter nGeef een recursieve definitie, en gebruik guards voor gevalsonderscheid filter :: (a  Bool)  [a]  [a] filter p [ ] = filter p (x:xs) = [ ] x : filter p xs | p x | True = filter p xs

5 Een ander soort lijst-functies product :: [Int]  Int product [ ]= product (x:xs)= 1 product xs x * and :: [Bool]  Bool and [ ]= and (x:xs)= True and xs x && sum :: [Int]  Int sum [ ]= sum (x:xs)= 0 sum xs x +

6 Universele “lijst-totalisator” foldr :: [a]  a foldr (#) e [ ] = foldr (#) e (x:xs)= e foldr (#) e xs x # (a  a  a)  a  zo combineren neutrale waarde

7 Had dat eerder gezegd... nAls foldr de generalisatie is van sum, product, en and.... n.... dan zijn sum, product, en and speciale gevallen van foldr product= foldr (*) 1 and= foldr (&&) True sum= foldr (+) 0 or= foldr (||) False

8 Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  a  a)  a  [a]  a [a] doe dit pak deze combineer zo begin hiermee

9 Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  b  b)  b  [a]  b [a] doe dit pak deze combineer zo begin hiermee

10 Andere hogere-ordefuncties until :: (a  Bool)  (a  a)  a  a begin hiermee doe dit totdat dit geldt > until (>1000) (*2) 1 1024 until p f x = | p x | True = x (f x) until p f

11 Andere hogere-ordefuncties (.) ::    begin hiermee doe dit en dan dat > map (not. even) [1, 2, 3, 4, 5, 6] [1, 3, 5] (.) g f x = g (f x) a (a  b) (b  c) c (a  c)

12 Partieel parametriseren > map (plus 5) [1.. 5] [6, 7, 8, 9, 10] > until (>1000) (*2) 1 1024 > filter (not. even) [1.. 5] [1, 3, 5]

13 Partieel parametriseren > map f [1.. 4] where f x = x*x + 3*x + 2 [6, 12, 20, 30] > map f [1.. 4] [6, 12, 20, 30] ( \ x  x*x+3*x+2 )

14 Lambda-expressies x*x + 3*x + 2 expressie waar x vrij in voorkomt \ x  de functie die die expressie uitrekent

15 Lambda ? x. x*x + 3*x + 2    x. x*x + 3*x + 2 x. x*x + 3*x + 2 (LAMBDA x)( x*x + 3*x + 2 ) \ x  x*x + 3*x + 2 \ x -> x*x + 3*x + 2

16 Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  b  b)  b  [a]  b [a] doe dit pak deze combineer zo

17 Currying nType nAanroep f :: Int  Bool  String > f 7 True “hoi” f 7 Bool  String  rechts-associatief links-associatief zonder haakjes!