Funktionen höherer Ordnung. 3. Dezember 2014

Transkript

1 höherer Ordnung Universität Bielefeld AG Praktische Informatik 3. Dezember 2014

2 höherer Ordnung Worum geht es heute? In Haskell gibt es, die als Argument haben oder als Ergebnis liefern. Diese nennt man höherer Ordnung. Davon kennen wir bisher Beispiele wie map oder (.) Was man insgesamt damit machen kann, ist damit noch lange nicht erschöpft...

3 als Bürger erster Klasse definieren kann man in jeder Programmiersprache. Eine funktionale Programmiersprache erlaubt auch in Datenstrukturen, z.b. [(+), (-), (*)] als Argmente, z.b. map square [1..100] als Ergebnisse, z.b. f. g

4 Wie entstehen? Benannte werden vom Programmierer definiert. Unbenannte (engl. anonymous functions) entstehen durch teilweise Anwendung benannter, z.b. (3+), ( div 2), ("niemals"++) map reverse Note ce ( Note (1/4)) map (1) all_equal 3 4 (Natürlich kann man diesen anonymen dann auch Namen geben startnie = ("niemals"++)) durch Verknüpfung von, z.b. reverse. concat oder durch...

5 Abstraktion Abstraktion verwandelt einen Ausdruck in eine Funktion 3 a b ist ein Ausdruck λa b 3 a b ist eine Funktion von a und b (λa b 3 a b 2 + 5)(2, 3) ist eine Funktionsanwendung und berechnet den Wert 2 Abstraktion Vom konkreten zum Allgemeinen Dur3Klang cdur3kl = Note ce (1/4) + Note eh (1/4) + Note ge (1/4) versus dur3kl = \(t,d) -> Note t d + Note (t+4) d + Note (t+7) d Auf der rechten Seite der Gleichung steht eine anonyme Funktion (die links einen Namen bekommt)

6 Man nennt sie... Abstractions Ausdrücke Anonyme

7 Man nennt sie... Example Abstractions Ausdrücke Anonyme 1 (\a b c-> b^2-4*a*c) map (\x -> x^2 + 1) [1..10] 3 filter (\ x - > x mod 5 == 0) [ ] 4 map (\(x,y) -> x+y) ( zip [1..10] [1..10])

8 Syntax Ausdruck Einfache und allgemeine Form λx 1... x n expr (1) λpat 1... pat n expr (2)

9 Syntax Ausdruck Einfache und allgemeine Form Bzw λx 1... x n expr (1) λpat 1... pat n expr (2) 1 \x1... xn -> expr 2 \ pat1... patn -> expr definiert eine anonyme, n-stellige Funktion.

10 Syntax Ausdruck Einfache und allgemeine Form Bzw λx 1... x n expr (1) λpat 1... pat n expr (2) 1 \x1... xn -> expr 2 \ pat1... patn -> expr definiert eine anonyme, n-stellige Funktion. Wichtig Ausdruck ist ein Ausdruck, sein Wert eine Funktion. Er kann überall stehen, wo Ausdrücke erlaubt sind, z.b. als Argument einer Funktion/ eines Ausdrucks

11 Wiederholung Pattern/Muster Pattern sind Ausdrücke bestehend aus natürlichen Zahlen Werten Variablen Datentyp-Konstruktoren Wildcard-Symbol _ aber ohne!! ( mit Ausnahme des Musters n + 1)

12 Patterns Patterns erlauben pattern matching auf der linken Seite auch in anonymen. Muster von mehrstelligen Konstruktoren müssen geklammert werden Example 1 (\( xxs) -> x) [4,3,2]

13 Currying 1-stellige versus n-stellige n-stellige lassen sich stets als 1-stellige auffassen. Man nennt sie dann curried oder auf Deutsch curryfiziert (nach Haskell B. Curry) geschönfinkelt (nach Moses Schönfinkel) gestaffelt

14 Currying 1-stellige versus n-stellige n-stellige lassen sich stets als 1-stellige auffassen. Man nennt sie dann curried oder auf Deutsch curryfiziert (nach Haskell B. Curry) geschönfinkelt (nach Moses Schönfinkel) gestaffelt Sichtweise λpat 1 pat 2... pat n expr (3) λpat 1 λpat 2... λpat n expr (4)

