Grundlagen der Informatik I Thema 5: Abstraktion von Design

1. Grundlagen der Informatik IThema 5: Abstraktion von Design Prof. Dr. Max Mühlhäuser Dr. Guido Rößling

2. Überblick • Ähnlichkeiten in Definitionen • Funktionen sind Werte • Abstraktionen aus Beispielen entwerfen • Abstraktionen mit Funktionen als Werten entwerfen • Funktionen “ad hoc” definieren • “pipes-and-filters” Organisation von Berechnungen

3. Ähnlichkeiten in Definitionen • Viele Daten- und Funktionsdefinitionen sehen ähnlich aus: • Daten: Symbolliste, Zahlenliste, … • Funktionen: • Suche nach speziellem Symbol in einer Symbolliste • Suche nach spezieller Zahl in einer Zahlenliste • … • Wiederholungen sind die Quelle vieler Programmfehler • Der wichtigste Schritt beim Schreiben eines Programms ist Wiederholungen zu eliminieren. • Dieser Teil der Vorlesung behandelt folgende Punkte: • Ähnlichkeiten in Daten- und Funktionsdefinitionen • Designrezepte, um abstrakte Funktion zu entwerfen und Wiederholungen zu vermeiden • Die Rolle von Prozeduren höherer Ordnung in diesem Prozess

4. Ähnlichkeiten in Funktionen • Die Benutzung derzeitiger Designrezepte leiten die Schablone einer Funktion (die grundlegende Organisation) aus der Datendefinition der Eingabe ab. • Eine Schablone ist eine Methode, um auszudrücken, was wir über die Eingangsdaten wissen. • Konsequenz: Funktionen, die die gleiche Art Daten verarbeiten, ähneln sich Wenn Deine Datenstruktur richtig ist, schreibt sich der Rest des Programms von selbst. David Jones

5. Zwei ähnliche Funktionen ;; contains-doll? : los  ->  boolean ;; to determine whether alos contains ;; the symbol 'doll (define(contains-doll? alos) (cond [(empty? alos) false] [else (cond [(symbol=? (firstalos) 'doll) true] [else (contains-doll? (restalos ))])]))

6. Zwei ähnliche Funktionen ;; contains-car? : los  ->  boolean ;; to determine whether alos contains ;; the symbol 'car (define(contains-car? alos) (cond [(empty? alos) false] [else (cond [(symbol=? (firstalos) 'car) true] [else (contains-car? (restalos))])]))

7. Eine abstraktere Funktion Diese abstraktere Funktion konsumiert einen zusätzlichenParameter: das Symbol, nach dem wir suchen • Ansonsten gleicht sie den beiden Originalfunktionen ;; contains? : symbol los -> boolean;; todeterminewhetheraloscontainsthesymbol s (define (contains? s alos)(cond[(empty? alos) false][else (cond [(symbol=? (firstalos) s) true] [else (contains? s (restalos))])]))

8. Funktionale Abstraktion • Abstrakte Versionen von Funktionen zu definieren ist sehr nützlich: • Eine einzige Funktion kann viele verschiedene Aufgaben erfüllen: • contains?kann nach vielen verschiedenen Symbolen suchen, anstatt nur nach einem bestimmten • Eine einzige Funktion kann mehrere ähnliche Probleme auf einmal lösen • Den Prozess, zwei ähnliche Funktionen zu einer Definition zusammenzuführen, nennt man funktionale Abstraktion

9. Zwei weitere ähnliche Funktionen less-than ;; less-than: lon number -> lon ;; constructs a list of those numbers ;; in alon that are less than t (define (less-than alon t) (cond [(empty? alon) empty] [else (cond [(< (first alon) t) (cons (first alon) (less-than(rest alon) t))] [else (less-than(rest alon) t)])]))

10. Zwei weitere ähnliche Funktionen greater-than ;; greater-than: lon number  ->  lon ;; to construct a list of those numbers ;; in alon that are greater than threshold t (define (greater-than alon t) (cond [(empty? alon) empty] [else (cond [(> (first alon) t) (cons (first alon) (greater-than (rest alon) t))] [else (greater-than (rest alon) t)])]))

