Download de presentatie
De presentatie wordt gedownload. Even geduld aub
GepubliceerdHans Hendriks Laatst gewijzigd meer dan 9 jaar geleden
1
Functioneel programmeren Een snelle herhaling…
2
Functie-definitie static int kwad (int x) { return x*x ; } kwad x = x * x Haskell kwad :: Int Int
3
Functie-definitie static int fac (int n) { int tel, res; res = 1; for (tel=1; tel<=n; tel++) res *= tel; return res; } fac n = product [1..n] Haskell fac :: Int Int
4
Functies als parameter nPas 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]
5
Herhalen fac :: Int Int fac n = 1 = | n==0 | n>0 “recursie” n * fac (n-1) graag zonder product te gebruiken
6
Partieel parametriseren nStel: nEn 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]
7
Definitie van map nGeef een recursieve definitie: map :: (a b) [a] [b] map f [ ]= map f (x:xs)= [ ] map f xsf x :
8
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 +
9
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
10
Universele “lijst-totalisator” foldr :: [a] b foldr (#) e [ ] = foldr (#) e (x:xs)= e foldr (#) e xs x # (a b b) b zo combineren neutrale waarde
11
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
12
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
13
Anonieme functies > 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
Functies op lijsten > [4, 6, 1] ++ [2, 4] [4, 6, 1, 2, 4] (++) :: [a] [a] [a] [ ] ++ ys= ys (x:xs) ++ ys= x : (xs++ys)
16
Functies op lijsten > concat [ [3, 4, 5], [ ], [1, 2], [6] ] [3, 4, 5, 1, 2, 6] concat :: [[a]] [a] concat [ ]= [ ] concat (xs:xss)= xs ++ concat xss concat xss= foldr (++) [ ] xss
17
Oneindige lijsten repeat :: a [a] repeat x= x : repeat x > repeat 3 [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3 replicate :: Int a [a] replicate n x= take n (repeat x) > concat (replicate 5 ”info ” ) ”info info info info info ”
18
Lazy evaluation nParameters worden pas uitgerekend als ze echt nodig zijn nGeldt ook voor (:) dus alleen deel van een lijst dat echt nodig is wordt uitgerekend
19
Oneindige lijsten iterate :: (a a) a [a] iterate f x = x : iterate f (f x) > iterate ((+)1) 3 [3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
20
Lijst-comprehensies nNotatie uit de verzamelingenleer { x*x | x N, x<10 } > [ x*x | x [1..10], even x ] [4, 16, 36, 64, 100] > [ (x,y) | x [1,4,8], y ”ab” ] [ (1,’a’), (1,’b’), (4,’a’), (4,’b’), (8,’a’), (8,’b’) ]
21
Lijst-comprehensies nSpeciale notatie nbetekent hetzelfde als maar leest lekkerder dan [ expressie | x lijst, predicaat ] map (\x expressie ) (filter (\x predicaat) lijst )
22
Zelf datastructuren ontwerpen data Boom a = Blad | Tak a (Boom a) (Boom a) constructor functies het nieuwe type types van de parameters van de constructorfuncties
23
Opnieuw de lijst uitvinden data Lijst a = Nil | Cons a (Lijst a) constructor functies het nieuwe type types van de parameters van de constructorfuncties
24
Een datastructuur opschrijven nLijst nBoom [ ] 4 :3 :2 :1 : BladTak 2Blad Tak 4 Blad Blad Tak 7 ( ) ( ) Tak 5 (Tak 1 Blad Blad ) (Blad ) Tak 3 ( ) ( )
25
Functies op datastructuren nomvang ndiepte omvang :: Boom a Int omvang Blad = 0 omvang (Tak x li re) = 1 + omvang li + omvang re diepte :: Boom a Int diepte Blad = 0 diepte (Tak x li re) = 1 + max (diepte li) (diepte re)
Verwante presentaties
© 2024 SlidePlayer.nl Inc.
All rights reserved.