Kapitel 3: Programmierung mit Kombinatoren

Transkript

1 Funktionale Programmierung (WS2005/2006) 3/1 Kapitel 3: Programmierung mit Kombinatoren Lernziele dieses Kapitels 1. Denken in unktionalen Komponenten, Vermeidung von Kontrolllussdenken (Rekursion) Details der Datenstruktur (Pattern Matching in induktiven Deinitionen) 2. Selbstverständlicher Umgang mit vielen in den Typsignaturen 3. Kenntnis der wichtigsten Kombinatoren Bildliche Vorstellung ihrer Struktur Anwendung von Kombinatoren 4. Bäume: Durchläue und Suche 5. Functor als Typklasse ür Abstraktion von Datenstrukturen 6. Skelette, Beispiel Divide-and-Conquer

2 Funktionale Programmierung (WS2005/2006) 3/2 Programmierung mit Kombinatoren Kombinator: Funktion ohne reie Variablen Bedeutung unabhängig von der Umgebung klare Funktionalität hohe Wiederverwendbarkeit geeignet ür spezielle eiziente Implementierung Skelett: Kombinator mit umangreicher Funktionalität

3 Funktionale Programmierung (WS2005/2006) 3/3 Kombinatoren statt expliziter Rekursion Beispielaugabe: revertieren einer Liste schlechte Lösung mit expliziter Rekursion revertiere l = i null l then [] else let rest = revertiere (tail l) ansende l1 = i null l1 then [head l] else head l1 : ansende (tail l1) in ansende rest gute Lösung mit Kombinatoren revertiere = oldl (lip (:)) []

4 Funktionale Programmierung (WS2005/2006) 3/4 Aspekt Programmierstil einige der wünschenswerten Eigenschaten Vermeidung impliziter Deinitionen (Rekursion) 2. Vermeidung von Fallunterscheidungen (i-then-else) 3. Bezug au Datenstrukturen so gering wie möglich halten 4. Wenn Datenstrukturen, dann Pattern Matching statt Selektoren 5. Funktionsgleichungen ohne Bezug au Argumente ( pointree style)... und warum diese wünschenswert sind: (1),(2),(4),(5): Vereinachung von Beweisen und Programmtransormationen (1),(2),(3),(4): Verkürzung des Quelltextumangs bessere Lesbarkeit (3): Austauschbarkeit von Teilen der Implementierung

5 Funktionale Programmierung (WS2005/2006) 3/5 Der Nutzen von Kombinatoren Bereitstellung häuig vorkommender Programmschemata (map, oldl,... ) Kapselung von Rekursion und Fallunterscheidungen Anpassung von Repräsentationen (lip, concat,... ) Skelette: Faktorisierung einer Problemlösung in algorithmischen Anteil (Depth-First-Suche, Divide-and-Conquer,... ) Anwendungs-speziische Operationen Einache Regeln ür Programmtransormationen z.b. map g. map = map (g. )

6 Funktionale Programmierung (WS2005/2006) 3/6 Eiziente Implementierung ür Kombinatoren Der Compiler kann Wissen über den Kombinator ausnutzen. Bsp. map [x 0,..., x n ] [y 0,..., y n ]: x 0 y 0 x 1 y 1 Denken in unktionalen Blöcken, nicht in Rekursion x n y n Fazit: alle Anwendungen von sind unabhängig und könnten, z.b. von einem Parallelrechner gleichzeitig ausgeührt werden.

7 Funktionale Programmierung (WS2005/2006) 3/7 Programmtransormationen Bsp.: map g. map == map (g. ) sequenziell: Vermeidung von Iterationen und temporären Datenstrukturen (y) parallel: Vermeidung von Kommunikationen map g map map (g ) z 0 g y 0 y 0 x 0 z 0 g x 0 z 1 g y 1 y 1 x 1 = z 1 g x 1 z n g y n y n x n z n g x n