11. Abstraktion der zwei Funktionen • Der zusätzliche Parameter rel-op von filter1 steht für den konkreten relationalen Operator in less-thanund greater-than: (define (filter1rel-opalont) (cond [(empty?alon) empty] [else (cond [(rel-op (firstalon) t) (cons (firstalon) (filter1rel-op (restalon) t))] [else (filter1rel-op (restalon) t)])]))

12. Originalfunktionen aus der Abstraktion • Für filter1 müssen wir drei Argumente bereitstellen: • Einen relationalen Operator R, der zwei Zahlen vergleicht • Eine ListeL aus Zahlen, und eine Zahl N • Die Funktion liefert alle Werte i aus L, für die (R i N) zu true auswertet. • Wir können nun less-thanund greater-than sowie less-or-equal als „Einzeiler“ mit Hilfe von filter1 erhalten • Bei gleicher Eingabeergeben less-than1 bzw. greater-than1das gleiche wie less-than bzw. greater-than ;; less-than1:lonnumber  ->  lon (define(less-than1 alont) (filter1<alont)) ;; greater-than1:lonnumber  ->  lon (define(greater-than1alont) (filter1>alont)) ;; less-or-equal:lonnumber  ->  lon (define(less-or-equalalont) (filter1<=alont))

13. Wiederverwendung abstrakter Funktionen • Wir können eine abstrakte Funktion auch anders benutzen • Das erste Argument von filter1 kann irgendeine Funktion sein, die zwei Zahlen erhält und einen booleanWert ausgibt • Beispiele: • (filter1 = alon t): wählt alle Zahlen n aus alon, für die gilt: n = t • (filter1 <= alon t): Erzeugt eine Liste von Zahlen n aus alon, für die gilt: n<= t. • (filter1 >= alon t): Erzeugt die Liste von Zahlen >= t. • Wähle die Zahlen aus (1 2 3 4 5), deren Quadrat größer 10ist: (filter1squared>?(list12345) 10) ;; squared>?:numbernumber  ->  boolean (define (squared>?xc) (> (*xx) c))

14. Ähnlichkeiten bei der Datendefinition • Bei ähnlicher Datendefinition sind auch Funktionen ähnlich, die die Elemente dieser Datenklassen verarbeiten. (define-structir (nameprice)) Ein IR – InventoryRecord - ist eine Struktur:  (make-ir n p) wobeinein Symbol und peine Zahl ist.

15. Ähnlichkeiten bei der Datendefinition ;; less-than:numberlon  ->  lon ;; to construct a list of those numbers ;; on alon that are less than t (define(less-than alont) (cond [(empty?alon) empty] [else (cond [(< (firstalon) t) (cons (firstalon) (less-than(restalon) t))] [else(less-than (restalon) t)])]))

16. Ähnlichkeiten bei der Datendefinition ;; less-than-ir:numberloIR  ->  loIR ;; to construct a list of those records ;; on aloir that contain a price less than t (define(less-than-iraloirt) (cond [(empty?aloir) empty] [else (cond [(<ir (firstaloir) t) (cons (firstaloir) (less-than-ir(restaloir) t))] [else(less-than-ir(restaloir) t)])])) ;; <ir:IRnumber  ->  boolean (define (<irirp) (< (ir-priceir) p))

17. Polymorphe Funktionen • Beim Abstrahieren der zwei Funktionen erhalten wir filter1 • Wir können less-than-irmit filter1definieren: (define(less-than-ir1 aloir t)(filter1 <iraloir t)) • filter1filtert nicht nur Listen aus Zahlen,sondernauchListen aus beliebigenDingen • Solange wir eine Funktionen definieren können, die diese beliebigen Dinge mit Zahlen vergleicht • Noch abstrakter: Solange wir Funktionen definieren können, die Listenelemente mit Elementen vergleichen, die filter1als zweites Argument übergeben werden • Siehe die folgende Funktion …

18. Polymorphe Funktionen ;; find:loIRsymbol  ->  boolean ;; determines whether aloir contains a record for t (define (findaloirname) (cons? (filter1eq-ir?aloirname))) ;; eq-ir?:IRsymbol  ->  boolean ;; to compare ir's name and p (define (eq-ir?irp) (symbol=? (ir-nameir) p)) • filter1arbeitet einheitlich mit vielen Arten von Eingabedaten: • filter1,angewandt auf eine Liste von X, hat als Ergebnis auch eine Liste von X– egal aus welcher Art von Daten X besteht • Polymorpheoder generische Funktionen

