1 / 25

Functioneel programmeren

Functioneel programmeren. Een snelle herhaling…. kwad x = x * x. Haskell. Functie-definitie. static int kwad (int x) { return x*x ; }. kwad :: Int  Int. static int fac (int n) { int tel, res; res = 1; for (tel=1; tel<=n; tel++) res *= tel; return res; }.

emerson-sloan
Download Presentation

Functioneel programmeren

An Image/Link below is provided (as is) to download presentation 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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

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)

More Related