Funktionen höherer Ordnung

Transkript

1 Eine Funktion wird als Funktion höherer Ordnung bezeichnet, wenn Funktionen als Argumente verwendet werden, oder wenn eine Funktion als Ergebnis zurück gegeben wird. Beispiel: twotimes :: ( a -> a ) -> a -> a twotimes f x = f ( f x ) Anwendung: twotimes quadrat 3 => quadrat (quadrat 3) => 81

2 Typische Beispielsfunktion: map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x : map f xs map f [2, 3, 6, 0] => [f(2), f(3), f(6), f(0)] Die Funktion f wird auf jedes Element der Liste angewendet map (^2) [2, 3, 6, 0] => [4, 9, 36, 0]

3 Die filter-funktion Die filter-funktion soll aus einer Liste nur die Elemente auswählen, die eine bestimmte Bedingung erfüllen. Beispiel: filter (<3) [2,5,0,1,7] => [2,0,1]

4 Die filter-funktion 1. Definition: filter :: (a -> Bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) Bedingung p x = x : filter p xs otherwise = filter p xs

5 takewhile-funktion So lange eine Bedingung erfüllt wird, werden Elemente aus einer Liste genommen. takewhile :: (a Bool) [a] [a] takewhile p [] = [] takewhile p (x:xs) p x = x : takewhile p xs otherwise = [] Beispiel: takewhile (<9) [2, 5, 7, 9, 11] => [2, 5, 7]

6 dropwhile-funktion So lange eine Bedingung erfüllt wird, werden Elemente aus einer Liste gelöscht. dropwhile :: (a Bool) [a] [a] dropwhile p [] = [] dropwhile p (x:xs) p x = dropwhile p xs otherwise = x:xs Beispiel: dropwhile isspace " Hello" => "Hello"

7 zip-funktion zip :: [a] [b] [(a,b)] zip (x:xs) (y:ys) = (x,y) : zip xs ys zip = [] Die zip-funktion kombiniert die Elemente aus zwei Listen und liefert eine Liste von Tupeln zurück. Beispiel: zip [1..] ["abcd"] [(1,'a'), (2,'b'), (3,'c'), (4,'d')]

8 zipwith-funktion Die zipwith-funktion bekommt zwei Listen und eine Funktion als Parameter und berechnet eine neue Liste, indem jeweils die Elemente der beiden Listen mit der angegebenen Funktion verknüpft werden. zipwith :: (a -> b -> c) -> [a] -> [b] -> [c] zipwith f (x:xs) (y:ys) = (f x y):(zipwith f xs ys ) zipwith f = [] Beispiel: zipwith (^) [1, 2, 3] [0, 3, 2] [1, 8, 9]

9 Arithmetische Sequenzen Mit Hilfe des.. Operators lassen sich in Haskell sehr elegant Zahlensequenzen erzeugen. [ ] => [1,2,3,4,5] [ 0, ] => [ 0, 5, 10, 15, 20 ] [ 10, ] => [ 10, 8, 6, 4, 2, 0 ] [ ] => [] [ 1.. ] => unendliche Liste take 5 [2, 0.. ] => [ 2, 0, -2, -4, -6 ]

10 Eine andere Definition der map-funktion mit Listen-Generatoren ist: map :: (a -> b) -> [a] -> [b] map f xs = [ f x x<-xs ] Anwendung: map length ["Eins", "Zwei", "Drei", "Vier"] => [4, 4, 4, 4]

11 Listen-Generatoren Die Syntax von Listengeneratoren in Haskell ist sehr ähnlich zu dem, was wir für die Definition von Mengen in der Mathematik kennen. Mathematik: { x x { }, (x mod 3) = 0 } { } x x Ν, x Menge aller Zahlen, die genau durch 3 geteilt werden können

12 Listen-Generatoren Haskell: [ x x <- [1.. 20], (mod x 3)==0 ] damit gibt man Haskell die Anweisung, eine Liste zu bilden aus allen Elementen, die genau durch 3 geteilt werden können: sollen dabei mehrere Bedingungen erfüllt werden, so müssen diese durch Komma getrennt sein. Im Unterschied zu der mathematischen Definition von Mengen können Haskell-Listen sich wiederholende Elemente beinhalten.

13 Listen-Generatoren Allgemeine Form: [ body qualifiers ] Beispiele: [ n*n n <- [1..100] ] factors n = [ i i <- [1..n], (n `mod` i) == 0 ] 2. Definition der filter-funktion: filter :: (a -> Bool) -> [a] -> [a] filter p xs = [ x x <- xs, p x ]

14 Sieb des Eratosthenes 3. Jahrhundert v. Chr. Das Sieb des Eratosthenes ist ein sehr bekannter Algorithmus, der für ein vorgegebenes N alle Primzahlen findet, die kleiner gleich N sind. Der Algorithmus verwendet ein Feld p aus booleschen Werten, mit dem Ziel, dem Element p[i] den Wert 1 zuzuweisen, falls i eine Primzahl ist, und anderenfalls den Wert 0. Ziel: P P P P P P

15 Anfang: Sieb des Eratosthenes

16 Sieb des Eratosthenes nicht mehr! N nur bis N/2 noch besser ist nur bis 2 N

17 Sieb des Eratosthenes

18 Listen-Generatoren primzahlen :: Integer [Integer] primzahlen n = sieb [2..n] where sieb [] = [] sieb (p:xs) = p: sieb [k k<-xs, k `mod` p>0] primzahlen :: Integer [Integer] primzahlen = sieb [2..] where sieb (p:xs) = p:sieb[k k<-xs, k `mod` p>0]

19 all-funktion Entscheidet, ob alle Elemente einer Liste eine gegebene Bedingung erfüllen. all :: (a Bool) [a] Bool all p xs = and [p x x xs] Beispiel: all even [2,4,6,8] => True all (==3) [3,4,3,0,3] => False

20 any-funktion Entscheidet, ob mindestens ein Element einer Liste eine gegebene Bedingung erfüllt. any :: (a Bool) [a] Bool any p xs = or [p x x xs] Beispiel: any even [2,3,6,8] => True any (==3) [3,4,3,0,3] => True