19. Parametrische Datendefinitionen • Frage: Wie schreiben wir präzise Verträge für polymorphe Funktionen wie filter1? • Antwort: Benutze Datendefinitionen mit Parametern, auch parametrische Datendefinitionen genannt • Sie spezifizieren nicht alles über eine Datenklasse • Sie benutzen Variablen, um anzudeuten, dass alle Scheme-Daten an einer bestimmten Stelle benutzt werden können TYP VARIABLE • Steht für eine beliebige Sammlung von Scheme Daten: Symbole, IRs, etc. • Wird ITEM durch einen dieser Namen ersetzt, erhalten wir eine konkrete Instanz dieser abstrakten Datendefinition: • Listen von Symbolen, Listen von IRs, etc. • Eine Liste von ITEM ist • entweder empty • oder (cons s l) • s ist ein ITEM • l ist eine Liste von ITEM 

20. Verträge fürPolymorphe Funktionen • Beim Definieren von Verträgen besagt die Abkürzung (listof X), dass eine Funktion auf allen Listen funktioniert ;; length: (listofX)  ->  number ;; to compute the length of a list (define (lengthalox) (cond [(empty?alox) 0] [else (+ (length (restalox)) 1)])) • Xist nur eine Variable  ein Name, der für eine Datenklasse steht • Wenn wir lengthauf ein Element der Klassen (listofsymbol)oder(listof IR) anwenden, erhalten wir eine Zahl

21. Überblick • Ähnlichkeiten in Definitionen • Funktionen sind Werte • Abstraktionen aus Beispielen entwerfen • Abstraktionen mit Funktionen als Werten entwerfen • Funktionen “ad hoc” definieren • “pipes-and-filters” Organisation von Berechnungen

22. Der Wert von Prozeduren • Wir haben bereits die Vorteile der Prozeduren diskutiert: • Isolierte Implementierung eines Konzepts: „Separation ofConcerns“ statt Wiederholung von Code • Wiederverwendung von Code • Änderungen an nur einer Stelle, etc. • Ermöglicht Rekursion • Einheit für „Information Hiding“ • Die Prozeduren, die wir bisher verwendet haben, werden Prozeduren erster Ordnung (engl. „first order procedures“) genannt • In dieser Vorlesung haben wir eine neue Art von Prozeduren verwendet: Prozeduren höherer Ordnung • Prozeduren, die andere Prozeduren als Parameter konsumieren oder als Ergebnisse zurückliefern

23. Prozeduren als generelle Methoden • Prozeduren erster Ordnung: Machen Berechnungen unabhängig von den Werten bestimmter Daten (Zahlen, Symbole usw.) • Prozeduren höherer Ordnung: Drücken allgemeine Berechnungsmethoden unabhängig von den jeweiligen beteiligten Funktionen aus • Werfen wir einen systematischen Blick auf Prozeduren höherer Ordnung • Wir müssen zunächst die Definition vom Scheme anpassen • Funktionen höherer Ordnung verletzen die bisherige Definition • Wählen Sie von nun an in DrScheme das „Intermediate Student with Lambda“ Sprachlevel • Dann diskutieren wir weiter das Thema „Verträge für polymorphe Funktionen“

24. Funktionen von Funktionen verletztendie Sprachdefinitionen auf zwei Arten (filter1< (cons4empty) 5) Grund: Ein Argument ist ein Ausdruck und die Klasse der Ausdrücke enthält keine Funktionsnamen Verletzung 1: (define (findaloirt) (cons? (filter1eq-ir?aloirt))) Funktionsnamen als Argumente in Anwendungen

25. Funktionen von Funktionen verletzengrundlegende Sprachdefinitionen Verletzung 2: Parameter werden an der ersten Stelle von Anwendungen benutzt (als wären sie Funktionen) (define (filter1rel-opalont) (cond [(empty?alon) empty] [else (cond [(rel-op (firstalon) t) (cons (firstalon) (filter1rel-op (restalon) t))] [else (filter1rel-op (restalon) t)])])) Grund: Unsere Grammatik erlaubt nur Namen von Funktionen und primitiven Operationen an dieser Stelle, jedoch keine Parameter

