Programmieren in Haskell
Werbung
Universität Bielefeld Programmieren in Haskell Giegerich Programmieren in Haskell WS 2013/2014 Robert Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules Universität Bielefeld AG Praktische Informatik 8. Januar 2014 DatentypSpezifikationen Themen-Vorschau Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Pattern Matching: as-Patterns und lazy Patterns Client-Server-Programmierung Abstrakte Datentypen Module in Haskell Holy Lists Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Pattern Matching in Haskell Universität Bielefeld Programmieren in Haskell Pattern matching (alias Mustervergleich) kennen wir bereits Giegerich aus Funktionsgleichungen Pattern Matching aus case-Ausdrücken Lazy patterns Ein Pattern (Muster) ist ein Ausdruck bestehend aus Variablen, der anonymen Variablen _ (“Joker”) Konstruktoren aller Datentypen Zahlen, Characters ... also keine Funktionen, die nicht Konstruktoren sind ... und keine Variable mehrfach, ausgenommen _ Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Ergonomie des Pattern Matching in Haskell Universität Bielefeld Programmieren in Haskell Giegerich Pattern matching leistet zweierlei 1 2 3 Pattern Matching Fallunterscheidung in übersichtlicher Form Lazy patterns Nutzung der Reihenfolge bei überlappenden Mustern Prüfungen, Vorbereitung Bindung von Muster-Variablen an Substrukturen des geprüften Werts Abstrakte Datentypen Haskell Modules leaves ( Leaf a ) = [ a ] Datentypleaves ( Br ( Leaf a ) y ) = a : leaves y Spezifikationen leaves ( Br ( Br x y ) z ) = leaves ( Br x ( Br y z )) As-Patterns Manchmal will man Muster verwenden und einen Namen für den (unzerlegten) Argumentwert haben Universität Bielefeld Programmieren in Haskell Giegerich 1 2 suffixes ( x : xs ) = ( x : xs ): suffixes xs erzeugt eine überflüssige (:) Operation, vergeudet Zeit und verschwendet Platz. Besser mit as-pattern suffixes z@(x:xs) = z: suffixes xs Nun ist das schon vorhandene x:xs unter dem Namen z zu haben. Nebenbei: Welche Komplexität hat die Berechnung von suffixes x? Und welche die Ausgabe des Ergebnisses? Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Pattern Matching und Auswertungreihenfolge Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Vergleich eines Musters mit einem Wert erfordert, Lazy patterns dass der Wert ausgerechnet wird, Prüfungen, Vorbereitung aber nur soweit es für den Vergleich nötig ist (Laziness) Abstrakte Datentypen Verwendung von Mustern hat also Auswirkung auf die Berechenungsreihenfolge Haskell Modules DatentypSpezifikationen Abweisbare und nicht abweisbare Muster Universität Bielefeld Programmieren in Haskell a.k.a. refutable versus irrefutable patterns Ein Muster ohne Konstruktoren (also x, _ ) passt auf jedem Wert und heißt unabweisbar Ein Muster mit Konstruktoren heißt abweisbar 1 2 3 Ist eine Funktion mit unabweisbaren Mustern definiert, ist sie immer ein Redex. Beispiele: square x = x * x double f = f . f five _ = 5 NB: Man kann alle Funktionen auf der linken Seite mit unabweisbaren Mustern schreiben, wenn man stattdessen case-Ausdrücke auf der rechten Seite verwendet. Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Pattern Matching und Terminierung (1) Erinnerung: Die Auswertungsstrategie in einer funktionalen Sprache hat keinen Einfluss auf den ggf. berechneten Wert, wohl aber auf die Terminierung der Berechnung. Ein Mustervergleich kann positive oder negativ ausgehen, oder divergieren Alle Muster in einer Gleichung werde top-down, links-rechts verglichen Geht ein Vergleich negativ aus, ist die aktuelle Gleichung nicht anwendbar, und es wird die nachfolgende Gleichung versucht Ruft der Vergleich eine nicht-endende Berechnung hervor, divergiert er und das Ergebnis der Gesamtrechnung ist undefiniert. Passen alle Muster einer Gleichung, wird sie angewendet Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Bottom Universität Bielefeld Programmieren in Haskell Giegerich 1 Hier eine Definition des “undefinierten” Werts > bot = bot bot, ausgesprochen “bottom” ist der gänzlich undefinierte Wert. Seine Berechnung terminiert nicht, und produziert auch keinen Konstruktor. Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules Was wäre ein teilweise undefinierter Wert? Nebenbei: Welchen Typ hat bot? DatentypSpezifikationen Pattern Matching und Terminierung (2) Universität Bielefeld Programmieren in Haskell Giegerich 1 2 3 1 2 3 Vergleiche take 0 _ = [] take _ [] = [] take n ( x : xs ) = x : take (n -1) xs und mit vertauschten Zeilen take ’ _ [] = [] take ’ 0 _ = [] take ’ n ( x : xs ) = x : take ’ (n -1) xs Einen Unterschied gibt es nur, wenn eines der Argumente undefiniert ist ... Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Unterschiedliches Terminierungsverhalten Universität Bielefeld Programmieren in Haskell Giegerich 1 2 take 0 take ’ 0 bot bot = = > [] = = > undefiniert 5 Lazy patterns Prüfungen, Vorbereitung 3 4 Pattern Matching take bot [] take ’ bot [] = = > undefiniert = = > [] Abstrakte Datentypen Haskell Modules Der Haskell Prelude implementiert die Version take. DatentypSpezifikationen Lazy Patterns Universität Bielefeld Programmieren in Haskell a.k.a. Muster mit verzögertem Vergleich Problem: Man möchte eine Funktion mit einem Muster definieren und zwar für ein Argument, das durch die Anwendung der Funktion erst berechnet wird Zwar steht fest, dass das Muster erfüllt sein wird, jedoch zum Zeitpunkt der Funktionsaufrufs muss für den Mustervergleich die gleiche Funktion wieder aufgerufen werden ... Wo kommt so etwas überhaupt vor? Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Client-Server-Anwendungen Client-Server-Anwendungen sind parallel laufende Programme, die über Ströme kommunizieren Nachrichten an einander – Requests und Responses – werden wechselseitig erzeugt und gelesen Sie werden in “Strömen” (streams) verwaltet. Ströme sind in Haskell einfach lazy Listen, in andern Sprachen weden sie als spezieller Datentyp zur Verfügung gestellt. Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Zahlen raten als client-server Programm (1) Ratespiel: Finde eine Zahl n aus dem Intervall [0..N] durch Fragen der Art ”Ist n ≤ z?” mit geschickt gewählten Vergleichszahlen z. Rollenverteilung: Client: Erzeugt Fragen und merkt sich das Ergebnis. Seine Strategie: Intervall-Halbierung; sie führt garantiert in O(log(N)) Schritten zum Ziel. Server: Kennt n und beantwortet Fragen ”Ist n ≤ z?” mit True oder False. Der Server antwortet wahrheitsgemäß. (In einer interesssanteren Variante des Spiels darf er einmal lügen.) Kommunikation zwischen Client und Server über zwei Ströme: questions und answers. Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Zahlen raten als client-server Programm (2) Eine Frage hat die Form (l,g,u) und bedeutet ausführlich: “Ich weiß dass n ∈ [l..u] und frage ob n ≤ g.” g ist dabei die Intervallmitte, und wird, je nach Antwort, für die nächste Frage ins linke oder rechte Halbintervall verlegt. Das Ende erkennt der Client daran, dass das Intervall sich nicht mehr ändert. 1 2 3 4 5 > > > > > Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules minN = 0 DatentypSpezifikatiomaxN = 1024 nen −− t a k e d i f f [ ] = [ ] −− t a k e d i f f [ x ] = [ x ] t a k e d i f f ( x : y : x s ) = x : i f y == x then [ ] e l s e t a k e d i f f ( y : x s ) takediff nimmt den Präfix einer Liste bis zur ersten Wiederholung Zahlen raten als client-server Programm (2) Universität Bielefeld Programmieren in Haskell Wir definieren die Prozesse ask und reply, die über die Listen questions und answers kommunizieren. Giegerich Pattern Matching 1 2 3 4 patterns > guess n = t a k e d i f f (map ( \ ( _ , g , _) −> g ) q u e s t i o n s )Lazywhere Prüfungen, > answers = reply questions Vorbereitung > r e p l y ( ( _ , g , _ ) : q s ) = ( n <= g ) : r e p l y q s Abstrakte Datentypen 5 6 7 8 9 10 > > > > > q u e s t i o n s = a s k i n i t i a l a n s w e r s where Haskell Modules i n i t i a l = ( minN , (maxN + minN ) ‘ d i v ‘ 2 , maxN) a s k ( l , g , u ) ( a : a s ) = ( l , g , u ) : a s k n e w g u e s s a s where Datentypnewguess = i f a then ( l , (l + g ) ‘ d i vSpezifikatio‘ 2 , g) nen e l s e ( g +1, ( g+1 + u ) ‘ d i v ‘ 2 , u ) Diese Version funktioniert nicht – warum? Verklemmung! Universität Bielefeld Programmieren in Haskell Der Aufruf von ask (l,g,u) (a:as) Giegerich stellt eine Frage ((l,g,u)), Pattern Matching die von reply beantwortet wird (a) Lazy patterns fragt jedoch in seinem rechten Muster bereits nach dieser Antwort ((a:as)), um aus ihr die nächste Frage (newguess) zu generieren Das pattern matching beim Aufruf von ask kommt zu frueh: es verlangt ein Ergbnis von reply, bevor der gegebene Aufruf von ask das erste Element von questions generiert hat. reply seinerseits verlangt ein Ergebnis von ask ... Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Zahlen raten als client-server Programm (3) Vermeidung des übereifrigen Musters: 1 2 3 Universität Bielefeld Programmieren in Haskell Giegerich > > answers = reply questions r e p l y ( (_, g ,_ ) : qs ) = ( n <= g ) : r e p l y q s > > > > > > q u e s t i o n s = a s k i n i t i a l a n s w e r s where Prüfungen, i n i t i a l = ( minN , (maxN + minN ) ‘ d i v ‘ 2 , maxN) Vorbereitung a s k ( l , g , u ) a s = ( l , g , u ) : a s k n e w g u e s s ( t a i l a s ) where Abstrakte a = head a s Datentypen newguess = i f a then ( l , (l + g ) ‘ d i v ‘ 2 ,Haskell g) e l s e ( g +1, ( g+1 + u ) ‘ d i v ‘ 2 ,Modules u) Pattern Matching 4 5 6 7 8 9 10 Lazy patterns ask kann nun starten, ohne zuerst nach der Zerlegung der answers-Liste as zu fragen. Also kann die Frage ausgegeben und daraus die erste Antwort erzeugt werden, bevor mit head as nach ihr gefragt wird DatentypSpezifikationen Zahlen raten als client-server Programm (4) Der gleiche Effekt mit lazy pattern ~(a:as) O t h e r w i s e , t h e same a s s o l u t i o n ( 1 ) 1 Universität Bielefeld Programmieren in Haskell Giegerich 2 3 > guess ’ ’ n = t a k e d i f f (map ( \ ( _ , g , _) −> g ) q u e s t i o n s )Pattern where Matching 4 5 6 answers = reply questions r e p l y ( ( _ , g , _ ) : q s ) = ( n <= g ) : r e p l y q s > > > > > Abstrakte q u e s t i o n s = a s k i n i t i a l a n s w e r s where Datentypen i n i t i a l = ( minN , (maxN + minN ) ‘ d i v ‘ 2 , maxN) Haskell a s k ( l , g , u ) ~( a : a s ) = ( l , g , u ) : a s k n e w g u e s s a s where Modules newguess = i f a then ( l , (l + g ) ‘ d i vDatentyp‘ 2 , g) e l s e ( g +1, ( g+1 + u ) ‘ d i vSpezifikatio‘ 2 , u) 7 8 9 10 11 12 Lazy patterns > > Prüfungen, Vorbereitung nen der lazy pattern ~(a:as) wird beim Aufruf als erfüllt angenommen erst wenn a oder as gebraucht wird, findet der Abgleich statt. Lazy Patterns Universität Bielefeld Programmieren in Haskell Giegerich Lazy patterns, ~(...) sind unabweisbar. Ihre Überprüfung findet nur statt, wenn eine Komponente daraus gebraucht wird Scheitert sie, bricht die Rechnung ab. Eine weitere Mustergleichung nach einer Gleichung mit einem lazy Pattern macht also keinen Sinn. Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Top level pattern binding: immer lazy Universität Bielefeld Programmieren Werden Muster nicht auf Argumentposition, sondern in der in Haskell Definition von Konstanten benutzt, sind sie automatisch lazy: Giegerich fibp@(1:tfibp) = 1:1:[a+b | (a,b) <- zip fibp tfibp ] Hier haben wir einen as-Pattern, der eine konstante, unendliche Liste definiert, ... ... die Liste der Fibonacci-Zahlen. Das Muster bindet die Gesamtliste an den Namen fibp, zugleich ihren tail an den Namen tfibp die linke Seite fragt, ob die Liste nicht leer ist, aber dank der laziness des Musters wird dies erst geprüft, wenn tfibp rechts benutzt wird Vergleiche: let a@(1:as) = 1:[] in 2:a let a@(0:as) = 1:[] in 2:a Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Infos und Tipps zu den Prüfungen Universität Bielefeld Programmieren in Haskell Die Veranstaltungen des Moduls “Algorithmen und Datenstrukturen” werden gemeinsam in einer Modulabschluss-Prüfung geprüft. wissenschaftlicher Sinn einer Prüfung: Feststellen, ob ausreichende Grundlagen für weiterführende Veranstaltungen vorhanden sind. wissenschaftlich unsinnig, aber systemimmanent: Leistungsvergleich, Noten, peinliche Buchführung über den Ausbildungsgang zum Ausweis von Unterschieden Voraussetzung der Zulassung zur Prüfung sind 50% der Punkte aus den Übungen zu A&D+Haskell. Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Mündliche Prüfung zum Modul A&D Welche Veranstaltungen werden geprüft? A&D Vorlesung Programmieren in Haskell A&D + Haskell Übung Programmieren in der UNIX-Umgebung Wer prüft? Prüfer Beisitzer Wie lange? 20 Minuten Wann? siehe Termine Was muss mitgebracht werden? Personalausweis bzw. Pass Studentenausweis Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Prüfungsziel Universität Bielefeld Programmieren in Haskell Giegerich Test, inwieweit Veranstaltungsinhalte verstanden werden und angewendet werden können. Pattern Matching Lazy patterns Verschiedene Arten von Leistungen Prüfungen, Vorbereitung Reproduktion Abstrakte Datentypen Transfer (konkret) Haskell Modules Transfer (abstrakt) Prüfen auf eine möglichst gute Note hin. DatentypSpezifikationen Termine Universität Bielefeld Programmieren in Haskell Robert Giegerich 2. und 4. Februar-Woche, und ggf. später Alex Sczyrba 3. Februar-Woche, 3. März-Woche Terminvereinbarung bei Stefanie Lanfermann (M3-127) (Frau Lanfermann meldet die Prüfung im Dekanat an) weitere Prüfer: Prof. Dr. Stoye (mail an Heike Samuel) Prof. Dr. Hammer (14.,17.,18.2.) (mail an Gisela Weitekemper) Prof. Dr. Nattkemper (mail an Heike Samuel) Dr. Thies Pfeiffer (mail an Stefanie Lanfermann) Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Vorbereitung Universität Bielefeld Programmieren in Haskell Giegerich Materialien Vorlesungsfolien Übungsunterlagen Skript Prüfungsprotokolle, dabei jeweils beachten: Motivation Hintergrund Übungsgruppen Sprechstunden Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Ablauf Universität Bielefeld Programmieren in Haskell Giegerich Ausweiskontrolle Prüfer stellt die Fragen Beisitzer protkolliert hauptsächlich Einstiegsfrage nach ∼ 20 Minuten: Ende Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Student geht vor die Tür Haskell Modules Prüfer und Beisitzer beraten sich kurz DatentypSpezifikationen Student wird wieder hereingebeten Mitteilung der Note und Feedback 10 einfache Regeln zum Versemmeln einer Prüfung (G.Sauthoff) 1 2 3 4 5 6 7 8 9 10 erst 3 Tage vor dem Prüfungstermin mit der Vorbereitung beginnen alleine Lernen, obwohl das eigentlich noch nie gut geklappt hat bei der Vorbereitung das Skript ignorieren Verzicht auf eine aktive Bearbeitung der Übungen strikt vermeiden, ein Haskell-Programm selbst zu schreiben Inhalte auswendig lernen möglichst unausgeschlafen in die Prüfung kommen auf die Frage nach Unklarheiten vor dem Beginn der Prüfung am besten sehr lang und breit erklären, wie schlecht vorbereitet man doch ist kommunizieren, dass man die Begriffe in den Veranstaltungstiteln nicht erklären kann trotz Krankheit zur Prüfung erscheinen Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Weitere Angebote Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns ZSB bietet Workshops an eher allgemeine Hinweise vieles ist wahrscheinlich schon bekannt eher sinnvoll bei extremer Prüfungsangst o.Ä. Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Abstrakte Datentypen Universität Bielefeld Programmieren in Haskell Giegerich In der Software-Entwicklung unterscheidet zwei Arten von Datentypen: Pattern Matching Lazy patterns konkrete Datentypen beziehen sich auf eine konkrete Repräsentation in der verwendeten Programmiersprache. Beispiele: Int, Char, Listen, Bäume; auch polymorphe Datentypen sind konkret! abstrakte Datentypen sind nicht an eine konkrete Repräsentation gebunden. Wie kann man dann überhaupt etwas definieren? Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Abstrakte Datentypen Universität Bielefeld Programmieren in Haskell Giegerich 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) Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Warum? Universität Bielefeld Programmieren in Haskell Programmieren mit ADTs erhöht die Wiederverwendbarkeit von Programmen Beispiel: ADT Verzeichnis Giegerich Pattern Matching Lazy patterns Operationen auf Verzeichnissen: Prüfungen, Vorbereitung 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 Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Abstrakte Datentypen Universität Bielefeld Programmieren in Haskell Abstrakte Datentypen 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 Haskell werden abstrakte Datentypen durch Module und durch Typklassen unterstützt. In Java/C++ geschieht dies durch Klassen ud Interfaces Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Mini-ADT Llist Universität Bielefeld Programmieren in Haskell Wir spezifizieren einen ADT Llist a analog zu Listen, dessen length-Funktion die Komplexität O(1) haben soll. Operationen: Giegerich Pattern Matching Lazy patterns empty : → Llist a in O(1) (1) Prüfungen, Vorbereitung lcons : a × Llista → Llist a in O(1) (2) Abstrakte Datentypen lhead : Llist a → a in O(1) (3) Haskell Modules Llist a → Llist a in O(1) (4) Llist a → Int in O(1) (5) in O(n) (6) ltail : llength : lapp : Llist a × Llist a → Llist a DatentypSpezifikationen Eigenschaften Universität Bielefeld Programmieren in Haskell Eigenschaften der Operationen: lhead(lcons(x , xs)) = x ltail(lcons(x , xs)) = xs llength(lcons(x , empty )) = 1 Giegerich (7) (8) (9) llength(lapp(xs, ys)) = llength(xs) + llength(ys)(10) lapp(x , empty ) = x und so weiter ... Können wir das spontan implementieren? (11) Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Module in Haskell Universität Bielefeld Programmieren in Haskell Giegerich Aus einigen Beispielen bekannt: Modulname Imports-Deklarationen Definitionen des Moduls 1 2 3 4 5 > module Meinmodul > where > import Data . List Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen > splits n = [ splitAt k [1.. n ] | k <- [1.. n -1] ] Modulaufbau — Was bisher verschwiegen wurde Universität Bielefeld Programmieren in Haskell Giegerich Ein Haskell-Modul ist eine Datei, welche wie folgt eingeleitet wird: module <Name> (<Exportliste>) where Nur die Datentypen und Funktionen, die in <Exportliste> angegeben werden, sind nach außen hin sichtbar Wenn <Exportliste> weggelassen wird, sind alle Definitionen nach außen sichtbar. Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Exportieren von Datentypen 1 module Liste ( List ) where Universität Bielefeld Programmieren in Haskell Giegerich 2 3 4 data List a = Nil | Cons a ( List a ) Pattern Matching Dies exportiert nur den Datentyp List, nicht aber die Konstruktoren Nil und Cons. Diese können in dem importierenden Modul nicht verwendet werden Prüfungen, Vorbereitung module Liste ( List ( Nil , Cons )) where exportiert auch die Konstruktoren alternativ: module Liste ( List (..)) where exportiert alle Konstruktoren eines Datentyps Lazy patterns Abstrakte Datentypen Haskell Modules DatentypSpezifikationen ADT-Beispiel: Holy Lists Universität Bielefeld Programmieren in Haskell Giegerich Anhängen eines Elements am Ende einer Liste erfordert O(n) Schritte. “Holy Lists” erlauben diese Operation in O(1). Pattern Matching Lazy patterns Prüfungen, Vorbereitung 1 2 3 4 Abstrakte Spezifikation: Datentypen > module Hlist ( l2h , h2l , lcons , rcons ) where Haskell > l2h :: [a] -> Hlist a -- in O ( n )Modules > h2l :: Hlist a -> [ a ] -- in O ( n )DatentypSpezifikatio> lcons :: a -> Hlist a -> Hlist a -- in O (1)nen > rcons :: Hlist a -> a -> Hlist a -- in O (1) Holy Lists 5 Stack Queue Set Multi-Set Holy Lists: Eigenschaften Universität Bielefeld Programmieren in Haskell Giegerich 1 2 Einige der erwarteten Eigenschaften: l2h . h2l = id ( Konvertierung ) h2l . l2h = id ( " ) Lazy patterns Prüfungen, Vorbereitung 3 4 Pattern Matching reverse ( h2l ( rcons as a )) = a : h2l as Abstrakte Datentypen Haskell Modules Implementierung ??? Zum Nachdenken über die Feiertage! Tipp: “holy” kommt von “hole” – Listen mit “Loch” am Ende ... DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Schöne Feiertage und Guten Rutsch Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules Dieser Foliensatz wird noch weiter ergänzt im neuen Jahr. DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set ADT Holy Lists Universität Bielefeld Programmieren in Haskell Giegerich 1 2 3 4 Pattern type Hlist a Matching empty :: Hlist a -- klassisch Lazy patterns cons :: a -> Hlist a -> Hlist a Prüfungen, Vorbereitung append :: Hlist a -> Hlist a -> Hlist a Abstrakte Datentypen 5 6 hcons :: Hlist a -> a -> Hlist a -- neu !! l2h h2l :: [ a ] -> Hlist a :: Hlist a -> [ a ] -- Konversion Spezifikatio- Haskell Modules 7 8 9 Datentypnen Holy Lists Stack Queue Set Multi-Set Axiome für ADT Holy Lists Universität Bielefeld Programmieren in Haskell Giegerich 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! Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Lösungsvorschlag Universität Bielefeld Programmieren in Haskell Giegerich 1 2 Implementierung siehe Datei hlist.lhs Pattern Auszug: Matching Hlist - Listen mit effizientem Anfuegen vorneLazyund h patterns Append - Funktion ebenfalls in O (1) Prüfungen, Vorbereitung 3 4 5 6 7 8 9 Specification Abstrakte Datentypen Haskell Modules > module Hlist ( l2h , h2l , lcons , rcons ) where > l2h :: [a] -> Hlist a -- in O ( n )DatentypSpezifikatio> h2l :: Hlist a -> [ a ] -- in O ( n )nen > lcons :: a -> Hlist a -> Hlist a -- in O (1) uns so weiter ... Holy Lists Stack Queue Set Multi-Set ADT-Beispiel: Stack Ein Stack (“Stapel” oder auch “Keller”) ist ein Datentyp, der eine Menge von gleichartigen Elementen aufnehmen kann. Er unterstützt fünf Operationen: emptystack: Liefert einen Stack ohne Inhalt Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns stackEmpty s: Fragt ob ein Stack s leer ist Prüfungen, Vorbereitung push x s: Legt ein neues Element x auf den Stack s Abstrakte Datentypen pop s: Entfernt das oberste Element vom Stack Haskell Modules top s: Liefert das oberste Element des Stacks s, ohne dieses zu entfernen DatentypSpezifikationen Holy Lists Last-In-First-Out (LIFO)-Strategie: Das letzte Element, was auf den Stack gelegt wurde, ist das erste, was wieder heruntergenommen wird. Stack Queue Set Multi-Set Stack-Schnittstelle in Haskell 1 2 module Stack ( Stack , push , pop , top , emptyStack , stackEmpty ) where 3 4 5 6 7 8 emptyStack :: stackEmpty :: push :: a -> pop :: Stack top :: Stack Stack a Stack a -> Bool Stack a -> Stack a a -> Stack a a -> a emptyStack liefert einen neuen, leeren Stack stackEmpty überprüft, ob der Stack leer ist push legt ein Element auf den Stack Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue pop entfernt das oberste Element vom Stack Set Multi-Set top liefert das oberste Element vom Stack Stack-Implementierung (1) Universität Bielefeld Programmieren 1 2 > module S t a c k ( Stack , emptyStack , stackEmpty , pop , push ,in Haskell top ) > data S t a c k a = St [ a ] Giegerich 3 4 5 > emptyStack : : Stack a > e m p t y S t a c k = St [ ] Lazy patterns 6 7 8 9 > s t a c k E m p t y : : S t a c k a −> Bool > s t a c k E m p t y ( St [ ] ) = True > s t a c k E m p t y ( St _) = False 10 11 12 Pattern Matching > push : : a −> S t a c k a −> S t a c k a > push x ( St x s ) = St ( x : x s ) Der Datentyp stack wird exportiert, aber nicht der Konstruktor St! Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists NUR mittels Emptystack und push können Stacks erzeugt werden. Stack Queue Alternative: module Stack (Stack(St), emptyStack ... oder auch module Stack (Stack(..), emptyStack ... Set Multi-Set Stack-Implementierung (2) Universität Bielefeld Programmieren in Haskell Giegerich 14 15 16 > pop : : S t a c k a > pop ( St [ ] ) > pop ( St ( x : x s ) ) −> S t a c k a = e r r o r " pop : S t a c k empty ! " = St x s 17 18 19 20 > t o p : : S t a c k a −> a > t o p ( St [ ] ) = e r r o r " t o p : S t a c k empty ! " > t o p ( St ( x : x s ) ) = x Inspektion und Abbau von Stacks Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Sicherheit ... Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Welche Rolle spielt der Konstruktor St? unterhalb von St stehen immer nur einfache Listen Lazy patterns Prüfungen, Vorbereitung eigentlich kann man ihn ganz weglassen, oder? Abstrakte Datentypen wie z.B. in ... Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Schlichte Stacks... 1 2 Programmieren > module S t a c k 2 ( Stack , emptyStack , stackEmpty , pop , push , top ) in Haskell > type S t a c k a = [ a ] Giegerich 3 4 5 > emptyStack : : Stack a > emptyStack = [ ] 6 7 8 9 11 Lazy patterns Prüfungen, Vorbereitung > push : : a −> S t a c k a −> S t a c k a > push x xs = x : xs Haskell Modules 13 14 15 16 > pop : : S t a c k a −> S t a c k a > pop [] = e r r o r " pop : S t a c k empty ! " > pop ( x : x s ) = xs 19 20 Abstrakte Datentypen DatentypSpezifikationen Holy Lists Stack Queue Set 17 18 Pattern Matching > s t a c k E m p t y : : S t a c k a −> Bool > stackEmpty [] = True > stackEmpty _ = False 10 12 Universität Bielefeld > t o p : : S t a c k a −> a > top [] = e r r o r " t o p : S t a c k empty ! " > top ( x : xs ) = x Multi-Set Der Unterschied ... Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Den Unterschied sieht man mit Hugs an Ausdrücken wie push ’y’ emptyStack emptyStack ++ "nonono" Auf den “schlichten” Stacks sind normale Listenoperationen ausführbar – das will man gerade nicht, auch wenn es manchmal praktisch wäre, so wie im Falle von show. Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Konvertierung Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching 1 2 Die erste Lösung ist also die bessere. Ggf. brauchen wir Konvertierungsfunktionen zwischen Listen und Stacks. > l2s :: [ a ] -> Stack a > s2l : Stack a -> [ a ] Wo würde man die implementieren? Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Konvertierung wo? Universität Bielefeld Programmieren in Haskell Giegerich 1 2 1 2 3 Im Modul Stack geht es einfach und effizient: > l2s l = St l > s2l ( St l ) = l außerhalb geht es auch recht einfach, aber weniger effizient: > l2s = foldr push emptyStack l > s2l s = if s == emptyStack then [] > else top s : s2l pop s Das liegt daran, dass wir “außen” nichts über die interne Implementierung wissen. Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Beispiel: Queue Universität Bielefeld Programmieren in Haskell Giegerich Warteschlangen realisiert der ADT Queue. Eine Queue (Schlange) arbeitet (im Gegensatz zum Stack) nach dem FIFO (First In First Out)-Prinzip → das erste Element, das einer Queue hinzugefügt wurde, ist auch das erste, das wieder entfernt wird Eine Queue stellt die Operationen enqueue, dequeue und front bereit, sowie emptyQueue und queueEmpty. Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Queue-Schnittstelle in Haskell 1 2 Universität Bielefeld module Queue ( Queue , emptyQueue , queueEmpty , enqueue , dequeue , front ) where 3 4 5 6 7 8 emptyQueue queueEmpty enqueue dequeue front :: :: :: :: :: Queue a Queue a -> a -> Queue Queue a -> Queue a -> Programmieren in Haskell Giegerich Pattern Matching Bool a -> Queue a Queue a a emptyQueue liefert eine neue Queue queueEmpty überprüft, ob eine Queue leer ist enqueue fügt einer Queue ein neues Element hinzu Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue dequeue entfernt das erste Element aus der Queue Set Multi-Set front liefert das erste Element der Queue Queue Implementierung (0) Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Vorüberlegung: Warum kann es nicht effizient werden, Queues einfach als Listen zu implementieren? Also z.B. als data Queue a = Q [a] ? Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Queue Implementierung (1) Universität Bielefeld Programmieren in Haskell Giegerich 1 2 Moduldeklaration: Pattern Matching > module Queue ( Queue , emptyQueue , queueEmpty , > enqueue , dequeue , f r o n t ) where Lazy patterns 3 4 5 6 7 8 > > > > > emptyQueue queueEmpty enqueue dequeue front :: :: :: :: :: Queue a Queue a −> a −> Queue Queue a −> Queue a −> Bool a −> Queue a Queue a a Auch hier wird kein Konstruktor exportiert! Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Queue Implementierung (1) Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Aufbau einer Queue: 10 > data Queue a = Q [ a ] [ a ] d e r i v i n g ( Show , Eq ) 11 12 13 14 > emptyQueue > queueEmpty (Q [ ] > queueEmpty _ = Q [] [] [ ] ) = True = False 15 16 > e n q u e u e a (Q back f r o n t ) = Q ( a : back ) f r o n t Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Queue Implementierung (3) Universität Bielefeld Programmieren in Haskell Giegerich Abbau einer Queue: Pattern Matching 17 18 19 20 > d e q u e u e (Q [ ] [ ] ) = e r r o r " d e q u e u e : queue empty ! " Lazy patterns > d e q u e u e (Q back [ ] ) = d e q u e u e (Q [ ] ( r e v e r s e back )) Prüfungen, > d e q u e u e (Q back ( a : f r o n t ) ) = Q back f r o n t Vorbereitung 21 22 23 24 > f r o n t (Q [ ] [ ] ) > f r o n t (Q back [ ] ) > f r o n t (Q back ( a : f r o n t ) ) = e r r o r " f r o n t : queue emptyAbstrakte !" Datentypen = f r o n t (Q [ ] ( r e v e r s e backHaskell )) = a Modules DatentypSpezifikationen Natürlich verwenden wir eine O(n)-Implementierung von reverse Holy Lists Stack Queue Set Multi-Set Queue: Effizienz? Universität Bielefeld Programmieren in Haskell emptyQueue liefert eine neue Queue queueEmpty überprüft, ob eine Queue leer ist enqueue fügt einer Queue ein neues Element hinzu dequeue entfernt das erste Element aus der Queue front liefert das erste Element der Queue Effizienzbetrachtung: Welchen Rechenaufwand haben die einzelnen Operationen? Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Was ist der Aufwand, wenn n Eintraege erzeugt, gelesen und entfernt werden? Amortisierte Effizienz von O(1) für dequeue. Stack Queue Set Multi-Set Varianten Universität Bielefeld Programmieren in Haskell Was ändert sich, wenn man front und dequeue zusammenlegt als frondeq:: Queue a -> (a, Queue a) ? 1 2 3 > frondeq ( Q [] []) = error " front : empty queue ! " > frondeq ( Q back []) = frondeq ( Q [] ( reverse back )) > frondeq ( Q back ( a : front )) = (a , Q back front ) Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Jedes Element wird nur einmal gelesen und nur einmal revertiert. Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Nochmals die Sinnfrage: Warum kann man ohne abstrakte Datentypen den Typ Queue nicht korrekt implementieren? Stack Queue Set Multi-Set Beispiel: Mengen Universität Bielefeld Programmieren in Haskell Giegerich 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? Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Mengen-Schnittstelle in Haskell 1 2 module Set ( Set , emptySet , setEmpty , inSet , addSet , delSet ) where Universität Bielefeld Programmieren in Haskell Giegerich 3 4 5 6 7 8 emptySet setEmpty inSet addSet delSet :: :: :: :: :: Set Set ( Eq ( Eq ( Eq a a -> Bool a ) = > a -> Set a -> Bool a ) = > a -> Set a -> Set a a ) = > a -> Set a -> Set a emptySet erzeugt eine leere Menge setEmpty überprüft, ob die Menge leer ist inSet überprüft, ob ein Element in einer Menge enthalten ist Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set addSet fügt ein Element der Menge hinzu delSet entfernt ein Element aus der Menge Multi-Set Mengen-Implementierung Universität Bielefeld Programmieren in Haskell Giegerich Pattern Matching Lazy patterns Siehe Datei set.lhs Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Multi-Set Universität Bielefeld Programmieren in Haskell Synonyme: Multimenge Multi-Set Giegerich Pattern Matching Lazy patterns Bag Prüfungen, Vorbereitung die Elementpositionen spielen keine Rolle Abstrakte Datentypen → wie bei Set → Unterschied zu Listen Elemente können vielfach enthalten sein → Unterschied zu Set Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue → wie bei Listen Set Multi-Set Multimenge Universität Bielefeld Programmieren in Haskell ∅ die leere Multimenge, Giegerich *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. Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules ∅]x = x x ]∅= x x ]y = y ]x (x ] y ) ] z = x ] (y ] z) DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Multimenge Universität Bielefeld Programmieren in Haskell Giegerich 1 2 3 bag :: [ a ] -> Bag a bag [] = ∅ 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 . Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Abstrakter Datentyp Multimenge Universität Bielefeld Programmieren in Haskell 1 2 3 4 module Bag ( Bag , emptyBag , bagEmpty , inBag , addBag , delBag , appendBag , eqBag ) where import List 5 6 7 8 9 10 11 12 emptyBag bagEmpty inBag addBag delBag appendBag eqBag :: :: :: :: :: :: :: Bag a Bag a -> Bool Eq a = > a -> Bag a -> Bool Eq a = > a -> Bag a -> Bag a Eq a = > a -> Bag a -> Bag a Bag a -> Bag a -> Bag a Eq a = > Bag a -> Bag a -> Bool Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set Abstrakter Datentyp Multimenge Universität Bielefeld Programmieren in Haskell 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? Giegerich Pattern Matching Lazy patterns Prüfungen, Vorbereitung Abstrakte Datentypen Haskell Modules DatentypSpezifikationen headBag gibt das erste Element aus der Multimenge aus Holy Lists tailBag entfernt das erste Element aus der Multimenge Queue Siehe Datei bag.lhs Stack Set Multi-Set ADT-Fazit Universität Bielefeld Programmieren in Haskell Giegerich ADTs sind wesentlich für die nachhaltige Software-Entwicklung. Einzelne Programmteile können unabhängig voneinander Pattern Matching Lazy patterns entwickelt Prüfungen, Vorbereitung verbessert und erweitert Abstrakte Datentypen ausgetauscht werden Haskell Modules und haben klare Schnittstellen (auch für das Verstehen des Programms) DatentypSpezifikationen Holy Lists Stack Queue Set Multi-Set
