expr :: Expr expr = Mul (Add (Const 3) (Const 4)) (Div (Sub (Const 73) (Const 37)) (Const 6))

Transkript

1 1 - Korrektur 2 - Abstrakte Datentypen für arithmetische Ausdrücke Der Datentyp Wir beginnen zunächst mit dem algebraischen Datentyp für Ausdrücke. Hierfür definieren wir einen Konstruktor Number für Zahlen, sowie je einen Konstruktor für die 4 Operationen: data Expr = Const Int Add Expr Expr Sub Expr Expr Mul Expr Expr Div Expr Expr deriving Show Eine konkreten Ausdruck wie beispielsweise (3 + 4) ((73 37)/6) können wir dann wie folgt definieren: expr :: Expr expr = Mul (Add (Const 3) (Const 4)) (Div (Sub (Const 73) (Const 37)) (Const 6)) Das sieht jedoch relativ kompliziert aus (Scheme!?). Dies können wir lösen, indem wir nicht wie oben Präfixkonstruktoren, sondern stattdessen Infixkonstruktoren verwenden. Damit diese als solche erkannt werden können, müssen Infixkonstruktoren mit einem Doppelpunkt : beginnen und weitere Symbole enthalten. 1 data Exp 2 = Number Int 3 Exp :+: Exp 4 Exp :-: Exp 5 Exp :*: Exp 6 Exp :/: Exp 7 deriving Show Nun können wir den Ausdruck wie folgt notieren: 8 test :: Exp 9 test = (Number 3 :+: Number 4) :*: ((Number 73 :-: Number 37) :/: Number 6) Wir können optional auch noch Präzedenzen (Bindungsstärken) für die Konstruktoren festlegen um Klammern zu sparen: 10 infixl 6 :+:, :-: 11 infixl 7 :*:, :/: Dies definiert die 4 Konstruktoren wegen infixl als links-assoziativ, im Gegensatz zu infixr (rechtsassoziativ) und infix (nicht assoziativ), und die multiplikativen Operationen binden stärker. Damit kann der Ausdruck als 12 seven :: Exp 13 seven = Number 1 :+: Number 2 :*: Number 3 notiert werden. Auswertung Da Exp eine induktiv definierte Datenstruktur ist, versuchen wir zunächst für jeden Fall eine Gleichung anzugeben, und erhalten direkt die folgende Lösung: 1

2 14 eval :: Exp -> Int 15 eval (Number i) = i 16 eval (e1 :+: e2) = eval e1 + eval e2 17 eval (e1 :-: e2) = eval e1 - eval e2 18 eval (e1 :*: e2) = eval e1 * eval e2 19 eval (e1 :/: e2) = eval e1 `div` eval e2 Binärbäume Arithmetische Ausdrücke lassen sich gut als Termbäume darstellen, wobei an den Blättern Zahlen und an den Knoten die Operationen stehen. Wenn wir zunächst die 4 Konstruktoren für Operationen durch einen gemeinsamen Fall abdecken und anschließend die Beschriftungen (Zahlen und Operatornamen) durch Typvariablen ersetzen, erhalten wir schlussendlich eine Datenstruktur für Binärbäume mit prinzipiell unterschiedlichen Beschriftungen an den Blättern und den Knoten: 1. Gemeinsame Teile herausfaktorisieren: data Exp = Number Int Bin Op Exp Exp data Op = Add Sub Mul Div 2. Typen und Konstruktoren umbenennen: data Tree = Leaf Int Node Op Tree Tree data Op = Add Sub Mul Div 3. Beschriftungen verallgemeinern: data Tree a b = Leaf a Node b (Tree a b) (Tree a b) data Op = Add Sub Mul Div Somit lassen sich arithmetische Ausdrücke wie folgt darstellen: 20 data Tree a b = Leaf a Node b (Tree a b) (Tree a b) 21 deriving Show data Op = Add Sub Mul Div 24 deriving Show type Exp' = Tree Int Op Damit wir konkrete Ausdrücke einfacher konstruieren können, definieren wir uns die folgenden Hilfs(konstruktor)funktionen, auch Smartkonstruktoren genannt: 27 number :: Int -> Exp' 28 number = Leaf (.+.) :: Exp' -> Exp' -> Exp' 31 (.+.) = Node Add (.-.) :: Exp' -> Exp' -> Exp' 34 (.-.) = Node Sub (.*.) :: Exp' -> Exp' -> Exp' 37 (.*.) = Node Mul 38 2