26. Scheme anpassen • Die Namen von Funktionen und primitiven Operationen in die Definition von <exp> aufnehmen • An der ersten Position in einer Anwendung sollten nicht nur Funktionsnamen und primitive Operationen erlaubt werden: • Variablen, die Funktionsparametern entsprechen • Allgemeiner noch: Irgendein Ausdruck

27. Scheme anpassen • Die Anpassung der Grammatik, um Prozeduren höhere Ordnung zu unterstützen, verlängert die Grammatik nicht, sondern macht sie einfacher! Achtung: immer noch vereinfacht; viele Ersetzungen sind nicht gültig!

28. Scheme anpassen • Die Auswertungsregeln ändern sich nicht • Was sich ändert, ist die Menge von Werten: sie enthält die Namen von Funktionen

29. Verträge für abstrakte und polymorphe Funktionen • Wo liegt das Problem? • Unsere neuen Funktionen akzeptieren einen Typ von Werten, den wir vorher nie als Daten verwendet haben: • Primitive Operationen und andere Funktionen • Um Verträge für Funktionen höherer Ordnung schreiben zu können, benötigen wir eine Methode, um die neue Klasse von Werten beschreiben zu können • Daher haben wir das Schreiben von Verträgen für die Funktionen bisher aufgeschoben • Dieses Thema werden wir auf den folgenden Folien behandeln

30. Verträge für abstrakte und polymorphe Funktionen • Wir haben Verträge für Prozeduren erster Ordnung ;; rel-op:numbernumber  ->  boolean • Wir sagen “” beschreibt eine Klasse von Werten: die Klasse der Funktionen • Namen links von  ””  legen fest, worauf jedes Element in der Klasse der Funktionen angewendet werden darf • Der Name auf der rechten Seite von  ”” bestimmt, was jeder Wert der Klasse produzieren wird, wenn er auf die passenden Werte angewendet wird • Allgemein:(A B C)kennzeichnet die Klasse aller Funktionen, die ein Element aus A und eines aus Bkonsumieren und ein Element in C produzieren. • Sie sind Funktionen „von A und B nach C“

31. Beispiel: Vertragsdefinitionen Erste Version von filter1 ;; filter1: (numbernumber  ->  boolean) lonnumber  ->  lon ;; toconstructthelistofthosenumbersn on alonforwhich ;; (rel-opnt)evaluatestotrue (define (filter1rel-opalont) ...) Abstraktere Version von filter1 filter1: (Xnumber -> boolean) (listofX) number -> (listofX) X steht für eine beliebige Klasse von Scheme Daten. Wir könnenX mit irgendetwas ersetzen, so lange alle drei Vorkommen durch dasselbe ersetzt werden

32. Funktionen von Funktionen anwenden list-of-number Ist diese Anwendung sinnvoll? (filter1< (list3810) 2 ) (numbernumber -> boolean) Die zwei Klassen sind identisch zu den ersten beiden Argumentteilen des Vertrags von filter1, wennXdurchnumberersetzt wird. filter1: (Xnumber -> boolean) (list-of-X) number -> (list-of-X) Allgemein: Um sicher zu stellen, dass Argumente sinnvoll sind, müssen wir Ersetzungen für die Variablen in Verträgen finden, so dass der Vertrag und die Klassen der Argumente zusammen passen.

33. Eine neue Anwendung für filter1 • filter1 benutzen, um alle Spielzeuge mit gleichem Namen aus einer Liste von Inventareinträgen (inventory records) zu extrahieren: ;; find: (listofIR) symbol -> (listofIR) (define (findaloirt) (filter1eq-ir?aloirt)) ;; eq-ir?:IRsymbol -> boolean (define (eq-ir?irs) (symbol=? (ir-nameir) s)) • Problem: „Schwellen“-Argument sist ein symbol, nicht eine number Konflikt mit dem momentanen Vertrag von filter1 • Um das Problem zu lösen, führen wir eine neue Variable ein, THfür Schwellen (thresholds), welche für irgendeine Datenklasse steht: filter1: (XTH -> boolean) (listofX) TH -> (listofX)