8 Funktionale Programmierung (WS2005/2006) 3/8 Vektoroperationen: zipwith zipwith :: (a->b->c) -> [a] -> [b] -> [c] zipwith (x:xs) (y:ys) = x y : zipwith xs ys zipwith _ = [] x 0 y 0 z 0 x 1 y 1 z 1 x n y n z n innerprod :: Num a => [a] -> [a] -> a innerprod xs ys = sum (zipwith (*) xs ys)

9 Funktionale Programmierung (WS2005/2006) 3/9 Der oldl-kombinator oldl :: (a->b->a) -> a -> [b] -> a oldl e [] = e oldl e (x:xs) = oldl ( e x) xs x xs e Beispiele: sum [1,2,3,4] = oldl (+) 0 [1,2,3,4] = (((0+1)+2)+3)+4 prod [1,2,3,4] = oldl (*) 1 [1,2,3,4] = (((1*1)*2)*3)*4

10 Funktionale Programmierung (WS2005/2006) 3/10 Wiederverwendbarkeit von Kombinatoren naive Deinition elegante Deinition sum [] = 0 sum = oldl (+) 0 sum (x:xs) = x + sum xs product [] = 1 product = oldl (*) 1 product (x:xs) = x * product xs reverse xs = rev xs [] reverse where = oldl (lip (:)) [] rev [] acc = acc rev (x:xs) acc = rev xs (x:acc)

11 Funktionale Programmierung (WS2005/2006) 3/11 Listenrevertierung mittels oldl reverse = oldl (lip (:)) [] reverse [1,2,3,4] = oldl (lip (:)) [] [1,2,3,4] = oldl (lip (:)) [1] [2,3,4] = oldl (lip (:)) [2,1] [3,4] = oldl (lip (:)) [3,2,1] [4] = oldl (lip (:)) [4,3,2,1] [] = [4,3,2,1] lip lip lip lip [] [1] [2,1] [3,2,1] [4,3,2,1] (:) (:) (:) (:)

12 Funktionale Programmierung (WS2005/2006) 3/12 Varianten des old-kombinators oldl :: (a->b->a)->a->[b]->a oldl e [] = e oldl e (x:xs) = oldl ( e x) xs oldr :: (a->b->b)->b->[a]->b oldr e [] = e oldr e (x:xs) = x (oldr e xs) e x 0 e x 1 x n x 0 x 1 x n e e oldl1 (x:xs) = oldl x xs x 0 x 1 x 2 x n e oldr1 [x] = x oldr1 (x:xs) = x (oldr1 xs) x 0 x 1 x n 1 x n e

13 Funktionale Programmierung (WS2005/2006) 3/13 Anwendung von oldl, Bsp. sum x 0 e x 1 x n e oldl :: (a->b->a) -> a -> [b] -> a oldl e [] = e oldl e (x:xs) = oldl ( e x) xs sum = oldl (+) 0 sum [a,b,c,d,e] ((((0+a)+b)+c)+d)+e Da + assoziativ ist, wäre auch oldr möglich. Für strikte Operatoren wie + bevorzugt man oldl, weil 1. die Zahlen in der Liste nicht extra gespeichert werden müssen und 2. sowieso die ganze Liste durchgegangen werden muss.

14 Funktionale Programmierung (WS2005/2006) 3/14 Anwendung von oldr, Bsp. and x 0 x 1 x n e e oldr :: (a->b->b) -> b -> [a] -> b oldr e [] = [] oldr e (x:xs) = x (oldr e xs) and = oldr (&&) True and [a,b,c] a && (b && (c && True)) Da && assoziativ ist, wäre auch oldl möglich. Für im zweiten Argument nicht-strikte Operatoren wie && bevorzugt man oldr weil 1. oldl die ganze Liste durchlauen würde, aber 2. das Ergebnis bereits rüher eststehen kann.