3 39 (./.) :: Exp' -> Exp' -> Exp' 40 (./.) = Node Div Somit könnte unser Ausdruck test von oben wie folgt in der Baumstruktur definiert werden: 41 test' :: Exp' 42 test' = (number 3.+. number 4).*. ((number number 37)./. number 6) Auch für diese Funktionen könnte man wie oben noch Präzedenzen festlegen. Auswertung Die Auswertungsfunktion ergibt sich wie oben, allerdings müssen wir noch einem Wert des Typs Op die dazugehörige Funktion als Bedeutung (Semantik) zuordnen. Wir nennen diese Funktion sem: 43 sem :: Op -> Int -> Int -> Int 44 sem Add = (+) 45 sem Sub = (-) 46 sem Mul = (*) 47 sem Div = div Nun können wir die Auswertung wie folgt definieren: 48 eval' :: Exp' -> Int 49 eval' (Leaf n) = n 50 eval' (Node op l r) = sem op (eval' l) (eval' r) Darstellung Üblicherweise möchte man Ausdrücke aber nicht nur ausrechnen, sondern vielleicht auch noch schön formatiert ausgeben. Wir definieren uns hierzu eine Funktion pshow (kurz für pretty show ): 51 pshow :: Exp' -> String 52 pshow (Leaf n) = show n 53 pshow (Node op l r) = concat ["(", pshow l, showop op, pshow r, ")"] showop :: Op -> String 56 showop Add = "+" 57 showop Sub = "-" 58 showop Mul = "*" 59 showop Div = "/" Faltung Es fällt auf, dass die Funktionen eval' und pshow insofern gleichartig vorgehen, als dass für Blätter die jeweilige Beschriftung verarbeitet wird, während bei Knoten die Teilbäume zunächst rekursiv verarbeitet und dann mit der Knotenbeschriftung kombiniert werden. Dies entspricht genau dem Konzept einer Faltung auf Binärbäumen: 60 foldtree :: (a -> c) -> (b -> c -> c -> c) -> Tree a b -> c 61 foldtree f _ (Leaf x) = f x 62 foldtree f g (Node y l r) = g y (foldtree f g l) (foldtree f g r) Somiz können wir beide Funktionen auch mittels foldtree implementieren: 63 eval2 :: Exp' -> Int 64 eval2 = foldtree id sem pshow2 :: Exp' -> String 67 pshow2 = foldtree show (\op s1 s2 -> concat ["(", s1, showop op, s2, ")"]) Beliebigstellige Operationen Um Operationen mit beliebiger Stelligkeit darstellen zu können, reicht es aus die beiden Teilbäume eines Knotens durch eine Liste von Teilbäumen zu ersetzen: 3

