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’ ’;’

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

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”

> groepeer 2 [[1,2,3,4,5,6,7], [3,4,5,6,7], [5,6,7], [7] ] [[1,2,3,4,5,6,7], [3,4,5,6,7], [5,6,7], [7], [], [], [], [] [1,2,3,4,5,6,7] [[1,2], [3,4], [5,6], [7]] groepeer n =. Zelftest iterate (drop n) takeWhile (not.null) map (take n) groepeer :: Int  [a]  [[a]]

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

Type-definities nIntroduceert een nieuw type uin de prelude uin je eigen programma type String = [Char] type Punt = (Float,Float)

Functies met patronen nFuncties op lijsten nFuncties op tupels head:: [a]  a tail :: [a]  [a] head (x:xs) = x tail (x:xs) = xs fst:: (a, b)  a snd :: (a, b)  b fst (x, y) = x snd (x, y) = y

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

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

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

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

Lijst-comprehensies nSpeciale notatie nbetekent hetzelfde als maar leest lekkerder dan [ expressie | x  lijst, predicaat x ] map (\x  expressie ) (filter (\x  predicaat) lijst )

Datastructuren nLijst uleeg ukop en staart [ ] :: [a] (:):: a  [a]  [a]

Nieuwe Datastructuren nDing uleeg ukop en twee staarten Leeg:: Ding a Split:: a  Ding a  Ding a  Ding a

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

Een datastructuur opschrijven nLijst nBoom [ ] 4 :3 :2 :1 : BladTak 2Blad Tak 4 Blad Blad Tak 7 ( ) ( ) Tak 5 (Tak 1 Blad Blad ) (Blad ) Tak 3 ( ) ( )

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

Boomstructuur blad diepte 14

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

Zoekboom links is kleiner rechts is groter

Zoekboom ? zoek kleiner? linksaf! groter? rechtsaf!

Zoeken in een zoekboom zoek :: (a  a  Ord)  a  Boom a  Bool zoek cmp e Blad= zoek cmp e (Tak x li re)= False cmp e xf ( ) wheref EQ = f LT = f GT = True zoek cmp e li zoek cmp e re

Zoekboom insert zoek maak nieuw hok 16

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)

Labels van een boom > labels testboom [1,3,4,5,6,8,10,11,14,15,16,18,23,26,29,34]

Labels van een boom labels :: Boom a  [a] labels Blad= labels (Tak x li re)= [ ] [x] labels li ++ labels re treeSort :: (a  a  Ord)  [a]  [a] treeSort cmp = labels. foldr (insert cmp) Blad

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

Opnieuw de lijst uitvinden data Lijst a = Nil | Cons a (Lijst a) constructor functies het nieuwe type types van de parameters van de constructorfuncties

Zelf datastructuren ontwerpen data MayBe a = No | Yes a constructorfuncties niet recursief het nieuwe type

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

Datastructuren nTupel(a,b) nLijst[a] nZelfgemaaktBoom a met constructorfuncties type String = [Char] data Boom a = Blad | Tak a (Boom a) (Boom a)