15 Funktionale Programmierung (WS2005/2006) 3/15 Anwendung von oldl1, Bsp. maximum x 0 x 1 x 2 x n e oldl1 :: (a->a->a) -> [a] -> a oldl1 (x:xs) = oldl x xs maximum = oldl1 max maximum [3,5,7,4] max (max (max 3 5) 7) 4 oldl1, weil ot kein neutrales Element vorhanden ist. Nur noch eine Variable im Typ. Da max assoziativ ist, wäre auch oldr1 möglich. Analog zu sum: oldl1, weil max strikt.

16 Funktionale Programmierung (WS2005/2006) 3/16 Zwischenergebnisse: scanl und mapaccuml oldl :: (a->b->a) -> a -> [b] -> a e x 0 e x 1 x n scanl :: (a->b->a) -> a -> [b] -> [a] e 0 x 0 x 1 x n e 0 e 1 e 2 e n e n+1 mapaccuml :: (a->x->(a,y)) -> a -> [x] -> (a,[y]) e x 0 y 0 x 1 y 1 x n y n e analog: scanr, scanl1, scanr1 und mapaccumr

17 Funktionale Programmierung (WS2005/2006) 3/17 Berechnung von Zielpositionen ür eine Teilolge Anwendung: paralleles Partitionieren (paralleler Quicksort) gegeben: Prädikat (>4) und Liste [2,7,6,4,8,2] gesucht: Positionen in der Teilolge der Zahlen, die das Prädikat erüllen Eingabe: [2,7,6,4,8,2] Maske: [0,1,1,0,1,0] 1 gdw. Prädikat erüllt Osets: [0,0,1,2,2,3,3] Präixsumme von Maske (scanl (+) 0) Ergebnis: [0,0,1,2,2,3] Ergebnis ist elementweise Verknüpung (zipwith) aus Maske (Farbe) und Osets (Wert), kleinere Liste bestimmt Länge Verwende statt Farbe Nothing und Just im Ergebnis: [Nothing,Just 0,Just 1,Nothing,Just 2,Nothing]

18 Funktionale Programmierung (WS2005/2006) 3/18 Anwendung von scanl, Bsp.: positions x 0 x 1 x n e 0 e 0 e 1 e 2 e n e n+1 scanl :: (a -> b -> a) -> a -> [b] -> [a] positions :: (a->bool) -> [a] -> [Maybe Int] positions pred xs = let mask = [ i pred x then 1 else 0 x<-xs ] [0,1,1,0,1,0] osets = scanl (+) 0 mask [0,0,1,2,2,3,3] m o = i m==0 then Nothing else Just o in zipwith mask osets

19 Funktionale Programmierung (WS2005/2006) 3/19 Anwendung von mapaccuml, nochmal: positions Vorteil: nur ein Listendurchlau, keine temporären Datenstrukturen x 0 x 1 x n e e y 0 y 1 y n mapaccuml :: (a->x->(a,y)) -> a -> [x] -> (a,[y]) positions :: (a->bool) -> [a] -> [Maybe Int] positions pred xs = let acc x = i pred x then (acc+1,just acc) else (acc,nothing) in snd (mapaccuml 0 xs)

20 Funktionale Programmierung (WS2005/2006) 3/20 Kombinatoren au Bäumen Baumtyp (eine Art): data Tree element = Node element [Tree element] Beispiel: tree1 :: Tree String tree1 = Node "" [Node "a" [Node "aa" [], Node "ab" [Node "aba" [], Node "abb" [Node "abba" [], Node "abbb" [], Node "abbc" []], Node "abc" []] ], Node "b" [Node "ba" [], Node "bb" [Node "bba" []]], Node "c" [Node "ca" [Node "caa" []]]]

21 Funktionale Programmierung (WS2005/2006) 3/21 Deinition Anwendung einer Funktion au alle Knoten maptree :: (a->b) -> Tree a -> Tree b maptree (Node x subtrees) = Node ( x) (map (maptree ) subtrees) Beispiel *Tree> maptree length tree1 Node 0 [Node 1 [Node 2 [], Node 2 [Node 3 [], Node 3 [Node 4 [], Node 4 [], Node 4 []], Node 3 []]], Node 1 [Node 2 [], Node 2 [Node 3 []]], Node 1 [Node 2 [Node 3 []]]]