15 Currying 1-stellige versus n-stellige n-stellige lassen sich stets als 1-stellige auffassen. Man nennt sie dann curried oder auf Deutsch curryfiziert (nach Haskell B. Curry) geschönfinkelt (nach Moses Schönfinkel) gestaffelt Sichtweise λpat 1 pat 2... pat n expr (3) λpat 1 λpat 2... λpat n expr (4) Bzw (λpat 1 (λpat 2... (λpat n expr))) (5)

16 Beispiel sechsmal die gleiche Funktion Example 1 > add I n t > I n t > I n t 2 > add x y = x + y 3 4 > add I n t > ( I n t > I n t ) 5 > add x y = x + y 6 7 > add I n t > ( I n t > I n t ) 8 > add x = \ y > x + y 9 10 > add I n t > ( I n t > I n t ) 11 > add = \x y > x + y > add I n t > ( I n t > I n t ) 14 > add = \x > \y > x + y > add I n t > I n t > I n t 17 > add = \x > \y > x + y

17 Beispiele Typen Was meint GHCi?

18 Currying die verschiedenen Versionen von add haben den gleichen Typ Denn -> (function type constructor) ist rechtsassoziativ in Haskell

19 Currying die verschiedenen Versionen von add haben den gleichen Typ Denn -> (function type constructor) ist rechtsassoziativ in Haskell Sichtweise Das zweistellige add ist eine einstellige Funktion, die eine einstellige Funktion als Ergebnis hat

20 Partielle Anwendung ohne Lambda Example 1 (1+) 2 map (1+) [2,3,4]

21 Kein Curry? Example 1 f (a, b) = a + b

22 Kein Curry? Example 1 f (a, b) = a + b Ausweg 1 curry ((a, b) -> c) -> a -> b -> c 2 curry f x y = f ( x, y)

23 Kein Curry? Example 1 f (a, b) = a + b Ausweg 1 curry ((a, b) -> c) -> a -> b -> c 2 curry f x y = f ( x, y) Zuviel Curry? 1 uncurry (a -> b -> c) -> ((a, b) -> c) 2 uncurry f p = f ( fst p) ( snd p)

24 Fazit Currying In Haskell Nomen est omen sind per-default gestaffelt Staffelung vermeidbar via Tupel Funktions-Typkonstruktor (->) ist rechtsassoziativ -Anwendung ist linksassoziativ f a b ist das gleiche wie (f a) b

25 Fazit Currying In Haskell Nomen est omen sind per-default gestaffelt Staffelung vermeidbar via Tupel Funktions-Typkonstruktor (->) ist rechtsassoziativ -Anwendung ist linksassoziativ f a b ist das gleiche wie (f a) b So gesehen ist jede mehrstellige Funktion eine Higher-Order-Function.

26 höherer Ordnung mit als Parameter mit als Rückgabewert In Haskell

27 höherer Ordnung mit als Parameter mit als Rückgabewert In Haskell als 1st class citizens sind oft von höherer Ordnung höherer Ordnung sind Kontrollstrukturen, die man (im Unterschied zu imperativen Sprachen) selbst definieren kann

28 Wiederholung Bekannte Beispiele für höherer Ordnung 1 map (a->b) -> [a] -> [b] 2 map f [] = [] 3 map f ( x xs) = f x map f xs 4 5 filter (a -> Bool ) -> [a] -> [a] 6 filter p xs = [ x x <- xs, p x]

29 Wiederholung A&D Strukturelle Rekursion Srukturelle Rekursion auf Listen Schema f [σ] -> τ f [] = e 1 f (a as) = e 2 where s = f as wobei e 1 und e 2 Ausdrücke vom Typ τ sind und e 2 die Variablen a, as und s (nicht aber f ) enthalten darf.

30 Beispiele length sum prod and Alle folgen dem gleichen Schema wie z.b. 1 and [] = True 2 and (xxs) = x && ( and xs) Funktion Terminierungs- Anwendung Akkumulation wert (e1) auf x (e2) des Ergebnisses (e2) length sum 0 x + prod 1 x * and True x &&

