WS 2011/2012. Robert Giegerich Dezember 2013

Transkript

1 WS 2011/2012 Robert 1 AG Praktische Informatik 11. Dezember robert@techfak.uni-bielefeld.de

2 Vorschau Themen heute: Funktionen höherer Ordnung (Fortsetzung) künstliche Striktheit mehr zu fold für alle (rekursiven) Datentypen

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

4 $, $! 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.

5 $, $! und seq (2) seq ist eingebaute Funktion mit den Eigenschaften a seq b =, falls a = (1) a seq b = b, falls x (2) 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

6 foldr1 Listerverarbeitung ohne Startwert, von rechts: 1 foldr1 :: (a -> a -> a) -> [a] -> a 2 foldr1 (*) = f 3 where f [a] = a 4 f (a:b:xs) = a * f (b:xs) Das letzte Listenelement dient als Startwert

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

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

9 Wiederholung: 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.

10 Viele Algorithmen auf Listen folgen dem Schema der strukturellen fold- Funktionen unterstützen dies als Higher-Order-Functions Was ist z.b. mit insert?

11 Beipiel: insert insert hat 2 Argumente formell keine strukturelle Aber: insert a folgt dem Schema 1 > insert x [] = [x] 2 > insert x (y:ys) 3 > x <= y = x:y:ys 4 > x > y = y:( insert x ys) Explizit: 5 > ins [] = \a -> [a] 6 > ins (a : as) = \a -> if a <= a 7 > then a:a : as 8 > else a :( ins as) a Unnatürlich?

12 Erweitertes sschema g :: σ 1 [σ 2 ] τ g i [] = e 1 g i (a : as) = e 2 where s = g e 3 as Ausdruck e 1 e 2 e 3 Variablen enthält i kann i, a, as und s enthalten kann i, a und as enthalten

13 auf Bäumen weitere Datenstruktur: Bäume Modellierung als algebraischer Datentyp Example

14 Eine von vielen Baum-Varianten Welche Eigenschaften sollen unsere Bäume haben? an den Blättern stehen Daten jeder innere Knoten hat 2 Kinder Darstellung: Begriffe: Bäume werden in der Informatik von oben nach unten gezeichnet Wurzel Knoten (Blatt, innerer Knoten) Kante Tiefe

15 Tree Datentyp Tree-Datenyp 1 data Tree a = Leaf a 2 Br ( Tree a) ( Tree a) 3 Nil 4 deriving Show

16 Beispiel Br Br Br Leaf Leaf Br Leaf 1 2 Leaf Leaf Br (Br ( Leaf 1) ( Leaf 2) ) 2 (Br (Br ( Leaf 3) ( Leaf 4) ( Leaf 5)))

17 auf Bäumen Schema der strukturellen : f :: Tree σ -> τ f Nil = e 1 f (Leaf a) = e 2 f (Br l r) = e 3 where sl = f l sr = f r e 3 darf dabei l, r, sl und sr enthalten, nicht aber f.

18 auf Bäumen 1 data Tree a = Leaf a 2 Br ( Tree a) ( Tree a) 3 Nil 4 deriving Show sbasis (Nil) Das Problem wird für den leeren Baum gelöst. sbasis (Leaf a) Das Problem wird für das Blatt Leaf a gelöst. sschritt (Br l r) Um das Problem für den Baum Br l r zu lösen, werden rekursiv Lösungen für l und r bestimmt, die zu einer Lösung für Br l r erweitert werden.

19 Beispiel: Berechnung der Baumgröße 1 size :: Tree a - > Integer 2 size Nil = 1 3 size ( Leaf _) = 1 4 size ( Br l r) = size l + size r

20 Beispiel: Berechnung der Baumtiefe 1 depth :: Tree a - > Integer 2 depth Nil = 0 3 depth ( Leaf _) = 0 4 depth (Br l r) = max ( depth l) ( depth r) + 1

21 Beispiel: Blätter aufzählen 1 > leaves :: Tree a -> [a] 2 > leaves Nil = [] 3 > leaves ( Leaf a) = [a] 4 > leaves ( Br l r) = leaves l ++ leaves r Geht es nicht besser?

22 Verstärkung der (Einbettung) Exkurs zu leaves Verstärkung der wie bei der rekursiven Listenfunktion reverse 1 fleaves :: Tree a -> [a] 2 fleaves t = f t [] 3 where 4 f :: Tree a -> [a] -> [a] 5 f Nil y = y 6 f ( Leaf a) y = a:y 7 f (Br l r) y = f l (f r y) Und warum ist das nun schneller?

23 Apropos reverse Die langsame Version: 1 > slowreverse [] = [] 2 > slowreverse ( x: xs) = slowreverse xs ++ [ x] Schneller durch Einbettung 1 > fastreverse xs = f xs [] where 2 > f [] ys = ys 3 > f (x:xs) ys = f xs (x:ys)

24 fold auf Bäumen Die Funktionen size, depth, leaves folgen alle dem gleichen Schema. 1 > foldtree :: b - >(a->b)->(b->b->b)-> Tree a -> b 2 > foldtree nil leaf br = f where 3 > f Nil = nil 4 > f ( Leaf a) = leaf a 5 > f (Br l r) = br (f l) (f r) Damit erhalten wir 1 > size = foldtree 1 (\ x - >1) (+) 2 > depth = foldtree 0 (\x - >0) (\x y-> max x y +1) 3 > leaves = foldtree [] (\x - >[x]) (++) Das findet man einfach durch Anwendung der Vogelperspektive

25 fold im Allgemeinen Verallgemeinerung: für jeden algebraischen Datentyp T können wir eine foldt-funktion definieren für jeden Konstruktor hat sie eine passende Funktion als Argument, sowie ein t T in der Vogelperspektive werden die Konstruktoren durch die passenden Funktionen ersetzt (und anschließend die entstandene Formel ausgerechnet). Je komplizierter der Datentyp, deso mehr gewinnt man durch die Verwendung der fold-operation PS: Und was tut die folgende Funktion f? 1 > f = foldtree Nil Leaf Br

26 Das allgemeine sschema data T a 1... a m = C 1 t t 1n1... C r t r1... t rnr Wir unterscheiden zwei Arten von Argumenten: rekursive (d.h. t ij ist gleich T a 1... a m ) und nicht-rekursive. Seien l i1,..., l ipi mit 1 l i1 < l i2 < < l ipi n i die Positionen, an denen der Konstruktor C i rekursiv ist

27 Das allgemeine Schema der strukturellen f :: T σ 1... σ m -> τ f (C 1 x x 1n1 ) = e 1 where s 11 = f x 1l11... s 1p1 = f x 1l1p1... f (C r x r1... x rnr ) = e r where s r1 = f x rlr1... s rpr = f x rlrpr Der Ausdruck e i darf die Variablen x i1,..., x ini und die Variablen s i1,..., s ipi enthalten. Ist p i = 0, so spricht man von einer sbasis, sonst von einem sschritt.

28 Fazit für jeden algebraischen Datentyp direkte Orientierung an den Konstruktoren lassen sich alle Probleme mit struktureller lösen? strukturelle versus wohlfundierte wie war das mit der Implementierung der Registermaschine?