34. Zusammenfassung: Verträge und Typen • Funktionsverträge bestehen aus Typen: • Basistyp, z.B. number, symbol, boolean, empty • Definierter Typ, z.B. inventory-record, list-of-numbers, family-tree • Funktionstyp, z.B. (number -> number) • Parametrischer Typ, entweder ein definierter Typ oder ein Funktionstyp mit Typvariablen • Um eine Funktion mit einem parametrischen Typ zu benutzen: • Finde Ersetzung für Variablen im Funktionsvertrag mit Typen, welche den Klassen der aktuellen Argumente entsprechen • Ist das nicht möglich, revidiere den Vertrag, oder stelle die Entscheidung in Frage, die Funktion wieder zu verwenden

35. Kurzdarstellung • Ähnlichkeiten in Definitionen • Funktionen sind Werte • Abstraktionen aus Beispielen entwerfen • Abstraktionen mit Funktionen als Werten entwerfen • Funktionen “ad hoc” definieren • “pipes-and-filters” Organisation von Berechnungen

36. Rezept für das Abstrahieren von Beispielen • Wir haben bereits Designs abstrahiert, z.B. aufgrund zweier konkreter Funktionsdefinitionen: • vergleiche sie, • kennzeichne die Unterschiede, • abstrahiere. • Jetzt formulieren wir diese Schritte als Rezept: • Vergleiche die Beispiele und rahme Unterschiede ein • Abstrahiere, falls die Rahmen Werte enthalten • Teste die Gültigkeit der Abstraktion • Formuliere den Vertrag der Abstraktion

37. Beispiele vergleichen • Wenn wir zwei Funktionsdefinitionen finden, die beinahe • gleich sind: • Vergleichen wir sie und markieren die Unterschiede in Kästchen • Wenn Kästchen Werte enthalten, können wir abstrahieren ;; names:loIR -> los (define (namesaloIR) (cond [(empty?aloIR) empty] [else (cons (IR-name (firstaloIR)) (names (restaloIR)))] )) Jedes Kästchen enthält einen Funktionswert, also können wir abstrahieren ...

38. Zwei Schritte der Abstraktion • Ersetze die Inhalte korrespondierender Kästchenpaare mit neuen Namen und füge diese Namen zur Parameterliste hinzu. • Es werden so viele Namen benötigt, wie es Kästchenpaare gibt (define (names faloIR) (cond [(empty?aloIR) empty] [else (cons (f (firstaloIR)) (names (restaloIR)))] ))

39. Zwei Schritte der Abstraktion • Die zwei Definitionen müssen jetzt dieselben sein, bis auf die Funktionsnamen • Um die Abstraktion zu erhalten, ersetze wir die Funktionsnamen systematisch mit einem neuen Namen mapstellt ein übliches Pattern für Operationen auf Listen dar  es abstrahiert über die Operation, die auf die Listenelemente angewandt werden soll

40. Die Abstraktion testen • Ziel: Sicherstellen, dass die neue Funktion eine korrekte Abstraktion der Originalfunktionen ist. • Vorgehen: • Definiere Originalfunktionen mittels Applikation der abstrakten Funktion • Teste die neuen Versionen mit den Beispielen, die beim Entwurf der Originalfunktionen formuliert wurden

41. Die Originalfunktionen als Spezialisierungder Abstraktion definieren • Annahmen: • Abstrakte Funktion heißtf-abstract • Eine Originalfunktion heißt f-original und erwartet ein Argument • Wenn sich f-original von der anderen konkreten Funktion in der Verwendung eines Wertes unterscheidet, z.B. boxed-value, dann definieren wir die folgende Funktion: • Für jeden zulässigen Wert V sollte folgendes gelten: (define (f-from-abstractx) (f-abstractboxed-valuex)) (f-from-abstract V) = (f-original V)

42. Die Originalfunktionen als Spezialisierungder Abstraktion definieren Um sicher zu stellen, dass diese beiden Definitionen zu den alten äquivalent sind, d.h. dass map eine korrekte Abstraktion ist, wende diese beiden Funktionen auf Beispiele an, die für die Entwicklung von convertCF und names spezifiziert wurden ;; convertCF-from-map:lon -> lon(define (convertCF-from-mapalon) (mapC->Falon)) ;; names-from-map:loIR -> los (define (names-from-mapaloIR) (mapIR-namealoIR))

