map

Imperatief programmeren
Programma bestaat uit
opdrachten
gegroepeerd in methoden
Runnen is
één voor één uitvoeren
te beginnen met main
Functioneel programmeren
Programma bestaat uit
functie-definities
Runnen is
uitrekenen van een
expressie
Logisch programmeren
Programma bestaat uit
predicaat-definities
Runnen is
vervullen
van een predicaat
proberen te
Functie-definitie
static int kwad (int x)
{ return x*x ;
}
kwad :: Int  Int
kwad x = x * x
Haskell
Gebruik van de functie
public static void main(String [ ] ps)
{ System.out.println( this.kwad(5) );
}
main :: Int
main = kwad 5
Haskell
Functies definiëren
Door combinatie van standaardfuncties
fac :: Int  Int
fac n = product [1..n]
oneven :: Int  Bool
oneven n = not (even n)
negatief :: Int  Bool
negatief n = n < 0
Prelude: operatoren op lijsten
 “op kop van”
:
> 1 : [2, 3, 4]
[1, 2, 3, 4]
 “samenvoegen”
> [1, 2] ++ [3, 4, 5]
[1, 2, 3, 4, 5]
++
Prelude: functies op lijsten
 “leeg?”
null
> null [ ]
True
“allemaal waar?”
and
> and [ 1<2, 2<3, 1==0]
False
“neem deel”
> take 3 [2..10]
[2, 3, 4]
take
Functies als parameter
Pas functie toe op alle
elementen van een lijst
map
> map fac [1, 2, 3, 4, 5]
[1, 2, 6, 24, 120]
> map sqrt [1.0, 2.0, 3.0, 4.0]
[1.0, 1.41421, 1.73205, 2.0]
> map even [1 .. 6]
[False, True, False, True, False, True]
Gevallen onderscheiden
abs :: Int  Int
abs x | x>=0
| x<0
= x
= -x
“guards”
Herhalen
fac :: Int  Int
fac n
| n==0
| n>0
graag zonder
product te gebruiken
= 1
= n * fac (n-1)
“recursie”
Lijst-patronen
null :: [Int]  Bool
null [ ]
= True
null (x:xs) = False
head :: [Int]  Int
head (x:xs) = x
tail :: [Int]  [Int]
head (x:xs) = xs
Zelftest
Definieer de recursieve functie
sum
met patronen
met gevalsonderscheid d.m.v. guards
sum :: [Int]  Int
sum [ ]
= 0
sum (x:xs)
= x + sum xs
sum :: [Int]  Int
sum xs | null xs = 0
| True
= head xs + sum (tail xs)
Quiz (basisschool)
prioriteitsregel
5+3*2
16
11
associatief
5+3+2
10
10
links-associatief
55 -- 33 - 2
0
4
rechts-associatief
5^3^2
1252
59
machtsverheffen
Quiz (logica)
associatief
FTF
F
F
associatief
FTF
T
T
rechts-associatief
 FF
F  TT 
F
T
implicatie
Quiz (Haskell)
los element
op kop van lijst
rechts-associatief
associatief
x : y : zzs
x ++ y ++ z
lijsten samenvoegen
Quiz (Helium)
toepassen van
een functie
links-associatief
links-associatief
map
y z [1,2,3]
mapf fac
boven nn k
boven
Partieel parametriseren
Stel:
En dan:
plus :: Int  Int  Int
plus x y = x + y
drieMeer :: Int  Int
drieMeer = plus 3
> map drieMeer [1, 2, 3, 4, 5]
[4, 5, 6, 7, 8]
Partieel parametriseren
Omgekeerd: drieMeer = plus 3
drieMeer :: Int  Int
En dus:
rechts-associatief
plus :: Int  (Int  Int)
plus :: Int  Int  Int
“Curry-ing”
 Type
f :: Int  Bool  String
 Aanroep
> f 7 True
“hoi”
rechts-associatief
links-associatief

zonder
haakjes!
Currying
Schönfinkeling?
 Haskell B. Curry
(1900-1982)
 Grundlagen der
kombinatorischen
Logik (1930)
 M. Schönfinkel
Über die Bausteine der mathematischen Logik (1924)
Currying en map
> map fac [1, 2, 3, 4, 5]
[1, 2, 6, 24, 120]
> map (plus 3) [1, 2, 3, 4, 5]
[4, 5, 6, 7, 8]
> map (* 2) [1, 2, 3, 4, 5]
[2, 4, 6, 8, 10]
Hogere-ordefuncties
Functie met een functie
als parameter
map
filter
Functie met een functie
als resultaat
inverse
afgeleide
elke functie met >1 parameter!
Hogere-ordefuncties
 Een lijst langs lopen
en met elk element iets doen
map
 Een lijst langs lopen
en sommige elementen
selecteren
filter
map en filter
doe dit overal
> 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]
pak alleen deze
Publieksvraag
Schrijf een functie kleintjes
die getallen van een lijst oplevert
die kleiner zijn dan 10
kleintjes :: [Int]  [Int]
kleintjes xs = filter (<10) xs
ook partieel geparametriseerd!
Definitie van map
Geef een recursieve definitie:
map :: (ab)  [a]  [b]
map f [ ]
= []
map f (x:xs) = f x : map f xs
Definitie van filter
Geef een recursieve definitie,
en gebruik guards voor gevalsonderscheid
filter :: (aBool)  [a]  [a]
filter p [ ]
= []
filter p (x:xs) | p x = x : filter p xs
| True = filter p xs