5. Januar Universität Bielefeld AG Praktische Informatik. Programmieren in Haskell. Stefan Janssen. Abstrakte Datentypen.

Transkript

1 Universität Bielefeld AG Praktische Informatik 5. Januar 2015

2 Themen-Vorschau Module

3 In der Software-Entwicklung unterscheidet zwei Arten von : konkrete beziehen sich auf eine konkrete Repräsentation in der verwendeten Programmiersprache. Beispiele: Int, Char, Listen, Bäume; auch polymorphe sind konkret! abstrakte sind nicht an eine konkrete Repräsentation gebunden. Wie kann man dann überhaupt etwas definieren?

4 Ein abstrakter Datentyp (ADT) ist, unabhängig von einer Programmiersprache, eine (nicht weiter spezifizierte) Wertemenge mit Operationen auf dieser Wertemenge, die bestimmte Axiome (Gleichungen) erfüllen die Menge der Operationen ist die Schnittstelle (API) nach außen konkrete Repräsentation der Daten in der Implementierung ist nicht nach außen sichtbar (Kapselung)

5 Warum? mit ADTs erhöht die Wiederverwendbarkeit von Programmen Beispiel: ADT Verzeichnis Operationen auf Verzeichnissen: Erzeugen, Einfuegen, Loeschen, Sortieren, Bereinigen Programmierer, die Verzeichnisse verwenden, kennen NUR diese Operationen Verzeichnisse können konkret Listen, Bäume, Arrays,... sein, ggf. mit Zusatzoperationen Die konkrete Implementierung kann geändert werden, ohne dass andere Programme davon betroffen sind

6 spielen eine bedeutende Rolle in der Software-Entwicklung Alle modernen Programmiersprachen unterstützen ihre Verwendung Sie dienen der Spezifikation der nach außen sichtbaren Operationen und Eigenschaften Manchmal werden die Operationen mit Effizienzvorgaben verknüpft In werden abstrakte durch Module und durch Typklassen unterstützt. In Java/C++ geschieht dies durch Klassen ud Interfaces

7 Mini-ADT Llist Wir spezifizieren einen ADT Llist a analog zu Listen, dessen length-funktion die Komplexität O(1) haben soll. Operationen: empty : Llist a in O(1) (1) lcons : a Llista Llist a in O(1) (2) lhead : Llist a a in O(1) (3) ltail : Llist a Llist a in O(1) (4) llength : Llist a Int in O(1) (5) lapp : Llist a Llist a Llist a in O(n) (6)

8 Eigenschaften Eigenschaften der Operationen: lhead(lcons(x, xs)) = x (7) ltail(lcons(x, xs)) = xs (8) llength(lcons(x, empty)) = 1 (9) llength(lapp(xs, ys)) = llength(xs) + llength(ys)(10) lapp(x, empty) = x (11) und so weiter... Können wir das spontan implementieren? Können wir. Siehe Tafel.

9 Module Aus einigen Beispielen bekannt: Modulname Imports-Deklarationen Definitionen des Moduls

10 Module Aus einigen Beispielen bekannt: Modulname Imports-Deklarationen Definitionen des Moduls 1 > module Meinmodul 2 > where 3 > import Data. List 4 5 > splits n = [ splitat k [1.. n] k <- [1..n -1] ]

11 Modulaufbau Was bisher verschwiegen wurde E-Modul ist eine Datei, welche wie folgt eingeleitet wird: module <Name> (<Exportliste>) where Nur die und Funktionen, die in <Exportliste> angegeben werden, sind nach außen hin sichtbar Wenn <Exportliste> weggelassen wird, sind alle Definitionen nach außen sichtbar.

12 Exportieren von 1 module Liste ( List ) where 2 3 data List a = Nil 4 Cons a ( List a) Dies exportiert nur den Datentyp List, nicht aber die Konstruktoren Nil und Cons. Diese können in dem importierenden Modul nicht verwendet werden module Liste ( List ( Nil, Cons )) where exportiert auch die Konstruktoren alternativ: module Liste ( List (..)) where exportiert alle Konstruktoren eines Datentyps