4 68 data NTree a b = NLeaf a NNode b [NTree a b] 69 deriving Show Diese Bäume werden in der Literatur übrigens oft als rose trees, zu deutsch Rhododendron-Bäume, bezeichnet. 3 - Suchbäume Wir beginnen mit dem Datentyp eines Suchbaums: 1 data SearchTree = Empty Branch SearchTree Int SearchTree 2 deriving (Eq, Show) Die insert-funktion fügt ein Element nur ein wenn es noch nicht vorhanden ist. In dem Fall wird für das Element ein neues Blatt erzeugt und so in den Baum gehängt, dass es rechts von kleineren und links von größeren Elementen steht. 3 insert :: Int -> SearchTree -> SearchTree 4 insert x Empty = Branch Empty x Empty 5 insert x (Branch l n r) 6 x == n = Branch l n r 7 x < n = Branch (insert x l) n r 8 otherwise = Branch l n (insert x r) Die Funktion iselem nutzt die Ordnung des Baums, um die richtige Beschriftung zu finden: 9 iselem :: Int -> SearchTree -> Bool 10 iselem _ Empty = False 11 iselem x (Branch l n r) 12 x == n = True 13 x < n = iselem x l 14 otherwise = iselem x r Zum Löschen einer Beschriftung gibt es unterschiedliche Strategien. Knoten mit weniger als zwei nicht-leeren Teilbäumen können einfach gelöscht werden, aber andere Knoten nicht, da dann zwei nicht-leere Teilbäume zu einem einzigen kombiniert werden müssen. Eine einfache Möglichkeit ist, den linken Teilbaum ganz links im rechten einzufügen oder umgekehrt. Dadurch wird die Höhe des Baumes aber unnötig groß. Besser ist es, eine geeignete Beschriftung aus einem der Teilbäume zu löschen und diese an die frei gewordene Stelle zu schreiben. Man kann entweder die größte (rechteste) Beschriftung des linken oder die kleinste (linkeste) des rechten Teilbaumes an diese Stelle schreiben. Für letzteres benötigt man eine Funktion splitmin, die die kleinste Beschriftung eines sortierten Baumes und den Restbaum als Ergebnis liefert. Da Funktionen nur ein Ergebnis liefern können, liefern wir ein Paar aus beiden Teilen: 15 splitmin :: SearchTree -> (Int, SearchTree) 16 splitmin Empty = error "splitmin: empty search tree" 17 splitmin (Branch Empty n r) = (n, r) 18 splitmin (Branch l n r) = (m, Branch t n r) 19 where (m, t) = splitmin l Die splitmin Funktion ist partiell, da sie nur für nicht-leere Bäume definiert ist. Sie wird aber auch nur auf solchen aufgerufen. Mit ihrer Hilfe können wir delete implementieren. Da jede Beschriftung höchstens einmal im Baum vorkommt, genügt es, die erste gefundene zu entfernen. 20 delete :: Int -> SearchTree -> SearchTree 21 delete _ Empty = Empty 4

5 22 delete x (Branch Empty n r) 23 x == n = r 24 x < n = Branch Empty n r 25 otherwise = Branch Empty n (delete x r) 26 delete x (Branch l n Empty) 27 x == n = l 28 x < n = Branch (delete x l) n Empty 29 otherwise = Branch l n Empty 30 delete x (Branch l n r) 31 x == n = Branch l m t 32 x < n = Branch (delete x l) n r 33 otherwise = Branch l n (delete x r) 34 where (m, t) = splitmin r 4 - Polymorphe binäre Blatt-Bäume Der folgende Datentyp representiert Bäume mit Beschriftungen an Blättern. 1 data Tree a = Leaf a Tree a :&: Tree a 2 deriving (Eq,Show) Die flattree-funktion soll einen Baum von Bäumen zu einem einzigen Baum flach klopfen. Wir könnten sie rekursiv wie folgt definieren: 3 flattree' :: Tree (Tree a) -> Tree a 4 flattree' (Leaf x) = x 5 flattree' (s :&: t) = flattree s :&: flattree t Die interessante Regel ist die zweite, die den Leaf-Konstruktor der äußeren Baumstruktur löscht. Mit ein wenig Vorausschau können wir uns die Implementierung von flattree erleichtern. Wählen wir beim Typ von extendtree für die Typvariable a den konkreten Typ Tree b, dann ergibt sich genau der Typ von flattree. Aber nicht nur das, es ergibt sich auch die Implementierung: 6 flattree :: Tree (Tree a) -> Tree a 7 flattree = extendtree id Auch die maptree-funktion können wir entweder direkt oder mit Hilfe einer anderen Funktion implementieren. Hier die direkte Variante: 8 maptree' :: (a -> b) -> Tree a -> Tree b 9 maptree' f (Leaf x) = Leaf (f x) 10 maptree' f (s :&: t) = maptree f s :&: maptree f t Statdessen können wir auch wieder extendtree verwenden, indem wir die übergebene Funktion mit dem Leaf{.haskell}-Konstruktor kombinieren: 11 maptree :: (a -> b) -> Tree a -> Tree b 12 maptree f = extendtree (Leaf. f) Die Funktion extendtree können wir entweder direkt implementieren oder mit foldtree. Hier die direkte Implementierung: 13 extendtree' :: (a -> Tree b) -> Tree a -> Tree b 14 extendtree' f (Leaf x) = f x 15 extendtree' f (s :&: t) = extendtree' f s :&: extendtree' f t Und hier die Variante mit foldtree: 16 extendtree :: (a -> Tree b) -> Tree a -> Tree b 17 extendtree f = foldtree f (:&:) 5

