Polymorf zoeken

zoek :: (aaBool) [ (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

Schrijf 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 tespecificeren operator

zipWith

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

Zelf datastructuren ontwerpen

data Boom a = Blad | Tak a (Boom a) (Boom a)

constructorfuncties

het nieuwetype

types van de parameters van de constructorfuncties

Blad:: Boom aTak :: a Boom a

Boom a Boom a

Functies op datastructuren

Lijst

Boom

length :: [a] Intlength [ ] = 0length (x:xs) = 1 + length xs

omvang :: Boom a Intomvang Blad = 0omvang Tak x li re

= 1 + omvang li + omvang reconstructor

functies

Insert in een zoekboom

insert :: (aaOrd) a Boom a Boom a

insert cmp e Blad = insert cmp e (Tak x li re) =

Tak e Blad Bladcmp e xf ( )

where f LT =f _ =

Tak x (insert cmp e li) reTak x li (insert cmp e re)

Toepassing: Breuken

type Breuk = (Int, Int)3

4

maal :: Breuk Breuk Breukplus :: Breuk Breuk Breukeq :: Breuk Breuk Booleenvoud :: Breuk Breuk

3

4

6

5

1

2

2

4

Breuken vermenigvuldigen

Teller en noemervermenigvuldigen

3

4

6

5*

18

20=

maal :: Breuk Breuk Breukmaal (x,y) (p,q) = (x*p, y*q)

Breuken optellen

Eerst gelijknamig maken

1

4

3

10+

22

40=

plus :: Breuk Breuk Breukplus (x,y) (p,q) = (x*q+y*p, y*q)

10

40

12

40+ =

Breuken vergelijken

Kruiselings vermenigvuldigen

2

8

3

12= = True

eq :: Breuk Breuk Boolmaal (x,y) (p,q) = x*q == y*p

Toepassing: Polynomen

type Term = (Float, Int)type Poly = [Term]

3.5x4 + 6.1x2 + 2.5

maal :: Poly Poly Polyplus :: Poly Poly Polyeq :: Poly Poly Booleenvoud :: Poly Poly

Polynomen optellen

Samenvoegen envereenvoudigen

+ =

plus :: Poly Poly Polyplus p q = eenvoud (p ++ q)

3x4 + 4x2 2x2 + 1 3x4 + 4x2 + 2x2 + 1

3x4 + 6x2 + 1

Polynomen vereenvoudigen

Sorteren op exponenttermen met gelijke exponent samenvoegen

=

eenvoud :: Poly Poly eenvoud =

3x4 + 4x2 +2x3 + x2+ 1 3x4 + 5x2 + 2x3 + 1

sorterensamenvoegen .verw0 .

Polynomen vereenvoudigen

eenvoud :: Poly Poly eenvoud = verw0 . samen . sorteren

sorteren = isort ordwhere ord :: Term Term Ordering

ord (c1,e1) (c2,e2) = ordInt e1 e2samen ((c1,e1):(c2,e2):ts) | e1==e2 = samen ((c1+c2,e1):ts)| True = (c1,e1) : samen ((c2,e2):ts)samenv ts = tsverw0 = filter ( \(c,e) c/=.0.0 )

Polynomen vermenigvuldigen

Alle termen met elkaar vermenigvuldigen

* =

maal :: Poly Poly Polymaal p q = eenvoud (cross tMaal p q)

3x + 1 2x2 + 5 6x3+15x + 2x2+5

tMaal :: Term Term TermtMaal (c1,e1) (c2,e2) = (c1*.c2, e1+e2)

Kruisproduct

Met lijstcomprehensie

Met expliciete recursie

cross :: (aab) [a] [a] [b]cross f xs ys = [ f x y | x xs, yys ]

cross f [ ] ys =cross f (x:xs) ys =

[ ]map (f x) ys++cross f xs ys

Ontwerp van functiesop lijsten

Combineer standaardfuncties

Herken je een , , of zoiets?Schrijf dan eerst de hulpfunctie

Gebruik expliciete recursie

map filter foldr

f [ ] = ...f (x:xs) = ... f xs ...

Voorbeeld 1

Een string afpassen op een gegeven lengte

afkappen, ofaanvullen met spaties

precies :: Int String Stringprecies n s | n < len = | n == len = | n > len =where len = length s

take n sss ++ replicate (n-len) ’_’

Voorbeeld 2

Een 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

Strings 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

Kolommen 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 elementen2 rijen van elk 5 elementen 5 rijen van elk 2 elementen1 rij van elk 5 elementen 5 rijen van elk 1 element

0 rijen van elk 5 elementen 5 rijen van elk 0 elementenveel veel

oneindig

repeat [ ]

wissel = foldr ... ...

Aanloop

1 2 3 4

1

aanloop ( x : xs )

= (aanloop xs)xmap ((:) )

[ ] [1,2,3,4][1,2,3][1,2][1]

[ ] [2,3,4][2,3][2]

[ ] :

:: [a] [[a]]