22 Funktionale Programmierung (WS2005/2006) 3/22 Deinition Reduktion (old) au Bäumen oldtree :: (a->[b]->b) -> Tree a -> b oldtree (Node x subtrees) = x (map (oldtree ) subtrees) Bsp.: Summierung aller Zahlen in einem Baum sumelems :: Num a => Tree a -> a sumelems = let nodeval subtreesums = nodeval + sum subtreesums in oldtree *Tree> let tree2 = maptree length tree1 *Tree> sumelems tree2 40

23 Funktionale Programmierung (WS2005/2006) 3/23 Tieendurchlau von Bäumen preorder, inorder, postorder :: Tree a -> [a] preorder = let pre x xss = x : concat xss in oldtree pre postorder = let post x xss = concat xss ++ [x] in oldtree post inorder = let second x [] = [x] second x (xs:xss) = xs ++ (x : concat xss) in oldtree second

24 Funktionale Programmierung (WS2005/2006) 3/24 Breitendurchlau von Bäumen Hilsmittel: algorithmisches Skelett workqueue workqueue :: (a->([b],[a])) -> [a] -> [b] workqueue xs = wq xs [] where wq [] acc = acc wq (x:xs) acc = let (out,app) = x in wq (xs++app) (acc++out) Implementierung des Breitendurchlaus breadthorder hänge aktuellen Knotenwert an Ergebnisliste acc an hänge Unterbäume an die Warteschlange xs an breadthorder :: Tree a -> [a] breadthorder t = workqueue [t] where (Node x subtrees) = ([x],subtrees)

25 Funktionale Programmierung (WS2005/2006) 3/25 Suche in Bäumen 1. erzeuge eine Liste mit den Elementen in der gewünschten Ordnung 2. suche das erste Element in der Liste, welches das Prädikat pred erüllt depthfirstsearch, breadthfirstsearch :: (a->bool) -> Tree a -> Maybe a depthfirstsearch pred = maybehead. ilter pred. preorder breadthfirstsearch pred = maybehead. ilter pred. breadthorder Wegen der Laziness von Haskell wird die Datenstruktur nur soweit durchlauen, bis das entsprechende Element geunden wurde. maybehead :: [a] -> Maybe a maybehead [] = Nothing maybehead (x:_) = Just x

26 Funktionale Programmierung (WS2005/2006) 3/26 *Tree> preorder tree1 ["","a","aa","ab","aba","abb","abba","abbb","abbc","abc", "b","ba","bb","bba","c","ca","caa"] *Tree> postorder tree1 ["aa","aba","abba","abbb","abbc","abb","abc","ab","a","ba", "bba","bb","b","caa","ca","c",""] *Tree> inorder tree1 ["aa","a","aba","ab","abba","abb","abbb","abbc","abc","", "ba","b","bba","bb","caa","ca","c"] *Tree> breadthorder tree1 ["","a","b","c","aa","ab","ba","bb","ca","aba","abb","abc", "bba","caa","abba","abbb","abbc"] *Tree> let pred x = length x > 0 && last x == b *Tree> depthfirstsearch pred tree1 Just "ab" *Tree> breadthfirstsearch pred tree1 Just "b"

27 Funktionale Programmierung (WS2005/2006) 3/27 Verallgemeinerung von map: map map und maptree unterscheiden sich nur in der Datenstruktur (Liste/Baum). Typkonstruktoren ür Listen ([]), Bäume (Tree) und andere Datenstrukturen sind sogenannte Funktoren ( Kategorientheorie). in Haskell gibt es eine Typklasse ür Funktoren: class Functor where map :: (a -> b) -> ( a -> b) Instanzen von Functor sollten olgende Bedingungen erüllen: (1) map id = id (2) map (. g) = map. map g

