Hogere-ordefuncties nVoeg de elementen van een lijst samen nCombineer twee functies foldr :: (a  b  b)  b  [a]  b [a] (.) :: (b  c)  (a  b)  a.

Presentatie over: "Hogere-ordefuncties nVoeg de elementen van een lijst samen nCombineer twee functies foldr :: (a  b  b)  b  [a]  b [a] (.) :: (b  c)  (a  b)  a."— Transcript van de presentatie:

1 Hogere-ordefuncties nVoeg de elementen van een lijst samen nCombineer twee functies foldr :: (a  b  b)  b  [a]  b [a] (.) :: (b  c)  (a  b)  a  c (a  c) combineer zo begin hiermee “na”

2 Lambda-expressies x*x + 3*x + 2 expressie waar x vrij in voorkomt \ x  de functie die die expressie uitrekent > map f [1.. 4] [6, 12, 20, 30] ( \ x  x*x+3*x+2 )

3 Zelftest nStel je schrijft een functie f die werkt op lijsten. Wat kun je routinematig alvast opschrijven? uals je recursie gebruikt, en gevalsonderscheid doet met patronen uals je recursie gebruikt, en gevalsonderscheid doet met guards uals je een hogere-ordefunctie (welke?) partieel parametriseert f

4 f ::....  [a] .... evt. extra parameters Functies op lijsten nBedenk eerst het type! resultaat nRecursie met patronen f [ ]=.... f (x:xs)=....x....f xs.... nRecursie met guards f xs| null xs =.... | True =....f (tail xs).. nZonder recursie f xs = foldr op e xs filter p map g

5 Functies op lijsten (++) :: [a]  [a]  [a] concat:: [[a]]  [a] head, last:: [a]  a tail, init:: [a]  [a] take, drop:: Int  [a]  [a] takeWhile:: (a  Bool)  [a]  [a] eqList:: (a  a  Bool)  [a]  [a]  Bool

6 Lijsten polymorf vergelijken nExtra functie meegeven eqList :: (a  a  Bool)  [a]  [a]  Bool eqList eq [ ][ ] = eqList eq [ ](y:ys) = eqList eq (x:xs)[ ] = eqList eq (x:xs)(y:ys) = True False eq x y && eqList eq xs ys

7 Lijsten vergelijken > eqList (==) [1,2,3] [1,2,3] True > eqList eqBool [True,False] [True] False > eqList (eqList (==)) [[1,2], [3,4]] [[1,2], [4,3]] False

8 Ordering nOrdering type met 3 elementen ordInt :: Int  Int  Ordering ordInt x y| x < y= LT | x==y= EQ | x > y= GT

9 Lexicografische ordening nLijsten kun je ordenen zoals woorden in een woordenboek ordList :: (a  a  Ord)  [a]  [a]  Ord > ordList ordInt [1, 2, 3] [1, 2, 4] LT > ordList ordInt [1, 3, 2] [1, 2, 4] GT

10 Lexicografische ordening ordList :: (a  a  Ord)  [a]  [a]  Ord ordList ord [ ][ ] = ordList ord [ ](y:ys) = ordList ord (x:xs)[ ] = ordList ord (x:xs)(y:ys) = EQ LT GT f (ord x y) wheref LT = f EQ = f GT = f (....) wheref.... LT ordList ord xs ys GT

11 Invoegen in een geordende lijst insert :: (a  a  Ord)  a  [a]  [a] insert ord e [ ]= [e] insert ord e (x:xs)= f (ord e x) wheref LT= e : x : xs f _= x : insert ord e xs isort :: (a  a  Ord)  [a]  [a] isort ord [ ]= [ ] isort ord (x:xs)= insert ord x (isort ord xs) isort ord = foldr (insert ord) [ ]

12 Geordende lijsten samenvoegen merge :: (a  a  Ord)  [a]  [a]  [a] merge ord [ ] ys= ys merge ord xs [ ]= xs merge ord (x:xs) (y:ys)= f (ord x y) wheref LT= x : merge ord xs (y:ys) f _= y : merge ord (x:xs) ys > merge ordInt [1, 3, 4] [2, 5, 6] [1, 2, 3, 4, 5, 6]

13 Primitieve types nIntgehele getallen nFloatgetallen met decimale punt nBoolTrue False nOrderingLT EQ GT nChar’a’ ’b’ ’A’ ’2’ ’#’

14 Char: lettertekens nConstanten nVergelijken nConversie ’a’ ’A’ ’1’ ’@’ ’;’ eqChar :: Char  Char  Bool ordChar:: Char  Char  Ordering ord :: Char  Int chr:: Int  Char

15 String: lijst charcters nConstanten ”hoi” ”CKI” ”a12#” > map ord ”CKI” [67, 75, 73] eqString :: String  String  Bool eqString= eqList eqChar > eqString ”CKI” (map toUpper ”cki”) True

16 Functies op Strings words:: String  [String] unwords:: [String]  String > words ”dit is een zin” [ ”dit”, ”is”, ”een”, ”zin” ] > unwords [”dit”, ”zijn”, ”losse”, ”woorden”] ”dit zijn losse woorden”

17 unwords en words unwords[ ]= unwords[w]= unwords(w:ws)= words[ ]= wordscs= where eerste= rest= [ ] w w ++ ” ” ++ unwords ws [ ] eerste : words rest takeWh (not.isSp) cs dropWh (not.isSp) cs dropWh isSp ( )

18 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 ”CKI ” ) ”CKI CKI CKI CKI CKI ”

19 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

20 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

21 5678 [5678, 567, 56, 5, 0, 0, [5678, 567, 56, 5] [8, 7, 6, 5] [5, 6, 7, 8] [’5’, ’6’, ’7’, ’8’] int2string = f5.f4.f3.f2.f1 where f1 = f2 = f3 = f4 = f5 = Functies combineren iterate (\x  x/10) takeWhile ((/=)0) map (\x  x-10*(x/10)) reverse map (\x  chr(x+48)) ”5678”

22 Datastructuren nLijst variabel aantal hetzelfde type nTupel vast aantal verschillend type rij :: [Int] rij = [1, 2, 3, 4, 5] paar:: (Int, String) paar = (3, ”hoi”)

23 Lijst van tupels telefoonboek :: [ (String, Int) ] telefoonboek = [ (”Jeroen”, 4118), (”Bastiaan”, 2585), (”Jur”, 3283), (”Arjan”, 1012) ] zoek :: [ (String, Int) ]  String  Int > zoek telefoonboek ”Bastiaan” 2585

24 Zoek in lijst van tupels zoek :: [ (String, Int) ]  String  Int zoek [ ] vraag = 0 zoek ( t : ts ) vraag > zoek telefoonboek ”Bastiaan” 2585 | eqString vraag naam = nr | otherwise = zoek ts vraag (naam,nr)

25 Char en String nCharéén letter uord ::Char  Int uchr ::Int  Char nString[Char] uwords :: String  [String] uunwords :: [String]  String ”hoi” ”CKI” ”a12#” ’a’ ’A’ ’1’ ’@’ ’;’

26 Oneindige lijsten nOneindige lijst nLazy evaluation: oneindige lijst als tussenresultaat antwoord toch in eindige tijd repeat :: a  [a] repeat x= x : repeat x