Functioneel programmeren

1 / 25

# Functioneel programmeren - PowerPoint PPT Presentation

##### Functioneel programmeren

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Functioneel programmeren Een snelle herhaling…

2. kwad x = x * x Haskell Functie-definitie static int kwad (int x) { return x*x ;} kwad :: Int  Int

3. static int fac (int n) { int tel, res; res = 1; for (tel=1; tel<=n; tel++) res *= tel; return res; } Haskell Functie-definitie fac n = product [1..n] fac :: Int  Int

4. Functies als parameter • Pas functie toe op alleelementen 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 | n==0 | n>0 = 1 = fac (n-1) n * graag zonder product te gebruiken “recursie”

6. Partieel parametriseren plus :: Int  Int  Int plus x y = x + y • Stel: • En dan: drieMeer :: Int  Int drieMeer = plus 3 > map drieMeer [1, 2, 3, 4, 5] [4, 5, 6, 7, 8]

7. Definitie van map • Geef een recursieve definitie: map :: (ab) [a]  [b] [ ] map f [ ] =map f (x:xs) = f x : map f xs

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

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

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

11. Had dat eerder gezegd... • Als foldr de generalisatie isvan sum, product, en and .... • .... dan zijn sum, product, en andspeciale gevallen van foldr product = foldr (*) 1 and = foldr (&&) True sum = foldr (+) 0 or = foldr (||) False

12. Hoger-ordefuncties op lijsten • Doorloop een lijst en ... map :: (ab) [a]  [b] filter :: (aBool) [a]  [a] foldr :: (abb)  b  [a]  b [a] [a] [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] ( \ x  x*x+3*x+2 ) > map f [1 .. 4] [6, 12, 20, 30]

14. Lambda-expressies expressie waarx vrij in voorkomt x*x + 3*x + 2 \ x  de functie die dieexpressie 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 • Parameters worden pas uitgerekendals ze echt nodig zijn • Geldt ook voor (:)dus alleen deel van een lijstdat echt nodig iswordt 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 • Notatie 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 • Speciale notatie • betekent hetzelfde alsmaar leest lekkerder dan [ expressie | x  lijst , predicaat ] map (\xexpressie ) (filter (\xpredicaat) lijst )

22. Zelf datastructuren ontwerpen het nieuwetype dataBoom a = Blad | Tak a (Boom a) (Boom a) constructorfuncties types van de parameters van de constructorfuncties

23. Opnieuw de lijst uitvinden het nieuwetype dataLijst a = Nil | Cons a (Lijst a) constructorfuncties types van de parameters van de constructorfuncties

24. Een datastructuur opschrijven • Lijst • Boom [ ] 1 : 2 : 3 : 4 : Tak 3 ( ) ( ) Tak 7 ( ) ( ) Tak 4 Blad Blad Tak 2 Blad Blad Tak 5 (Tak 1 Blad Blad ) (Blad )

25. Functies op datastructuren omvang :: Boom a  Int omvang Blad = 0 omvang (Tak x li re) = 1 + omvang li + omvang re • omvang • diepte diepte :: Boom a  Int diepte Blad = 0 diepte (Tak x li re) = 1 + max (diepte li) (diepte re)