Hogere-ordefuncties

Een lijst langs lopenen met elk element iets doen

Een lijst langs lopenen sommige elementen selecteren

map

filter

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

Definitie van map

Geef een recursieve definitie:

map :: (ab) [a] [b]

map f [ ] =map f (x:xs)=

[ ]map f xs

f x

:

Definitie van filter

Geef een recursieve definitie,en gebruik guards voor gevalsonderscheid

filter :: (aBool) [a] [a] filter p [ ] =filter p (x:xs) =

[ ]x : filter p xs| p x

| True = filter p xs

Een ander soort lijst-functies

product :: [Int] Int product [ ] =product (x:xs)

=

1product xsx *

and :: [Bool] Bool and [ ] =and (x:xs)=

Trueand xsx

&&sum :: [Int] Int sum [ ] =sum (x:xs)

=

0sum xsx +

Universele “lijst-totalisator”

foldr :: [a] a

foldr (#) e [ ] =foldr (#) e (x:xs)=

efoldr (#) e xsx #

(aaa) a

zo combineren neutrale waarde

Had dat eerder gezegd...

Als foldr de generalisatie isvan sum, product, en and ....

.... dan zijn sum, product, en andspeciale gevallen van foldr

product = foldr (*) 1and = foldr (&&) Truesum = foldr (+) 0or = foldr (||) False

Hoger-ordefuncties op lijsten

Doorloop een lijst en ...

map :: (ab) [a] [b]

filter :: (aBool) [a] [a]

foldr :: (aaa) a [a] a

[a]

[a]

[a]

doe dit

pak deze

combineer zo

begin hiermee

Hoger-ordefuncties op lijsten

Doorloop een lijst en ...

map :: (ab) [a] [b]

filter :: (aBool) [a] [a]

foldr :: (abb) b [a] b

[a]

[a]

[a]

doe dit

pak deze

combineer zo

begin hiermee

Andere hogere-ordefuncties

until :: (aBool) (aa) a a

begin hiermeedoe dit

totdat dit geldt

> until (>1000) (*2) 11024

until p f x =| p x | True =

x(f x)until p f

Andere hogere-ordefuncties

(.) ::

begin hiermee

doe diten dan dat

> map (not . even) [1, 2, 3, 4, 5, 6]

[1, 3, 5]

(.) g f x =

g (f x)

a(ab)(bc) c(a c)

Partieel parametriseren

> map (plus 5) [1 .. 5][6, 7, 8, 9, 10]

> until (>1000) (*2) 11024

> filter (not . even) [1 .. 5][1, 3, 5]

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 )

Lambda-expressies

x*x + 3*x + 2

expressie waarx vrij in voorkomt

\ x

de functie die dieexpressie uitrekent

Lambda ?

x . x*x + 3*x + 2

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

Hoger-ordefuncties op lijsten

Doorloop een lijst en ...

map :: (ab) [a] [b]

filter :: (aBool) [a] [a]

foldr :: (abb) b [a] b

[a]

[a]

[a]

doe dit

pak deze

combineer zo

Currying

Type

Aanroep

f :: Int Bool String

> f 7 True“hoi”

f 7

Bool String

rechts-associatief

links-associatief

zonder haakjes!