28 Funktionale Programmierung (WS2005/2006) 3/28 Listen instance Functor [] where map = map Prelude> map (^2) [2,3,4] [4,9,16] Bäume Instanzen von Functor instance Functor Tree where map = maptree *Tree> map (^2) (Node 3 [Node 4 [], Node 5 []]) Node 9 [Node 16 [],Node 25 []]

29 Funktionale Programmierung (WS2005/2006) 3/29 Maybe instance Functor Maybe where map Nothing = Nothing map (Just x) = Just ( x) Prelude> map (^2) (Just 3) Just 9 Arrays instance (Ix a) => Functor (Array a) where (a:indexmenge) map n (MkArray b ) = MkArray b (n. ) Prelude Array> map (^2) (array ((0,0),(1,1)) [((0,0),3),((0,1),6), ((1,0),5), ((1,1),2)]) array ((0,0),(1,1)) [((0,0),9),((0,1),36),((1,0),25),((1,1),4)]

30 Funktionale Programmierung (WS2005/2006) 3/30 Das Skelett Divide-and-Conquer (1) Paradigma Divide-and-Conquer: alls das Problem einach ist, löse es direkt sonst 1. teile das Problem in unabhängige Teile gleichen Typs 2. wende das Verahren rekursiv au jedes Teilproblem an 3. kombiniere die Lösungen der Teile zur Gesamtlösung

31 Funktionale Programmierung (WS2005/2006) 3/31 Das Skelett Divide-and-Conquer (2) Problem Problem Problem Problem Problem Problem Lösung Lösung Lösung Lösung Lösung Lösung

32 Funktionale Programmierung (WS2005/2006) 3/32 Das Skelett Divide-and-Conquer (3) dc :: (a->bool)->(a->b)->(a->[a])->(a->[b]->b)->a->b dc p b d c = dcprg where dcprg x = i p x then b x else c x (map dcprg (d x)) Instanzierung mit problemspeziischen Funktionen: 1. p::(a->bool) stellt est, ob das Problem einach ist 2. b::(a->b) löst das Problem direkt 3. d::(a->[a]) teilt das Problem in eine Liste von Teilproblemen 4. c::(a->[b]->b) verbindet die Teillösungen dcprg::(a->b) ist das resultierende Programm

33 Funktionale Programmierung (WS2005/2006) 3/33 Anwendung von dc (1): unktionales quicksort quicksort :: Ord a => [a] -> [a] quicksort = dc p b d c where p xs = length xs < 2 b xs = xs d (x:xs) = let (a,b) = partition (<x) xs in [a,b] c (x:_) [a,b] = a ++ (x : b)

34 Funktionale Programmierung (WS2005/2006) 3/34 Anwendung von dc (2): Damenproblem Eingabe: Anzahl der Zeilen/Spalten des Schach bretts Ausgabe: Liste aller Lösungen, bei jeder Lösung: Element i der Liste enthält Spaltenposition der Dame, die in Zeile i steht queens :: Int -> [[Int]] queens n = dc p b d c ([],[0..n-1]) where p (_,remain) = null remain b (placed,_) = [placed] d (placed,remain) = [ (placed++[i],ilter (/=i) remain) i <- remain, not (diagonal_attack i) ] where diagonal_attack i = or [ length placed - j == abs (i - placed!!j) j<-[0..length placed -1] ] c _ = concat

35 Funktionale Programmierung (WS2005/2006) 3/35 Skelett ramp (reduce-and-map-over-pairs) beschreibt wechselseitigen Einluß von Objekten ramp :: (a->a->b) -> (b->b->b) -> [a] -> [b] ramp g xs = map h xs where h x = oldr1 g (map ( x) xs) Anwendung: Simulation eines Systems von Planeten (nbody) nbody :: [Planet] -> [[Planet]] nbody ps = ps : nbody (map newpos (zip ps (ramp calcf sumfs ps))) newpos :: (Planet,Force) -> Planet neue Beschleunigung, Geschwindigkeit, Position calcf :: Planet -> Planet -> Force Gravitationskrat zwischen zwei Objekten sumfs :: Force -> Force -> Force Vektoraddition von Kräten