Imperatief programmeren nProgramma bestaat uit nRunnen is opdrachten gegroepeerd in methoden één voor één uitvoeren te beginnen met main

Functioneel programmeren nProgramma bestaat uit nRunnen is functie-definities uitrekenen van een expressie

Logisch programmeren nProgramma bestaat uit nRunnen is predicaat-definities proberen te vervullen van een predicaat

Functie-definitie static int kwad (int x) { return x*x ; } kwad x = x * x Haskell kwad :: Int  Int

Gebruik van de functie public static void main(String [ ] ps) { System.out.println( this.kwad(5) ); } main = kwad 5 Haskell main :: Int

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

Prelude: operatoren op lijsten n “op kop van” n “samenvoegen” : ++ > 1 : [2, 3, 4] [1, 2, 3, 4] > [1, 2] ++ [3, 4, 5] [1, 2, 3, 4, 5]

Prelude: functies op lijsten n “leeg?” n“allemaal waar?” n“neem deel” null and > null [ ] True > and [ 1<2, 2<3, 1==0] False take > take 3 [2..10] [2, 3, 4]

Functies als parameter nPas functie toe op alle elementen van een lijst map > map fac [1, 2, 3, 4, 5] [1, 2, 6, 24, 120] > map sqrt [1.0, 2.0, 3.0, 4.0] [1.0, , , 2.0] > map even [1.. 6] [False, True, False, True, False, True]

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 (Haskell) 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önfinkeling?

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