31 Schema für diese Art der strukturellen Rekursion in Haskell 1 foldr steht für fold right 2 foldr (a -> b -> b) -> b -> [a] -> b 3 foldr _ e [] = e 4 foldr f e (xxs) = f x ( foldr f e xs) 5 6 sum = foldr (+) 0 7 prod = foldr (*) 1 8 and = foldr (&&) True 9 or = foldr ( ) False 10 length = foldr (\ a b - > 1 + b) 0

32 Noch mehr Beispiele mit foldr...? 1 x ++ y = foldr () y x 2 concat = foldr (++) []

33 foldr sum aus der Vogelperspektive foldr f e ersetzt alle durch f und [] durch e. Example [1..5] = [1,2,3,4,5] = 12345[]

34 foldr sum aus der Vogelperspektive foldr f e ersetzt alle durch f und [] durch e. Example [1..5] = [1,2,3,4,5] = 12345[] []

35 foldr sum aus der Vogelperspektive foldr f e ersetzt alle durch f und [] durch e. Example [1..5] = [1,2,3,4,5] = 12345[] foldr (+) [] 5 0

36 foldr prod aus der Vogelperspektive []

37 foldr prod aus der Vogelperspektive [] 5 1

38 foldr prod aus der Vogelperspektive [] 5 1 (1 (2 (3 (4 (5 1))))) = 120

39 foldr length []

40 foldr length [] 1 0

41 foldr length [] 1 0 (1 + (1 + (1 + (1 + (1 + 0))))) = 5

42 Rechenstrategie Vogelperspektive Vogelperspektive bzgl. f bedeutet Rechne so viel (und NUR so viel) bis alle Auftreten von f verschwunden sind. das ist i.a. werder inner- noch outermost aber auf jeden Fall mathematisch korrekt. Dient nicht dem wirklichen Rechnen, aber dem Programmverstehen.

43 foldr klammert von rechts... 1 length " acbde " => (1+(1+(1+(1+(1+0))))) 2 and [True, False, True ] => 3 True && ( False && ( True && False ))... geht s auch von links her?

44 foldl f 5 f 4 f 3 f 2 f 1 e foldl [] foldr f f f f f e

45 foldl-definition 1 foldl (b -> a -> b) -> b -> [a] -> b 2 foldl _ e [] = e 3 foldl f e (xxs) = foldl f (f e x) xs Der Endwert e ist jetzt ein Startwert.

46 Unterschiede foldl, foldr Unterschiedliche Faltung foldr klammert rechtsassoziativ ((a 1 (a 2 (a 3... (a n e))))) (6)

47 Unterschiede foldl, foldr Unterschiedliche Faltung foldr klammert rechtsassoziativ ((a 1 (a 2 (a 3... (a n e))))) (6) foldl klammert linksassoziativ (((((e a 1 ) a 2 ) a 3 )...) a n ) (7) die Faltung von foldr entspricht der Datentypdefinition ggf. Platzbedarf besser bei foldl

48 Unterschiede foldl, foldr Eigenschaft 1 foldr f e ( reverse x) = foldl ( flip f) e x

49 Unterschiede foldl, foldr Eigenschaft 1 foldr f e ( reverse x) = foldl ( flip f) e x Beispiel siehe Tafel.

50 foldl Beispiele sum = foldl (+) 0 or = foldl ( ) False concat = foldl (++) []...

51 Fold im Allgemeinen Fold-Operationen verarbeiten rekursive Datentypen nach deren Rekursionsschema, also mit struktureller Rekursion Kompakter Code Vermeidung von Redundanz Angabe des Wesentlichen Vermeidung von Fehlern bei hand-programmierter Rekursion

52 Weitere Beispiele?

53 Weitere Beispiele? Die Funktion tabulate verwandelt über einem gegebenen Intervall in tabellierende 1 > tabulate (Int, Int )->(Int ->a)->(int ->a) 2 > tabulate (lo,up) f = (t!) where 3 > t = array ( lo, up) ( zip domain ( map f domain )) 4 > domain = [lo.. up] 1 2 > g = tabulate f was sich beim mehrfachen Aufruf von g anstelle von f bezahlt macht.