13 ADT-Beispiel: Anhängen eines Elements am Ende einer Liste erfordert O(n) Schritte. erlauben diese Operation in O(1). Spezifikation: 1 > module Hlist ( Hlist,l2h,h2l, lcons, rcons, happ Holy) Lists whe 2 > l2h :: [a] -> Hlist a -- in O(n) 3 > h2l :: Hlist a -> [a] -- in O(n) 4 > lcons :: a - > Hlist a - > Hlist a -- in O (1) 5 > rcons :: Hlist a - > a - > Hlist a -- in O (1)

14 : Eigenschaften 1 Einige der erwarteten Eigenschaften: 2 l2h. h2l = id ( Konvertierung ) 3 h2l. l2h = id ( " )

15 : Eigenschaften 1 Einige der erwarteten Eigenschaften: 2 l2h. h2l = id ( Konvertierung ) 3 h2l. l2h = id ( " ) Implementierung??? Zum Nachdenken über die Feiertage! Tipp: holy kommt von hole Listen mit Loch am Ende...

16 Schöne Feiertage und Guten Rutsch PS: Purer Zufall, dass die HolyLists immer in die letzte Vorlesung vor Weihnachten fallen...

17 ADT 1 type Hlist a 2 empty :: Hlist a -- klassisch 3 cons :: a - > Hlist a - > Hlist a 4 append :: Hlist a - > Hlist a - > Hlist a 5 6 hcons :: Hlist a - > a - > Hlist a -- neu!! 7 8 l2h :: [a] -> Hlist a -- Konversion 9 h2l :: Hlist a -> [a]

18 Axiome für ADT Forderungen an die Implementierung: Alle Eigenschaften von (:), [], (++) sollen auch für cons, empty, append gelten. h2l. l2h == id hcons h a == l2h (h2l h ++ [a]) Konvertierung (l2h l) und (h2l h) in O(n) hcons h a in O(1) Die letzte Anforderung ist die eigentliche Herausforderung!

19 Lösungsvorschlag Implementierung siehe Datei Hlist.lhs Auszug: 1 Hlist - Listen mit effizientem Anfuegen vorne und h 2 Append - Funktion ebenfalls in O (1) 3 4 Specification 5 6 > module Hlist ( Hlist,l2h,h2l, lcons, rcons, happ ) whe 7 > l2h :: [a] -> Hlist a -- in O(n) 8 > h2l :: Hlist a -> [a] -- in O(n) 9 > lcons :: a - > Hlist a - > Hlist a -- in O (1) uns so weiter...

20 ADT-Beispiel: Ein ( Stapel oder auch Keller ) ist ein Datentyp, der eine Menge von gleichartigen Elementen aufnehmen kann. Er unterstützt fünf Operationen: emptystack: Liefert einen ohne Inhalt stackempty s: Fragt ob ein s leer ist push x s: Legt ein neues Element x auf den s pop s: Entfernt das oberste Element vom top s: Liefert das oberste Element des s s, ohne dieses zu entfernen Last-In-First-Out (LIFO)-Strategie: Das letzte Element, was auf den gelegt wurde, ist das erste, was wieder heruntergenommen wird.

21 -Schnittstelle 1 module (,push,pop,top, 2 empty, stackempty ) where 3 4 empty :: a 5 stackempty :: a - > Bool 6 push :: a - > a - > a 7 pop :: a - > a 8 top :: a -> a empty liefert einen neuen, leeren stackempty überprüft, ob der leer ist push legt ein Element auf den pop entfernt das oberste Element vom top liefert das oberste Element vom

22 -Implementierung (1) 1 > module (, empty, stackempty, pop, push, top ) 2 > data a = St [ a ] 3 4 > empty : : a 5 > empty = St [ ] 6 7 > stackempty : : a > Bool 8 > stackempty ( St [ ] ) = True 9 > stackempty ( St _) = F a l s e > push : : a > a > a 12 > push x ( St xs ) = St ( x : xs )

23 -Implementierung (1) 1 > module (, empty, stackempty, pop, push, top ) 2 > data a = St [ a ] 3 4 > empty : : a 5 > empty = St [ ] 6 7 > stackempty : : a > Bool 8 > stackempty ( St [ ] ) = True 9 > stackempty ( St _) = F a l s e > push : : a > a > a 12 > push x ( St xs ) = St ( x : xs ) Der Datentyp stack wird exportiert, aber nicht der Konstruktor St! NUR mittels Emptystack und push können s erzeugt werden. Alternative: module ((St), empty... oder auch module ((..), empty...

24 -Implementierung (2) 14 > pop : : a > a 15 > pop ( St [ ] ) = e r r o r " pop : empty! " 16 > pop ( St ( x : xs ) ) = St xs > top : : a > a 19 > top ( St [ ] ) = e r r o r " top : empty! " 20 > top ( St ( x : xs ) ) = x Inspektion und Abbau von s

25 Sicherheit... Welche Rolle spielt der Konstruktor St? unterhalb von St stehen immer nur einfache Listen eigentlich kann man ihn ganz weglassen, oder? wie z.b. in...

26 Schlichte s... 1 > module 2 (, empty, stackempty, pop, push, top ) 2 > type a = [ a ] 3 4 > empty : : a 5 > empty = [ ] 6 7 > stackempty : : a > Bool 8 > stackempty [ ] = True 9 > stackempty _ = F a l s e > push : : a > a > a 12 > push x xs = x : xs > pop : : a > a 15 > pop [ ] = e r r o r " pop : empty! " 16 > pop ( x : xs ) = xs > top : : a > a 19 > top [ ] = e r r o r " top : empty! " 20 > top ( x : xs ) = x

27 Der Unterschied... Den Unterschied sieht man mit Hugs an Ausdrücken wie push y empty empty ++ "nonono"

28 Der Unterschied... Den Unterschied sieht man mit Hugs an Ausdrücken wie push y empty empty ++ "nonono" Auf den schlichten s sind normale Listenoperationen ausführbar das will man gerade nicht, auch wenn es manchmal praktisch wäre, so wie im Falle von show.

29 Konvertierung Die erste Lösung ist also die bessere. Ggf. brauchen wir Konvertierungsfunktionen zwischen Listen und s. 1 > l2s :: [a] -> a 2 > s2l : a -> [a] Wo würde man die implementieren?

30 Konvertierung wo? Im Modul geht es einfach und effizient: 1 > l2s l = St l 2 > s2l (St l) = l

31 Konvertierung wo? Im Modul geht es einfach und effizient: 1 > l2s l = St l 2 > s2l (St l) = l außerhalb geht es auch recht einfach, aber weniger effizient: 1 > l2s = foldr push empty 2 > s2l s = if s == empty then [] 3 > else top s : s2l pop s Das liegt daran, dass wir außen nichts über die interne Implementierung wissen.

32 Beispiel: Warteschlangen realisiert der ADT. Eine (Schlange) arbeitet (im Gegensatz zum ) nach dem FIFO (First In First Out)-Prinzip das erste Element, das einer hinzugefügt wurde, ist auch das erste, das wieder entfernt wird Eine stellt die Operationen enqueue, dequeue und front bereit, sowie empty und queueempty.

33 -Schnittstelle 1 module (, empty, queueempty, 2 enqueue, dequeue, front ) where 3 4 empty :: a 5 queueempty :: a - > Bool 6 enqueue :: a - > a - > a 7 dequeue :: a - > a 8 front :: a - > a empty liefert eine neue queueempty überprüft, ob eine leer ist enqueue fügt einer ein neues Element hinzu dequeue entfernt das erste Element aus der front liefert das erste Element der

34 Implementierung (0) Vorüberlegung: Warum kann es nicht effizient werden, s einfach als Listen zu implementieren? Also z.b. als data a = Q [a]?

35 Implementierung (1) Moduldeklaration: 1 > module (, empty, queueempty, 2 > enqueue, dequeue, f r o n t ) where 3 4 > empty : : a 5 > queueempty : : a > Bool 6 > enqueue : : a > a > a 7 > dequeue : : a > a 8 > f r o n t : : a > a Auch hier wird kein Konstruktor exportiert!

36 Implementierung (1) Aufbau einer : 10 > data a = Q [ a ] [ a ] d e r i v i n g (Show, Eq) > empty = Q [ ] [ ] 13 > queueempty (Q [ ] [ ] ) = True 14 > queueempty _ = F a l s e > enqueue a (Q back f r o n t ) = Q ( a : back ) f r o n t

37 Implementierung (3) 17 Abbau einer : 18 > dequeue (Q [ ] [ ] ) = e r r o r " dequeue : queue empty! " 19 > dequeue (Q back [ ] ) = dequeue (Q [ ] ( r e v e r s e back ) ) 20 > dequeue (Q back ( a : f r o n t ) ) = Q back f r o n t > f r o n t (Q [ ] [ ] ) = e r r o r " f r o n t : queue empty! " 23 > f r o n t (Q back [ ] ) = f r o n t (Q [ ] ( r e v e r s e back ) ) 24 > f r o n t (Q back ( a : f r o n t ) ) = a Natürlich verwenden wir eine O(n)-Implementierung von reverse

38 : Effizienz? empty liefert eine neue queueempty überprüft, ob eine leer ist enqueue fügt einer ein neues Element hinzu dequeue entfernt das erste Element aus der front liefert das erste Element der Effizienzbetrachtung: Welchen Rechenaufwand haben die einzelnen Operationen? Was ist der Aufwand, wenn n Eintraege erzeugt, gelesen und entfernt werden?

39 : Effizienz? empty liefert eine neue queueempty überprüft, ob eine leer ist enqueue fügt einer ein neues Element hinzu dequeue entfernt das erste Element aus der front liefert das erste Element der Effizienzbetrachtung: Welchen Rechenaufwand haben die einzelnen Operationen? Was ist der Aufwand, wenn n Eintraege erzeugt, gelesen und entfernt werden? Amortisierte Effizienz von O(1) für dequeue.

40 Varianten Was ändert sich, wenn man front und dequeue zusammenlegt als frondeq:: a -> (a, a)?

41 Varianten Was ändert sich, wenn man front und dequeue zusammenlegt als frondeq:: a -> (a, a)? 1 > frondeq ( Q [] []) = error " front : empty queue!" 2 > frondeq (Q back []) = frondeq (Q [] ( reverse back )) 3 > frondeq ( Q back ( a: front )) = (a, Q back front )

42 Varianten Was ändert sich, wenn man front und dequeue zusammenlegt als frondeq:: a -> (a, a)? 1 > frondeq ( Q [] []) = error " front : empty queue!" 2 > frondeq (Q back []) = frondeq (Q [] ( reverse back )) 3 > frondeq ( Q back ( a: front )) = (a, Q back front ) Jedes Element wird nur einmal gelesen und nur einmal revertiert.

43 Varianten Was ändert sich, wenn man front und dequeue zusammenlegt als frondeq:: a -> (a, a)? 1 > frondeq ( Q [] []) = error " front : empty queue!" 2 > frondeq (Q back []) = frondeq (Q [] ( reverse back )) 3 > frondeq ( Q back ( a: front )) = (a, Q back front ) Jedes Element wird nur einmal gelesen und nur einmal revertiert. Nochmals die Sinnfrage: Warum kann man ohne abstrakte den Typ nicht korrekt implementieren?

44 Beispiel: Mengen Mengen sind ein recht schwieriger Datentyp. Eine Menge ist eine ungeordnete Sammlung von unterschiedlichen Elementen Ein Element kann auf Mitgliedschaft in einer Menge hin überprüft werden, kann einer Menge hinzugefügt oder aus einer Menge entfernt werden Was ist daran schwierig?

45 Mengen-Schnittstelle 1 module (, empty, setempty, in, 2 add, del ) where 3 4 empty :: a 5 setempty :: a - > Bool 6 in :: (Eq a) => a -> a -> Bool 7 add :: (Eq a) => a -> a -> a 8 del :: (Eq a) => a -> a -> a

46 Mengen-Schnittstelle 1 module (, empty, setempty, in, 2 add, del ) where 3 4 empty :: a 5 setempty :: a - > Bool 6 in :: (Eq a) => a -> a -> Bool 7 add :: (Eq a) => a -> a -> a 8 del :: (Eq a) => a -> a -> a empty erzeugt eine leere Menge setempty überprüft, ob die Menge leer ist in überprüft, ob ein Element in einer Menge enthalten ist add fügt ein Element der Menge hinzu del entfernt ein Element aus der Menge

47 Mengen-Implementierung Siehe Datei set.lhs

48 Synonyme: Multimenge Bag

49 Synonyme: Multimenge Bag die Elementpositionen spielen keine Rolle wie bei Unterschied zu Listen Elemente können vielfach enthalten sein Unterschied zu wie bei Listen

50 Multimenge die leere Multimenge, a die einelementige Multimenge, die genau ein Vorkommen von a enthält, x y die Vereinigung der Elemente von x und y; das + im Vereinigungszeichen deutet an, dass sich die Vorkommen in x und y akkumulieren. x = x = x y = x x y x (x y) z = x (y z)

51 Multimenge 1 bag :: [a] -> Bag a 2 bag [] = 3 bag (a:as) = a bag as Beobachtung Eine Liste x enthält alle Elemente von y, falls bag x = bag y. In diesem Fall heißt x Permutation von y.

52 r Datentyp Multimenge 1 module Bag ( Bag, emptybag, bagempty, inbag, 2 addbag, delbag, appendbag, 3 eqbag ) where 4 import List 5 6 emptybag :: Bag a 7 bagempty :: Bag a - > Bool 8 inbag :: Eq a = > a - > Bag a - > Bool 9 addbag :: Eq a = > a - > Bag a - > Bag a 10 delbag :: Eq a = > a - > Bag a - > Bag a 11 appendbag :: Bag a - > Bag a - > Bag a 12 eqbag :: Eq a = > Bag a - > Bag a - > Bool

53 r Datentyp Multimenge emptybag erzeugt eine neue Multimenge bagempty überprüft, ob eine Multimenge leer ist inbag überprüft, ob ein Element in der Multimenge enthalten ist addbag fügt ein Element einer Multimenge hinzu delbag löscht ein Element aus einer Multimenge appendbag vereinigt zwei Multimengen

54 r Datentyp Multimenge emptybag erzeugt eine neue Multimenge bagempty überprüft, ob eine Multimenge leer ist inbag überprüft, ob ein Element in der Multimenge enthalten ist addbag fügt ein Element einer Multimenge hinzu delbag löscht ein Element aus einer Multimenge appendbag vereinigt zwei Multimengen Was soll man von diesen Operationen halten? headbag gibt das erste Element aus der Multimenge aus tailbag entfernt das erste Element aus der Multimenge Siehe Datei bag.lhs

55 ADT-Fazit ADTs sind wesentlich für die nachhaltige Software-Entwicklung. Einzelne Programmteile können unabhängig voneinander entwickelt verbessert und erweitert ausgetauscht werden und haben klare Schnittstellen (auch für das Verstehen des Programms)