6 Wenn wir die Implementierungen von flattree und maptree verwenden, die nicht auf extendtree basieren, können wir extendtree auch mit deren Hilfe definieren: 18 extendtree'' :: (a -> Tree b) -> Tree a -> Tree b 19 extendtree'' f = flattree'. maptree' f Die einzige Funktion, die wir direkt implementieren müssen, da wir sie nicht auf die anderen zurückführen können, ist foldtree. Sie bekommt für jeden Konstruktor des Tree-Datentyps ein Argument um diesen zu ersetzen: 20 foldtree :: (a -> b) -> (b -> b -> b) -> Tree a -> b 21 foldtree l _ (Leaf x) = l x 22 foldtree l f (s :&: t) = foldtree l f s `f` foldtree l f t 5 - Folds foldr (:) [] ist die Identitätsfunktion auf Listen. foldl (*) 1 [x1...xn] berechnet ((1*x1)*x2)...*xn, sprich das Produkt der Elemente der Liste. foldr (-) 1 [x1...xn] berechnet x1-(x2-...(xn-1)). foldl (-) 1 [x1...xn] berechnet ((1-x1)-x2)...-xn bzw. 1 - sum [x1...xn]. Die map Funktion erhält die Listenstruktur und bildet nur die Elemente auf neue ab. 9 mapr, mapl :: (a -> b) -> [a] -> [b] 10 mapr f = foldr ((:). f) [] Aber wie kommt man auf Ausdrücke wie (:). f? Indem man mit einer anonymen Funktion anfängt und diese systematisch umformt: 11 \x xs -> f x : xs 12 \x -> (f x :) 13 \x -> (:) (f x) 14 \x -> ((:). f) x 15 (:). f Funktionen ohne explizite Argumente nennt man übrigens punktfrei. Auch die map Funktion kann man mit foldl nur umständlich definieren, und das führt zur gleichen Verschlechterung der Laufzeit wie bei append: 16 mapl f = foldl (\xs x -> xs ++ [f x]) [] Die reverse-funktion hingegen implementiert man am besten mit foldl. Interessanterweise entspricht die Definition mit foldr genau der naiven (ineffizienten) Variante und die Definition mit foldl der effizienten Implementierung: 17 reverser, reversel :: Eq a => [a] -> [a] 18 reverser = foldr (\x xs -> xs ++ [x]) [] -- quadratisch 19 reversel = foldl (\xs x -> x : xs) -- linear reversel = foldl (flip (:)) [] Die zweite Definition nutzt das zweite Argument von foldl als Akkumulator, in dem die gegebene Liste umgedreht wird. unzip lässt sich recht leicht mit foldr implementieren, aber schwierig mit foldl: 20 unzipr, unzipl :: [(a, b)] -> ([a], [b]) 21 unzipr = foldr (\(a,b) (as,bs) -> (a : as, b : bs)) ([],[]) 22 unzipl = foldl (\(as,bs) (a,b) -> (as ++ [a], bs ++ [b])) ([],[]) 6

7 Die Variante mit foldr hat hier eine lineare Laufzeit bezogen auf die Listenlänge, die Variante mit foldl ist quadratisch. Bei nub verhält es sich ähnlich, wobei wegen des filter beide Implementierungen eine quadratische Laufzeit besitzen. 23 nubr, nubl :: Eq a => [a] -> [a] 24 nubr ys = foldr (\x xs -> x : filter (x/=) xs) [] ys 25 nubl ys = foldl (\xs x -> filter (x/=) xs ++ [x]) [] ys 7