54 Combinator Languages, edsls höherer Ordnung, deren Argumente nur sind, nennt man Kombinatoren. In manchen Anwendungen gibt es eine Anzahl komplexer, spezifischer Operationen, die sich zu Kombinatoren abstrahieren lassen. Beispiele Parsing, Prettyprinting, Dynamic Programming, Format-Transformationen Dies führt zur Definition von anwendungs-spezifischen Sprachen, eingebettet (embedded domain specific languages, edsls) Dies ist der schnellste Weg zu einer DSL, aber nicht der Weg zur schnellsten DSL

55 Zusammenfassung Wann definiert man selbst neue höherer Ordnung? Wenn sich die gleiche Verknüpfung anderer mehrfach wiederholt,...

56 Zusammenfassung Wann definiert man selbst neue höherer Ordnung? Wenn sich die gleiche Verknüpfung anderer mehrfach wiederholt, macht die Verwendung von Kombinatoren die Systematik transparent, hilft beim Vermeiden von Fehlern, und erhöht so die eigene Programmier-Produktivität

57 Weitere höherer Ordnung Zum Beispiel die Funktions-Komposition 1 infixr (.) (b -> c) -> (a -> b) -> a -> c 4 f. g = \ x -> f (g x)

58 Weitere höherer Ordnung Zum Beispiel die Funktions-Komposition 1 infixr (.) (b -> c) -> (a -> b) -> a -> c 4 f. g = \ x -> f (g x) Oder 5 (.) (b -> c) -> (a -> b) -> a -> c 6 (.) f g x = f (g x)

59 Weitere höherer Ordnung Zum Beispiel die Funktions-Komposition 1 infixr (.) (b -> c) -> (a -> b) -> a -> c 4 f. g = \ x -> f (g x) Oder 5 (.) (b -> c) -> (a -> b) -> a -> c 6 (.) f g x = f (g x) Übersichtlich für Algorithmen mit mehreren Phasen 1 > treesort = sorttree. build 2 3 > compile = writecode. m- opt. codegen. implmap. 4 > transform. semcheck. parse. tokenize Das zweite Beispiel beschreibt die typischen Phasen eines Compilers

60 $, $! und seq Oder sogar die Funktionsanwendung als Funktion 1 infixr 0 $ 2 3 ($) (a -> b) -> a -> b 4 f $ x = f x -- $ heisst " apply "

61 $, $! und seq Oder sogar die Funktionsanwendung als Funktion 1 infixr 0 $ 2 3 ($) (a -> b) -> a -> b 4 f $ x = f x -- $ heisst " apply " infix application operator spart Klammern

62 $, $! und seq Oder sogar die Funktionsanwendung als Funktion 1 infixr 0 $ 2 3 ($) (a -> b) -> a -> b 4 f $ x = f x -- $ heisst " apply " infix application operator spart Klammern Strikte Funktionsanwendung 1 > infixr 0 $! 2 > f $! x = x seq f x -- = f x, aber strikt seq ist die sequentielle Auswertung und dient der Vermeidung unerwünschter Laziness.

63 $, $! und seq seq ist eingebaute Funktion mit den Eigenschaften a seq b =, falls a = a seq b = b, falls x Es ändert ggf. Laufzeit (schneller oder langsamer), Speicherplatz (i.a. weniger) und Terminierungsverhalten (falls überhaupt problematisch), nicht aber die Ergebnisse einer Funktion wenn sie definiert ist. Vergleiche 1 let { cond a b c = if a then b else c; x = x} 2 in ( cond True 1) $ x 3 4 let { cond a b c = if a then b else c; x = x} 5 in ( cond True 1) $! x

64 foldr1 Listerverarbeitung ohne Startwert, von rechts 1 foldr1 (a -> a -> a) -> [a] -> a 2 foldr1 (*) = f 3 where f [a] = a 4 f (abxs) = a * f (bxs) Das letzte Listenelement dient als Startwert

65 foldl1... und das Gleiche von links her 1 foldl1 (a -> a -> a) -> [a] -> a 2 foldl1 (*) (xxs) = foldl (*) x xs Das erste Listenelement dient als Startwert

66 foldl1-beispiele

67 foldl1-beispiele 1 minimum = foldl1 min 2 maximum = foldl1 max Geht s kürzer?