43. Den Vertrag formulieren • Ziel: Einen Vertrag für die abstrakte Funktion formulieren • Hinweis: • Normalerweise kann man den Vertrag für die abstrakte Funktion nicht formulieren, indem man sie als Abstraktion der einen oder anderen Originalfunktion betrachtet Betrachten wir mapals Abstraktion von convertCF, so erhalten wir: (number -> number) (listofnumber) -> (listofnumber) Betrachten wir mapals Abstraktion von names, so erhalten wir: (IR -> symbol) (listofIR) -> (listofsymbol) Der erste Vertrag wäre nutzlos im zweiten Fall und umgekehrt

44. Allgemeine Verträge formulieren • Durch Betrachten der Definition sehen wir: • map wendet sein erstes Argument – eine Funktion f – auf jedes Element des zweiten Arguments – eine Liste l – an • Impliziert: • f muss die Daten verarbeiten, die l enthält • Daher hat f den Vertrag X ->???, wenn l Werte der Klasse X enthält • Wenn f Werte in Y produziert, dann produziert map eine Liste von Ys: map : (X -> Y) (listof X) -> (listof Y)

45. Neue Einsatzmöglichkeiten abstrakter Funktionen Eine abstrakte Funktion ist allgemein in einem breiteren Kontext nützlich, als zunächst angenommen: • So kann map jedesmal benutzt werden, wenn wir eine neue Liste durch Bearbeitung einer bestehenden Liste erzeugen möchten ;; list-of-squares: (listof numbers) -> (listof numbers) ;; constructs the list of squares of the elements of alon (define (list-of-squares alon) (cond [(empty? alon) empty] [else (cons (sqr (first alon)) (list-of-squares (rest alon)))])) (list-of-squares (list 1 2 3 4 5)) --> (list 1 4 9 16 25) (define (list-of-squares list) (map sqr list))

46. Verträge und neue Einsatzmöglichkeitenabstrakter Funktionen • Frage: Wie entdecken wir neue Einsatzmöglichkeiten abstrakter Funktionen? • Dafür gibt es kein Rezept • Es ist Übungssache, einen Blick dafür zu entwickeln, ob abstrakte Funktionen zu Situationen passen • Die Formulierung des Vertrags ist wichtig, um die Nützlichkeit einer abstrakten Funktion zu erhöhen: • Formuliere Verträge, welche die Anwendbarkeit abstrakter Funktionen im allgemeinst möglichen Kontext beschreiben

47. Allgemeine Verträge formulieren • Das Abstrahieren von Verträgen folgt dem gleichen Rezept wie das Abstrahieren von Funktionen: • Vergleiche Verträge von Beispielen, die wir abstrahieren wollen • Ersetze spezifische Klassen an korrespondierenden Positionen, eine nach der anderen, um den Vertrag allgemeiner zu machen • Überprüfe, ob der Vertrag die spezifischen Instanzen der abstrahierten Funktion richtig beschreibt  (number -> number) (listofnumber) -> (listofnumber) X Y (IR -> symbol) (listofIR) -> (listofsymbol) (X -> Y) (listof X) -> (listof Y)

48. [Wir erinnern uns…] • Prozeduren erster Ordnung: Machen Berechnungen unabhängig von den Werten bestimmter Daten (Zahlen, Symbole, usw.) • Prozeduren höherer Ordnung: Drücken allgemeine Berechnungsmethoden unabhängig von den jeweilig beteiligten Funktionen aus • Schauen wir uns an, was das bedeutet - am Beispiel von map …

49. map als Abstraktionsbarriere (define (list-of-squaresalon) (cond [(empty? alon) empty] [else (cons (sqr (firstalon)) (list-of-squares (restalon)))])) • Diese obige Version von list-of-squaresist aus zwei Gründen nicht optimal: • Sie hebt die Element-für-Element Verarbeitung der Listen hervor • Verrät zu viele Details über die Implementierung der Listen, darüber wie Listenelemente extrahiert und kombiniert werden • Die Operation, welche auf jedem Listenelement angewandt wird, ist fest verdrahtet

50. map als Abstraktionsbarriere (define (list-of-squares list) (map sqr list)) • Diemap-Versionvonlist-of-squaresunterdrücktdiesen Detaillevel • Siebetont,dass Quadrieren eine Transformationeiner Liste von Elementen in eine andere Liste ist • Höhere Abstraktionbeim Umgang mit Listen • Computer führt den gleichen Prozess aus • Wir denken anders über den Prozess!