Polymorf zoeken zoek :: (a  a  Bool)  [ (a, b) ]  a  b zoek eq [ ] x = ??? zoek eq ((a,b):ts) x | eq a x = b | otherwise = zoek eq ts x MayBe b No Yes b

Zelftest nSchrijf de functie (definitie en type) die overeenkomstige elementen van twee lijsten koppelt > zipWith (+) [1, 2, 3] [4, 5, 6, 7] [5, 7, 9] met een nader te specificeren operator zipWith

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’) ]

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 Blad:: Boom a Tak:: a  Boom a  Boom a  Boom a

Functies op datastructuren nLijst nBoom length :: [a]  Int length [ ] = 0 length (x:xs) = 1 + length xs omvang :: Boom a  Int omvang Blad = 0 omvang Tak x li re = 1 + omvang li + omvang re constructor functies

Insert in een zoekboom insert :: (a  a  Ord)  a  Boom a  Boom a insert cmp e Blad= insert cmp e (Tak x li re)= Tak e Blad Blad cmp e xf ( ) wheref LT = f _ = Tak x (insert cmp e li) re Tak x li (insert cmp e re)

Toepassing: Breuken type Breuk = (Int, Int) 3434 maal:: Breuk  Breuk  Breuk plus:: Breuk  Breuk  Breuk eq:: Breuk  Breuk  Bool eenvoud :: Breuk  Breuk

Breuken vermenigvuldigen nTeller en noemer vermenigvuldigen * = maal:: Breuk  Breuk  Breuk maal (x,y) (p,q) = (x*p, y*q)

Breuken optellen nEerst gelijknamig maken = plus:: Breuk  Breuk  Breuk plus (x,y) (p,q) = (x*q+y*p, y*q) =

Breuken vergelijken nKruiselings vermenigvuldigen == True eq:: Breuk  Breuk  Bool maal (x,y) (p,q) = x*q == y*p

Toepassing: Polynomen type Term= (Float, Int) type Poly= [Term] 3.5x x maal:: Poly  Poly  Poly plus:: Poly  Poly  Poly eq:: Poly  Poly  Bool eenvoud :: Poly  Poly

Polynomen optellen nSamenvoegen en vereenvoudigen + = plus:: Poly  Poly  Poly plus p q = eenvoud (p ++ q) 3x 4 + 4x 2 2x x 4 + 4x 2 + 2x x 4 + 6x 2 + 1

Polynomen vereenvoudigen nSorteren op exponent termen met gelijke exponent samenvoegen = eenvoud:: Poly  Poly eenvoud = 3x 4 + 4x 2 +2x 3 + x x 4 + 5x 2 + 2x sorteren samenvoegen.verw0.

Polynomen vereenvoudigen eenvoud :: Poly  Poly eenvoud = verw0. samen. sorteren sorteren = isort ord whereord :: Term  Term  Ordering ord (c1,e1) (c2,e2) = ordInt e1 e2 samen ((c1,e1):(c2,e2):ts) | e1==e2 = samen ((c1+c2,e1):ts) | True = (c1,e1) : samen ((c2,e2):ts) samenv ts = ts verw0 = filter ( \(c,e)  c/=.0.0 )

Polynomen vermenigvuldigen nAlle termen met elkaar vermenigvuldigen * = maal:: Poly  Poly  Poly maal p q = eenvoud (cross tMaal p q) 3x + 12x x 3 +15x + 2x 2 +5 tMaal :: Term  Term  Term tMaal (c1,e1) (c2,e2) = (c1*.c2, e1+e2)

Kruisproduct nMet lijstcomprehensie nMet expliciete recursie cross :: (a  a  b)  [a]  [a]  [b] cross f xs ys = [ f x y | x  xs, y  ys ] cross f [ ] ys= cross f (x:xs) ys= [ ] map (f x) ys ++ cross f xs ys

Ontwerp van functies op lijsten nCombineer standaardfuncties nHerken je een,, of zoiets? Schrijf dan eerst de hulpfunctie nGebruik expliciete recursie mapfilterfoldr f [ ] =... f (x:xs) =... f xs...

Voorbeeld 1 nEen string afpassen op een gegeven lengte afkappen, of aanvullen met spaties precies :: Int  String  String precies n s | n < len= | n == len= | n > len= where len = length s take n s s s ++ replicate (n-len) ’_’

Voorbeeld 2 nEen heleboel strings afpassen op lengte > evenlang 4 [ ”aap”, ”noot”, ”weide” ] [ ”aap_”, ”noot”, ”weid” ] evenlang :: Int  [String]  [String] evenlang n xs = map f xs where f x = precies n x evenlang n xs = map (precies n) xs

Voorbeeld 3 nStrings even lang maken zonder afkappen > uniform [ ”aap”, ”noot”, ”weide” ] [ ”aap__”, ”noot_”, ”weide” ] uniform :: [String]  [String] uniform xs = evenlang n xs where n = maximum (map length xs)

Voorbeeld 4 nKolommen afpassen in blok van strings > unikol [[ ” aap ”,” noot ”,” mies ” ], [ ” wim ”,” zus ”,” jet ” ], [ ” weide ”,” hok ”,” schapen ”] ] [[ ” aap__ ”,” noot ”,” mies___ ” ], [ ” wim__ ”,” zus_ ”,” jet____ ” ], [ ” weide ”,” hok_ ”,” schapen ” ] ]

Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol xss= map uniform xss

Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol xss= map uniform xss

Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol =

Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol = wissel

Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol = map uniform. wissel

Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol = wissel. map uniform. wissel

Wissel [1, 2][3, 4][5, 6][7, 8] [1, 3, 5, 7] [2, 4, 6, 8] [3, 5, 7] [4, 6, 8] [1, 2] wissel ( xs : xss ) = (wissel xss) xs zipWith (:)

Wissel wissel (xs : xss) = zipWith (:) xs (wissel xss) wissel [ ] = 3 rijen van elk 5 elementen  5 rijen van elk 3 elementen 2 rijen van elk 5 elementen  5 rijen van elk 2 elementen 1 rij van elk 5 elementen  5 rijen van elk 1 element 0 rijen van elk 5 elementen  5 rijen van elk 0 elementen veel oneindig repeat [ ] wissel = foldr......

Aanloop aanloop ( x : xs ) = (aanloop xs) x map ((:) ) [ ][1,2,3,4][1,2,3][1,2][1][ ][2,3,4][2,3][2] [ ] : :: [a]  [[a]]