Programmieren in Haskell. Stefan Janssen. Strukturelle Rekursion. Universität Bielefeld AG Praktische Informatik. 10.

Transkript

1 Universität Bielefeld AG Praktische Informatik 10. Dezember 2014

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

3 Viele Algorithmen auf Listen folgen dem Schema der strukturellen fold- Funktionen unterstützen dies als Higher-Order-Functions

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

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

6 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

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

8 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

9 auf Bäumen weitere Datenstruktur: Bäume Modellierung

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

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

12 Eine von vielen Baum-Varianten Welche Eigenschaften sollen unsere Bäume haben? an den Blättern stehen Daten jeder innere Knoten hat 2 Kinder

13 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: Bäume werden in der Informatik von oben nach unten gezeichnet

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 5 3 4

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

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

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

20 Beispiel: Berechnung der Baumgröße

21 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

22 Beispiel: Berechnung der Baumtiefe

23 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

24 Beispiel: Blätter aufzählen

25 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

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

27 Verstärkung der (Einbettung) Exkurs zu leaves Verstärkung der wie bei der rekursiven Listenfunktion reverse

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

29 Apropos reverse Die langsame Version: 1 > slowreverse [] = [] 2 > slowreverse ( x: xs) = slowreverse xs ++ [ x]

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

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

32 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

33 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

34 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

35 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

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

37 Fazit für jeden algebraischen Datentyp direkte Orientierung an den Konstruktoren lassen sich alle Probleme mit struktureller lösen? strukturelle versus wohlfundierte