Functies definiëren nDoor combinatie van standaardfuncties fac :: Int  Int fac n = product [1..n] oneven :: Int  Bool oneven n = not (even n) negatief :: Int  Bool negatief n = n < 0

Functies uitrekenen nMet de interpretern Met de compiler module Stat where fac n = product [1..n] module Stat where fac n = product [1..n] main = fac 6 H:\> hi > :l Stat > fac H:\> helium Stat.hs H:\> lvmrun Stat 720

Gevallen onderscheiden abs :: Int  Int abs x = x = -x | x>=0 | x<0 “guards”

Herhalen fac :: Int  Int fac n = 1 = | n==0 | n>0 “recursie” n * fac (n-1) graag zonder product te gebruiken

Lijst-patronen null :: [Int]  Bool null [ ] = True null (x:xs) = False head :: [Int]  Int head (x:xs) = x tail :: [Int]  [Int] head (x:xs) = xs

Zelftest nDefinieer de recursieve functie umet patronen umet gevalsonderscheid d.m.v. guards sum sum :: [Int]  Int sum [ ] = 0 sum (x:xs)= x + sum xs sum :: [Int]  Int sum xs| null xs= 0 | True= head xs + sum (tail xs)

Quiz (basisschool) * 2 3 * ^ 3 ^ ^ 2 machtsverheffen prioriteitsregel associatief links-associatief rechts-associatief

Quiz (logica) F  T  F F F  T  F TT F  T  F T  F implicatie F associatief rechts-associatief TF

Quiz (Helium) x : y : z x ++ y ++ z y : zs los element op kop van lijst rechts-associatief associatief lijsten samenvoegen

Quiz (Helium) f y z boven n k links-associatief map fac [1,2,3] map fac boven n toepassen van een functie

Partieel parametriseren nStel: nEn dan: plus :: Int  Int  Int plus x y = x + y drieMeer :: Int  Int drieMeer = plus 3 > map drieMeer [1, 2, 3, 4, 5] [4, 5, 6, 7, 8]

Partieel parametriseren nOmgekeerd: nEn dus: plus :: Int  (Int  Int) drieMeer = plus 3 drieMeer :: Int  Int plus :: Int  Int  Int rechts-associatief

“Curry-ing” nType nAanroep f :: Int  Bool  String > f 7 True “hoi” f 7 Bool  String  rechts-associatief links-associatief zonder haakjes!

Currying nHaskell B. Curry ( ) nGrundlagen der kombinatorischen Logik (1930) nM. Schönfinkel Über die Bausteine der mathematischen Logik (1924) Schönfinkelin g?

Currying en map > map fac [1, 2, 3, 4, 5] [1, 2, 6, 24, 120] > map (plus 3) [1, 2, 3, 4, 5] [4, 5, 6, 7, 8] > map ((*) 2) [1, 2, 3, 4, 5] [2, 4, 6, 8, 10]

Hogere-ordefuncties nFunctie met een functie als parameter nFunctie met een functie als resultaat map inverse afgeleide elke functie met >1 parameter! filter

Hogere-ordefuncties nEen lijst langs lopen en met elk element iets doen nEen lijst langs lopen en sommige elementen selecteren map filter

map en filter > map even [1, 2, 3, 4, 5, 6] [False, True, False, True, False, True] > filter even [1, 2, 3, 4, 5, 6] [2, 4, 6] doe dit overal pak alleen deze

Publieksvraag nSchrijf een functie die getallen van een lijst oplevert die kleiner zijn dan 10 kleintjes kleintjes :: [Int]  [Int] kleintjes xs = filter ((>)10) xs (>) 10 x 10>x x<10 ook partieel geparametriseerd!

Definitie van map nGeef een recursieve definitie: map :: (a  b)  [a]  [b] map f [ ]= map f (x:xs)= [ ] map f xsf x :

Definitie van filter nGeef een recursieve definitie, en gebruik guards voor gevalsonderscheid filter :: (a  Bool)  [a]  [a] filter p [ ] = filter p (x:xs) = [ ] x : filter p xs | p x | True = filter p xs

Een ander soort lijst-functies product :: [Int]  Int product [ ]= product (x:xs)= 1 product xs x * and :: [Bool]  Bool and [ ]= and (x:xs)= True and xs x && sum :: [Int]  Int sum [ ]= sum (x:xs)= 0 sum xs x +

Universele “lijst-totalisator” foldr :: [a]  a foldr (#) e [ ] = foldr (#) e (x:xs)= e foldr (#) e xs x # (a  a  a)  a  zo combineren neutrale waarde

Had dat eerder gezegd... nAls foldr de generalisatie is van sum, product, en and.... n.... dan zijn sum, product, en and speciale gevallen van foldr product= foldr (*) 1 and= foldr (&&) True sum= foldr (+) 0 or= foldr (||) False

Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  a  a)  a  [a]  a [a] doe dit pak deze combineer zo

Andere hogere-ordefuncties until :: (a  Bool)  (a  a)  a  a begin hiermee doe dit totdat dit geldt > until ((<)1000) ((*)2) filter p f x = | p x | True = x (f x) until p f

Andere hogere-ordefuncties (.) ::    begin hiermee doe dit en dan dat > map (not. even) [1, 2, 3, 4, 5, 6] [1, 3, 5] (.) g f x = g (f x) a (a  b) (b  c) c (a  c)

Partieel parametriseren > map (plus 5) [1.. 5] [6, 7, 8, 9, 10] > until ((<)1000) ((*)2) > filter (not. even) [1.. 5] [1, 3, 5]

Partieel parametriseren > map f [1.. 4] where f x = x*x + 3*x + 2 [6, 12, 20, 30] > map f [1.. 4] [6, 12, 20, 30] ( \ x  x*x+3*x+2 )

Lambda-expressies x*x + 3*x + 2 expressie waar x vrij in voorkomt \ x  de functie die die expressie uitrekent

Lambda ? x. x*x + 3*x + 2    x. x*x + 3*x + 2 x. x*x + 3*x + 2 (LAMBDA x)( x*x + 3*x + 2 ) \ x  x*x + 3*x + 2 \ x -> x*x + 3*x + 2

Toepassing: priemgetallen deelbaar :: Int  Int  Bool deelbaar t n = (t/n)*n == t delers :: Int  [Int] delers x = filter (deelbaar x) [2..x-1] priem :: Int  Bool priem x = null (delers x) priem = null. delers priemgetallen :: [Int] priemgetallen = filter priem [ ]

Toepassing: dag van de week > dag “dinsdag” dag d m j = weekdag (nummer d m j) weekdag 0 = “zondag” weekdag 1 = “maandag” weekdag 2 = “dinsdag” etc.

Toepassing: dag van de week nummer d m j = ( ( j-1) * ( j-1) / 4 - ( j-1) / ( j-1) / sum (take (m-1) (ms j)) + d ) `rem` 7 elk jaar 1 dag later, want 365 = 52*7+1

Toepassing: dag van de week ms j = [ 31, feb, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ] where feb | schrik j = 29 | True = 28 schrik j | deelb j 100 = deelb j 400 | True = deelb j 4

Toepassing: differentiëren diff :: (Float  Float)  (Float  Float) diff :: (Float  Float)  Float  Float diff f x = ( f (x+h) – f (x) ) / h where h =

Toepassing: nulpunt nulpunt :: (Float  Float)  Float nulpunt f = until ok verbeter 1.0 where ok x =... verbeter x =...

Methode van Newton b f b b-d d = f(b) / f’(b) verbeter b = b – f b / diff f b ok b = abs (f b) <

Toepassing: inverse wortel a = nulpunt (\x  x*x – a) arcsin a= nulpunt (\x  sin x – a) log a= nulpunt (\x  exp x – a) inverse :: (Float  Float)  (Float  Float) inverse f a = nulpunt (\x  f x – a)

Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  a  a)  a  [a]  a [a] doe dit pak deze combineer zo

Currying nType nAanroep f :: Int  Bool  String > f 7 True “hoi” f 7 Bool  String  rechts-associatief links-associatief zonder haakjes!