Upload
haduwig-zillmer
View
109
Download
2
Embed Size (px)
Citation preview
Telecooperation/RBG
Technische Universität Darmstadt
Copyrighted material; for TUD student use only
Grundlagen der Informatik IThema 5: Abstraktion von Design
Prof. Dr. Max MühlhäuserDr. Guido Rößling
1
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ü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
2
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ä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 3
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ä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
4
Wenn Deine Datenstruktur richtig ist,schreibt sich der Rest des Programms von selbst.
David Jones
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Zwei ähnliche Funktionen
5
;; contains-doll? : los -> boolean ;; to determine whether alos contains ;; the symbol 'doll
(define ( contains-doll? alos) (cond [(empty? alos) false] [else (cond [(symbol=? (first alos) 'doll) true] [else ( contains-doll? (rest alos ))])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Zwei ähnliche Funktionen
6
;; contains-car? : los -> boolean ;; to determine whether alos contains ;; the symbol 'car
(define ( contains-car? alos) (cond [(empty? alos) false] [else (cond [(symbol=? (first alos) 'car ) true] [else ( contains-car? (rest alos))])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Eine abstraktere FunktionDiese abstraktere Funktion konsumiert einen zusätzlichenParameter: das Symbol, nach dem wir suchen
– Ansonsten gleicht sie den beiden Originalfunktionen
7
;; contains? : symbol los -> boolean
;; to determine whether alos contains the symbol s
(define (contains? s alos)
(cond
[(empty? alos) false]
[else (cond
[(symbol=? (first alos) s) true]
[else
(contains? s (rest alos))])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
8
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Zwei weitere ähnliche Funktionen
9
;; less-than: lon number -> lon ;; to construct 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)])]))
less-than
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Zwei weitere ähnliche Funktionen
10
;; greater-than: lon number -> lon;; to construct a list of those numbers ;; in alon that are greater than 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)])]))
greater-than
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Abstraktion der zwei Funktionen
• Der zusätzliche Parameter rel-op von filter1 steht für den konkreten relationalen Operator in less-than und greater-than:
11
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Originalfunktionen aus der Abstraktion
• Für filter1 müssen wir 3 Argumente bereitstellen: – Einen relationalen Operator R, der zwei Zahlen
vergleicht– Eine Liste L aus Zahlen, und eine Zahl N
• Die Funktion liefert alle Werte i aus L, für die (R i N) zu true auswertet.
12
;; less-than: lon number -> lon (define (less-than1 alon t) (filter1 < alon t))
;; greater-than1: lon number -> lon (define (greater-than 1alon t) (filter1 > alon t))
• Wir können nun less-than und greater-than als „Einzeiler“ mit Hilfe von filter1 erhalten– Bei gleicher Eingabe ergeben less-than1 bzw. greater-than 1das gleiche wie less-than bzw. greater-than
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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 boolean Wert 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ählt die Zahlen aus (1 2 3 4 5), deren Quadrat größer 10 ist.
13
;; squared>? : number number -> boolean (define (squared>? x c) (> (* x x) c))
(filter1 squared>? (list 1 2 3 4 5) 10)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ähnlichkeiten bei der Datendefinition
• Bei ähnlicher Datendefinition sind auch Funktionen ähnlich, die die Elemente dieser Klasse verarbeiten.
14
Eine list-of-numbers ist• entweder empty • oder (cons n l)
• n ist eine Zahl• l ist eine list-of-numbers
Eine list-of-IRs ist• entweder empty • oder (cons n l)
• n ist ein IR • l ist eine list-of-IRs
(define-struct ir (name price))
Ein IR – Inventory Record - ist eine Struktur: (make-ir n p)
wobei n ein Symbol und p eine Zahl ist.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ähnlichkeiten bei der Datendefinition
15
;; less-than: number lon -> lon ;; to construct a list of those numbers ;; on 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)])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ähnlichkeiten bei der Datendefinition
16
;; <ir : IR number -> boolean
(define (<ir ir p) (< (ir-price ir) p))
;; less-than-ir : number loIR -> loIR ;; to construct a list of those records ;; on aloir that contain a price less than t
(define (less-than-ir aloir t) (cond [(empty? aloir) empty] [else (cond
[(<ir (first aloir) t)
(cons (first aloir) (less-than-ir (rest aloir) t))] [else (less-than-ir (rest aloir) t)])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Polymorphe Funktionen
• Beim Abstrahieren der zwei Funktionen erhalten wir filter1
• Wir können less-than-ir mit filter1 definieren:
17
(define (less-than-ir1 aloir t)(filter1 <ir aloir t))
• filter1 filtert nicht nur Listen aus Zahlen, sondern auch Listen aus beliebigen Dingen– 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 filter1 als zweites Argument übergeben werden• Siehe die folgende Funktion …
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Polymorphe Funktionen
18
;; find : loIR symbol -> boolean ;; determines whether aloir contains a record for t (define (find aloir name) (cons? (filter1 eq-ir? aloir name)))
;; eq-ir? : IR symbol -> boolean ;; to compare ir's name and p (define (eq-ir? ir p) (symbol=? (ir-name ir) p))
• filter1 arbeitet 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
• Polymorphe oder generische Funktionen
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
19
• 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
TYP VARIABLE
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Verträge für Polymorphe Funktionen
• Beim Definieren von Verträgen besagt die Abkürzung (listof X), dass eine Funktion auf allen Listen funktioniert
20
;; length : (listof X) -> number ;; to compute the length of a list (define (length alox) (cond [(empty? alox) 0] [else (+ (length (rest alox)) 1)]))
• X ist nur eine Variable ein Name, der für eine Datenklasse steht
• Wenn wir length auf ein Element der Klassen (listof symbol) oder (listof IR) anwenden, erhalten wir eine Zahl
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ü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
21
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Der Wert von Prozeduren• Wir haben bereits die Vorteile der Prozeduren
diskutiert:– Isolierte Implementierung eines Konzepts: „Separation of
Concerns“ 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ückliefern22
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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“
23
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen von Funktionen verletztendie Sprachdefinitionen auf zwei Arten
24
(define (find aloir t) (cons? (filter1 eq-ir? aloir t)))
Verletzung 1: (filter1 < (cons 4 empty) 5)
Funktionsnamen als Argumente in Anwendungen
<var><fct>
== x | alon | ... area-of-disk | perimeter | ...
<exp> = <var>
| <con>
| (<prm> <exp> ...<exp>)
| (<fct> <exp> ...<exp>)
| (cond (<exp> <exp>) ...(<exp> <exp>))
| (cond (<exp> <exp>) ...(else <exp>))| ...
Grund: Ein Argument ist ein Ausdruck und die Klasse der Ausdrücke enthält keine Funktionsnamen
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen von Funktionen verletzengrundlegende Sprachdefinitionen
Verletzung 2:
25
Parameter werden an der ersten Stelle von Anwendungen benutzt (als wären sie Funktionen)
Grund: Unsere Grammatik erlaubt nur Namen von Funktionen und primitiven Operationen an dieser Stelle, jedoch keine Parameter
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
<exp> = <var>
| <con> | <prm> | <fct>
| (<exp> <exp> ...<exp>)
Scheme anpassen
1. Die Namen von Funktionen und primitiven Operationen in die Definition von <exp> aufnehmen
2. An der ersten Position in einer Anwendung sollten nicht nur Funktionsnamen und primitive Operationen erlaubt werden:– Variablen, die Funktionsparametern entsprechen– Allgemeiner noch: Irgendein Ausdruck
26
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Scheme anpassen
• Die Anpassung der Grammatik, um Prozeduren höhere Ordnung zu unterstützen, verlängert die Grammatik nicht, sondern macht sie einfacher!
27
<exp> = <var> | <con>
| <prm> | <fct>
| (<exp> <exp> ...<exp>)
<exp> = <var>
| <con>
| (<prm> <exp> ...<exp>) | (<fct> <exp> ...<exp>)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Scheme anpassen
•Auswertungsregeln ändern sich nicht•Was sich ändert, ist die Menge von Werten: sie enthält die Namen von Funktionen und primitiven Operationen
28
<val> = <boo> | <sym> | <num> | empty | <lst>
| <var> (names of defined functions)
| <prm> | <fct>
<lst> = empty | (cons <val> <lst>)
<val> = <con>
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Verträge für abstrakte und polymorphe Funktionen
• Wir haben Verträge für Prozeduren erster Ordnung
31
;; rel-op : number number -> boolean
• Wir sagen “” beschreibt eine Klasse von Werten: die Klasse der Funktionen – Namen links von ”” legen fest, worauf jeder
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 B konsumieren und ein Element in C produzieren.– Sie sind Funktionen „von A und B nach C“
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Beispiel: Vertragsdefinitionen
Erste Version von filter1
32
;; filter1 : (number number -> boolean) lon number -> lon ;; to construct the list of those numbers n on alon for which ;; (rel-op n t) evaluates to true
(define (filter1 rel-op alon t) ...)
Abstraktere Version von filter1filter1 : (X number -> boolean) (listof X) number -> (listof X)
X steht für eine beliebige Klasse von Scheme Daten. Wir können X mit irgendetwas ersetzen, so lange alle drei Vorkommen durch dasselbe ersetzt werden
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen von Funktionen anwenden
Ist diese Anwendung sinnvoll?
33
filter1 : (X number -> boolean) (listof X) number -> (listof X)
(number number -> boolean)
listof number
(filter1 < (list 3 8 10) 2 )
Die zwei Klassen sind identisch zu den ersten beiden Argumentteilen des Vertrags von filter1, wenn X durch number ersetzt wird.
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.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Eine neue Anwendung für filter1
• filter1 benutzen, um alle Spielzeuge mit gleichem Namen aus einer Liste von Inventareinträgen (inventory records) zu extrahieren:
34
;; find : (listof IR) symbol -> (listof IR) (define (find aloir t) (filter1 eq-ir? aloir t)) ;; eq-ir? : IR symbol -> boolean (define (eq-ir? ir s) (symbol=? (ir-name ir) s))
• Problem: „Schwellen“-Argument s ist 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, TH für Schwellen (thresholds), welche für irgendeine Datenklasse steht: filter1 :(X TH -> boolean) (listof X) TH -> (listof X)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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: 1. Vergleiche die Beispiele und rahme Unterschiede ein2. Abstrahiere, falls die Rahmen Werte enthalten3. Teste die Gültigkeit der Abstraktion4. Formuliere den Vertrag der Abstraktion
37
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
;; convertCF : lon -> lon (define (convertCF alon) (cond [(empty? alon) empty] [else (cons (C->F (first alon)) (convertCF (rest alon))]))
;; names : loIR -> los (define (names aloIR) (cond [(empty? aloIR) empty] [else (cons (IR-name (first aloIR)) (names (rest aloIR)))]))
Beispiele vergleichen
38
Wenn Sie zwei Funktionsdefinitionen finden, die beinahe
gleich sind:• Vergleiche sie und markieren die Unterschiede in Kästchen• Wenn Kästchen Werte enthalten, können wir abstrahieren
Jedes Kästchen enthält einen Funktionswert, also können wir abstrahieren ...
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
(define (names f aloIR) (cond [(empty? aloIR) empty] [else (cons (f (first aloIR)) (names (rest aloIR)))]))
(define (convertCF f alon) (cond [(empty? alon) empty] [else (cons (f (first alon)) (convertCF (rest alon)))]))
Zwei Schritte der Abstraktion
1. Ersetze die Inhalte korrespondierender Kästchenpaare mit neuen Namen und füge diese Namen zur Parameterliste hinzu. – Es werden soviele Namen benötigt, wie es
Kästchenpaare gibt
39
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Zwei Schritte der Abstraktion2. Die zwei Definitionen müssen jetzt dieselben sein,
bis auf die Funktionsnamen– Um die Abstraktion zu erhalten, ersetze die
Funktionsnamen systematisch mit einem neuen Namen
40
(define (map f lon) (cond [(empty? lon) empty] [else (cons (f (first lon)) (map f (rest lon)))]))
map stellt ein übliches Pattern für Operationen auf Listen dar es abstrahiert über die Operation, die auf die Listenelemente angewandt werden soll
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Die Originalfunktionen als Spezialisierung
der Abstraktion definieren• Annahmen:
– Abstrakte Funktion heißt f-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:
42
(define (f-from-abstract x) (f-abstract boxed-value x))
(f-from-abstract V) = (f-original V)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Die Originalfunktionen als Spezialisierung
der 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 43
;; convertCF-from-map : lon -> lon (define (convertCF-from-map alon) (map C->F alon))
;; names-from-map : loIR -> los (define (names-from-map aloIR) (map IR-name aloIR))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
44
Betrachten wir map als Abstraktion von names, so erhalten wir:
(number -> number) (listof number) -> (listof number)
Betrachten wir map als Abstraktion von convertCF, so erhalten wir:
(IR -> symbol) (listof IR) -> (listof symbol)
Der erste Vertrag wäre nutzlos im zweiten Fall und umgekehrt
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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:
45
map : (X -> Y) (listof X) -> (listof Y)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
46
;; 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)))]))
(define (list-of-squares list) (map sqr list))
(list-of-squares (list 1 2 3 4
5))--> (list 1 4 9 16 25)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
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
48
(number -> number) (listof number) -> (listof number)
(IR -> symbol) (listof IR) -> (listof symbol)
(X -> Y) (listof X) -> (listof Y)
X Y
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
[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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
map als Abstraktionsbarriere
50
(define (list-of-squares alon) (cond [(empty? alon) empty] [else (cons (sqr (first alon)) (list-of-squares (rest alon)))]))
• Diese obige Version von list-of-squares ist 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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
map als Abstraktionsbarriere
51
• Die map-Version von list-of-squares unterdrückt dieses Detaillevel– Sie betont, dass Quadrieren eine Transformation
einer Liste von Elementen in eine andere Liste ist– Höhere Abstraktion beim Umgang mit Listen
• Computer führt den gleichen Prozess aus• Wir denken anders über den Prozess!
(define (list-of-squares list) (map sqr list))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen höherer Ordnungals Abstraktionsbarrieren:
Beispiel von map• Eine Abstraktionsbarriere isoliert die
Implementierung von Prozeduren, die Listen transformieren, von den Details, wie die Elemente der Liste extrahiert und kombiniert werden
52
Unwichtige Details, wie Sequenzen implementiert sind
MAP
Operation, die Sequenzen in Sequenzen umwandelt
• Man kann die Implementierung der Listen unabhängig von der Umwandlungsfunktion variieren
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Benutzung von map für Bäume
map zusammen mit Rekursion ist eine mächtige Abstraktion, um baumartige Datenstrukturen zu bearbeiten
53
;; scale-tree : (treeof numbers) number -> (treeof numbers);; constructs a new list by multiplying ;; each element of tree by num(define (scale-tree tree num) (map (local ((define (scale-st sub-tree) (cond [(cons? sub-tree) (scale-tree sub-tree num)] [else (* sub-tree num)]))) scale-st) tree))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Abstrahieren von Schablonen • Beim Design von Funktionen orientieren wir uns an
die Schablone der Datendefinition– Definitionen sehen ähnlich aus; wir abstrahieren
sie– Wir könnten direkt von den Schablonen
abstrahieren
54
(define (fun-for-l l) (cond [(empty? l) ...] [else ... (first l) ... (fun-for-l (rest l)) ...]))
Eine list-of-numbers ist:• entweder empty • oder (cons n l) wo
• n is a number• l is a list-of-numbers
• Um eine konkrete Funktion f abzuleiten, füllen wir zwei Lücken:– Im ersten Fall setzen wir typischerweise einen konkreten
Wert ein– Im zweiten Fall kombinieren wir (first l) mit (f (rest
l))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Abstrahieren von Schablonen
55
;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))]))
;; sum : (listof number) -> number (define (sum lst) (fold 0 + lst))
;; product : (listof number) -> number (define (product lst) (fold 1 * lst))
• fold stellt ein übliches Pattern für Operationen auf Listen dar
• Anwendung einer binären Operation auf dem ersten Element und auf dem Ergebnis der Anwendung von fold auf dem Rest der Liste
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
[Notiz: Zusammenfalten in Scheme]
“Zusammenfalten” ist eine sehr häufige Operation über Listen, so dass es dafür zwei vordefinierte Funktion in Scheme gibt:
–foldr faltet zusammen von rechts nach links–foldl faltet zusammen von links nach rechts
56
;; foldr : (X Y -> Y) Y (listof X) -> Y
;; (foldr f base (list x-1 ... x-n)) =
;; (f x-1 ... (f x-n base))
(define (foldr f base alox) ...)
;; foldl : (X Y -> Y) Y (listof X) -> Y
;; (foldl f base (list x-1 ... x-n)) =
;; (f x-n ... (f x-1 base))
(define (foldl f base alox) ...)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
sort von fold ableiten
57
Können wir fold verwenden, um Listen zu sortieren?
Erinnern wir uns an insertion sort…
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
[Erinnerung insert]
58
eli,i = [1… j], eli <= nelj+1 elj+2 ... eln
alon
n
n
insert für den Fall, dass alon nicht leer ist:Überspringe alle Elemente in alon bis zu dem ersten Element von alon, ej+1, das größer ist als n. Füge nzwischen elj und elj+1
ein.
;; insert : number list-of-numbers -> list-of-numbers
(define (insert n alon)
(cond
[(empty? alon) (cons n empty)]
[(<= n (first alon)) (cons n alon)]
[else (cons (first alon) (insert n (rest alon)))]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
[Erinnerung: insertion sort]
59
;; sort : list-of-numbers -> list-of-numbers
;; creates a sorted list of numb. from numbers in alon
(define (sort alon)
(cond
[(empty? alon) empty]
[else (insert (first alon) (sort (rest alon)))]))
nn
sortedunsorted
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
sort von fold ableiten
60
;; sort : (listof number) -> (listof number) (define (sort lst) (local ((define (insert an alon) ... ) (fold empty insert lst)))
;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))]))
init empty
combine-op insert
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
sort @ work
61
(sort lst) = (fold empty insert (list 3 2 8))= (insert 3 (fold empty insert (list (2 8))))= (insert 3 (insert 2 (fold empty insert (list 8))))= (insert 3 (insert 2 (insert 8 (fold empty insert ()))))= (insert 3 (insert 2 (insert 8 ())))= (insert 3 (insert 2 (list 8)))= (insert 3 (list 2 8)= (2 3 8)
2
3 2 8
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Abstraktion und „eindeutiger Kontrollpunkt”?
• Eine Abstraktion vereinfacht oft andere Definitionen• Der Prozess der Abstraktion kann Probleme mit
existierenden Funktionen aufdecken• Abstrahierte Funktionsdefinitionen sind flexibler und
breiter einsetzbar als spezialisierte Definitionen
• Der Hauptvorteil von Abstraktion liegt jedoch darin, dass Sie einen eindeutigen Kontrollpunkt für die Funktionalität in einem Programm darstellt– Die Definitionen für eine bestimmte Aufgabe werden
(so weit wie möglich) an einem Ort vereint– Separation of Concerns
62
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum „Eindeutiger Kontrollpunkt”?
• Wenn sich alle Definitionen für eine bestimmte Aufgabe sich an einer Stelle befinden, wird das Programm leichter zu warten
• Unter Wartung eines Programms verstehen wir:– Behebung von Fehlern, so dass es in vorher nicht
getesteten Fällen funktioniert– Erweiterung des Programms, um mit neuen oder nicht
vorgesehenen Situationen zurechtzukommen– Änderung der Darstellung von Informationen als Daten
(z.B. Kalenderdaten)• Einige Schätzungen gehen davon aus, dass die
Wartung eines erfolgreichen Programms den Hauptteil seiner Lebensdauer ausmacht (60-80%)
63
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum „eindeutiger Kontrollpunkt”?
• Durch Änderung einer einzigen Definition können wir an vielen Stellen Fehler beheben und Verbesserungen erzielen– Ein ebenso wichtiger Vorteil von abstrahierten
Definitionen
• Beispiel: Zwei Änderungen an filter1 auf den nächsten zwei Folien:– Die erste Änderung glättet den geschachtelten cond-
Ausdruck – Die zweite Änderung verwendet einen local-Ausdruck,
um den geschachtelten cond-Ausdruck lesbarer zu machen
64
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum „eindeutiger Kontrollpunkt”?
65
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [(rel-op (first alon) t) (cons (first alon)
(filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum „eindeutiger Kontrollpunkt”?
66
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (local ((define first-item (first alon)) (define rest-filtered
(filter1 rel-op (rest alon) t))) (cond [(rel-op first-item t) (cons first-item rest-filtered)] [else rest-filtered]))]))
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum „Eindeutiger Kontrollpunkt”?
• Alle Verwendungen von filter1, inklusive derer, die zur Definition von less-than1 and greater-than1 benutzt werden, profitieren von den Änderungen
• Es würden alle Verwendungen der Funktion davon profitieren, wenn die Änderung einen logischen Fehler beheben würde
• Letztendlich ist sogar möglich, einer abstrahierten Funktion neue Aufgaben zuzuweisen, z.B. einen Mechanismus, der zählt, wie viele Elemente gefiltert werden– Alle Verwendungen der Funktion würden von der neuen
Funktionalität profitieren67
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum „Eindeutiger Kontrollpunkt”?
• Wenn alles an einer Stelle steht:– Verstehen, was zu reparieren, erweitern oder zu ändern
ist, bedeutet, nur eine einzige Funktion zu verstehen– Einen Fehler zu beheben, bedeutet, ihn in einer
Funktion zu beheben, nicht in mehreren ähnlichen Versionen
– Die Fähigkeiten einer Funktion zu erweitern, bedeutet, nur eine Funktion zu ändern, und nicht ähnliche Kopien
– Eine Datenrepräsentation zu ändern, bedeutet, eine allgemeine Daten-Traversierungs-Funktion zu ändern, und nicht all jene, die von der gleichen Schablone stammen
68
Richtlinie für die Erstellung von Abstraktionen:Erstelle eine Abstraktion, anstatt Teile des Programms zu kopieren und zu verändern
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Die Rolle von Abstraktion
• Die Erfahrung lehrt uns, dass die Wartung von Software teuer ist
• Programmierer können die Wartungskosten senken, indem sie Programme richtig organisieren
• Erstes Prinzip: Passe die Struktur der Funktion an die Struktur der Daten an. – Erleichtert Änderungen und Erweiterungen von Funktionen,
wenn die Menge der möglichen Eingabedaten sich verändert
• Zweites Prinzip: Führe angemessene Abstraktionen ein – Jede abstrahierte Funktion erzeugt einen eindeutigen
Kontrollpunkt für mindestens zwei verschiedene Funktionen, oft auch für mehr
69
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Die Rolle von Abstraktion
• Die besten Programmierer verändern ihre Programme, um neue Abstraktionen zu erzeugen
• Unser Designrezept zur Abstraktion von Funktionen ist das grundlegende Werkzeug dazu– Die Anwendung erfordert Übung. Während wir üben, erweitern
wir unsere Fähigkeit, Abstraktionen zu erzeugen und zu nutzen• Wir benutzen funktionale Abstraktion zum Erlernen dieser
Konzepte– Nicht alle Sprachen geben uns die Freiheit, Funktionen so leicht
zu abstrahieren wie in Scheme, jedoch verfügen moderne Sprachen oft über ähnliche Konzepte
– Mit mächtigen Sprachen wie Scheme zu üben ist die beste Vorbereitung
70
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ü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
71
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen, die Funktionen erzeugen• Ausdrücke können im „neuen“ Scheme zu Funktionen
ausgewertet werden• Da der Rumpf einer Funktion auch ein Ausdruck ist,
kann eine Funktion eine Funktion erzeugen
• Funktionen, die Funktionen erzeugen, sind besonders dann nützlich, wenn sich die erzeugte Funktion an die Argumente der erzeugenden Funktion zur Zeit der Anwendung „erinnert“
72
(define (f x) first)(define (g x) f) (define (h x) (cond [(empty? x) f] [(cons? x) g]))
(define (add-10 x) (+ x 10))(define (add-5 x) (+ x 5)) (define (h x) (cond [(< x 5) add-5] [else add-10])) (define addX (h 12))(addX 7) -> 17
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen mit „Gedächtnis“
Interessante Eigenschaft von add:–Das Ergebnis „erinnert sich“ an den Wert des
Arguments x zum Applikationszeitpunkt– Jedes Mal, wenn wir das Ergebnis verwenden, benutzt
es den Wert von x zur Zeit der Applikation
73
;; add : number -> (number -> number) ;; to create a function that adds x to its input
(define (add x) (local ((define (x-adder y) (+ x y))) x-adder))
Funktionen mit „Gedächtnis“ entstehen durch die Kombination von local-Ausdrücken und
Funktionen höherer Ordnung
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen mit „Gedächtnis“
74
x5
4 95 2 7
8
8
2 101 9
(define f (add 5)) = (define f (local ((define (x-adder y) (+ 5 y))) x-adder)) = (define f (local ((define (x-adder5 y) (+ 5 y))) x-adder5)) = (define (x-adder5 y) (+ 5 y)) (define f x-adder5)
(f 10) = (x-adder5 10) = (+ 5 10) = 15
add
(add 5)
(add 8)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Funktionen mit Gedächtnis als Abstraktionsmittel
• Funktionen mit Gedächtnis können das Rezept zur Erstellung abstrakter Funktionen vereinfachen
• Bisheriges Rezept:– Vergleiche und rahme Unterschiede ein– Ersetze den Inhalt von Kästchen mit Variablen– Binde diese Variablen, indem sie zur Argumentliste
hinzugefügt werden
• Alternatives Rezept:– Schließe die Definition in ein local ein, wobei der Inhalt
der Kästchen mit freien Variablen ersetzt wird– Stelle dem local Block eine Funktion voran, welche die
entstandenen freien Variablen bindet
75
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Abstrahieren mit Funktionen mit Gedächtnis
76
;; less-than: lon number -> lon ;; to construct a list of those numbers ;; on 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)])]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
;; greater-than: lon number -> lon;; to construct a list of those numbers ;; on alon that are greater than 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)])]))
Abstrahieren mit Funktionen mit Gedächtnis
77
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
(define (filter2 rel-op) (local (
(define (abs-fun alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (abs-fun (rest alon) t))] [else (abs-fun (rest alon) t)])])))
abs-fun))
Abstrahieren mit Funktionen mit Gedächtnis
78
Genau wie add erhält filter2 ein Argument, definiert eine Funktion und gibt sie als Ergebnis zurück. Das Ergebnis erinnert sich an rel-op, für immer.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Alternatives Abstraktionsrezept
Die Abstraktion: • Stelle eine der Funktionen in eine local-expression und
benutze den Namen der Funktion als Body von local:
• Erzeuge die abstrakte Funktion durch Auflistung der Namen in Kästchen als Parameter:
• Falls op1 oder op2 ein spezielles Symbol ist, z.B. <, benenne es mit etwas, das im neuen Kontext aussagekräftiger ist
79
(local ((define (concrete-fun x y z) ... op1 ... op2 ...)) concrete-fun)
(define (abs-fun op1 op2) (local ((define (concrete-fun x y z) ... op1 ... op2 ...)) concrete-fun))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Alternatives Abstraktionsrezept• Der Test: Leite die konkreten Funktionen wie
zuvor als Instanzen von filter2 ab.– Beispiel: less-than und greater-than als Instanz von filter2:
• Der Vertrag: – Der Vertrag einer mit dem neuen Rezept erzeugten
abstrakten Funktion enthält zwei Pfeile. • Die Funktion erzeugt eine Funktion• Um dies darzustellen, muss der Typ auf der rechten Seite des
ersten Pfeils einen weiteren Pfeil enthalten.– Beispiel: Der Vertrag für filter2:
80
(define less-than2 (filter2 <)) (define greater-than2 (filter2 >))
;; filter2 : (X Y -> boolean) -> ((listof X) Y -> (listof X))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ü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
81
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Motivation für „ad hoc“ Funktionsdefinitionen
Die Applikation abstrakter Funktionen erfordert oft die Definition von Hilfsfunktionen
– filter1 ist mit <ir, eq-ir, … <ihre Funktion> benutzbar
82
;; find : (listof IR) symbol -> (listof IR) (define (find aloir t) (filter1 eq-ir? aloir t))
;; eq-ir? : IR symbol -> boolean (define (eq-ir? ir s) (symbol=? (ir-name ir) s))
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
Zur Erinnerung: die Definition von filter1
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Motivation für „ad hoc“ Funktionsdefinitionen
Falls Hilfsfunktionen nur als Argumente einer abstrakten Funktion f benutzt werden, verwenden wir local
83
;; find : list-of-IRs symbol -> boolean (define (find aloir t) (local ((define (eq-ir? ir s) (symbol=? (ir-name ir) s))) (filter1 eq-ir? aloir t)))
;; find : list-of-IRs number -> boolean (define (find aloir t) (filter1 (local ((define (<ir ir p)(< (ir-price ir) p))) <ir) aloir t ))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Motivation für „ad hoc“ Funktionsdefinitionen
• Da gute Programmierer abstrakte Funktionen benutzen und ihre Programme ordentlich organisieren, gibt es in Scheme eine Abkürzung für diese spezielle, häufige Verwendung von local
• Diese Abkürzung wird lambda-Ausdruck genannt– Das erleichtert die „spontane“ Einführung von Funktionen
wie eq-ir? oder <ir
• Nächste Folien:– Syntax und Semantik von lambda-Ausdrücken– Pragmatik
84
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Syntax von lambda• Ein lambda-Ausdruck ist ein neuer Typ von Ausdruck,
gekennzeichnet durch das Schlüsselwort lambda
• Ein lambda-Ausdruck definiert eine anonyme Funktion– Die Sequenz von Variablen hinter dem
Schlüsselwort lambda sind die Parameter der Funktion
– Die dritte Komponente ist der Body der Funktion
• Beispiele
85
1.(lambda (x c) (> (* x x) c)) 2.(lambda (ir p) (< (ir-price ir) p)) 3.(lambda (ir s) (symbol=? (ir-name ir) s))
<exp> = (lambda (<var> ... <var>) <exp>)
(define (plus4 x) (+ x 4)) ist gleichbedeutend zu(define plus4 (lambda (x) (+ x 4)))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
(local ((define (a-new-name x-1 ... x-n) exp)) a-new-name)
Scope und Semantik von lambda
(lambda (x-1 ... x-n) exp) führt x-1 ... x-n als gebundene Variablen ein, deren Scope exp ist.
86
(lambda (x-1 ... x-n) exp)
a-new-name darf nicht in exp vorkommen
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
lambda statt local
87
;; find : list-of-IRs number -> boolean (define (find aloir t) (filter1 (local ((define (<ir ir p) (< (ir-price ir) p))) <ir) aloir t))
;; find : list-of-IRs number -> boolean (define (find aloir t) (filter1 (lambda (ir p) (< (ir-price ir) p)) aloir t))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
lambda statt local
88
Wozu der Zwischenschritt? Besser: direkt den erzeugten Prozedurwert zurückliefern
;; add : number -> (number -> number) ;; to create a function that adds x to its input(define (add x) (local ((define (x-adder y) (+ x y))) x-adder))
;; add : number -> (number -> number) ;; to create a function that adds x to its input (define (add x) (lambda (y) (+ x y)))
Drei Schritte: Erzeuge einen Prozedurwert Assoziiere einen Namen mit dem
Wert Werte den Namen aus, um den
Wert zurückzuliefern
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
lambda statt local
89
(define (filter2 rel-op) (local ( (define (abs-fun alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (abs-fun (rest alon) t))] [else (abs-fun (rest alon) t)])])) ) abs-fun))
Quiz: Kann ich hier local mit lambda ersetzen?
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Semantik von lambda
Grundlegendes zur Auswertung von lambda-Expressions:
– Ein lambda-Ausdruck ist ein Wert, weil Funktionen Werte sind
– Die Anwendung von lambda-Ausdrücken erfolgt nach den üblichen Regeln der Funktionsanwendung, vorausgesetzt, wir werten die Kurzform zuerst aus
90
(lambda (x-1 ... x-n) exp)
(local ((define (a-new-name x-1 ... x-n) exp)) a-new-name)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Semantik von lambda
Zur Erläuterung evaluieren wir die folgende Applikation:
91
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
(filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8)
Zur Erinnerung: die Definition von filter1
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Scope und Semantik von lambda
92
(filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8) ...
= (filter1 (local ((define (<ir ir p) (< (ir-price ir) p))) <ir) (list (make-ir 'doll 10)) 8)
...
= (filter1 <ir (list (make-ir 'doll 10)) 8)...
substituiere lambda mit local
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Semantik von lambda
Wir können die Semantik von lambda direkter erklären:
93
= exp mit x-1 ... x-n ersetzt durch val-1 ... val-n
( (lambda (x-1 ... x-n) exp) val-1 ... val-n )
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Semantik von lambda
Zur Erläuterung evaluieren wir erneut die Applikation:
94
(define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))
Zur Erinnerung: die Definition von filter1
(filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Scope und Semantik von lambda
95
(filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8) = (cond [((lambda (ir p) (< (ir-price ir) p)) (make-ir 'doll 10) 8) (cons (first (list (make-ir 'doll 10))) (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8))] [else (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8) ]) = (cond [(< (ir-price (make-ir 'doll 10)) 8) (cons (first (list (make-ir 'doll 10))) (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8))] [else (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8)]) = ...
1. El. der Liste
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Pragmatik von lambda
96
Richtlinie für Lambda AusdrückeBenutze lambda-Ausdrücke, wenn eine Funktion nicht rekursiv ist und nur einmal, als Argument, gebraucht wird
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Warum “Lambda” ?
• Das Wort „Lambda“ stammt aus -Kalkül - ein mathematisches Kalkül – Es wurde eingeführt von Alonso Church– Im Wesentlichen der Kern von Scheme (eine
minimale aber komplette Sprache):• Nur Lambda-Abstraktion und Anwendung• Keine primitiven Typen/Prozeduren• Keine Spezialformen etc.
– Grundlegendes Werkzeug für mathematische Untersuchungen und formale Behandlung von Programmiersprachen
• Zunächst kann man Lambda als erzeuge-Prozedur betrachten– Aber schauen wir uns kurz an, was man mit Lambda
alleine alles machen kann!
97
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
• Berechnen ohne primitive Werte/Typen, spezielle Formen?
• Ja! Alles wird durch Funktionen modelliert … z.B. die primitiven Operatoren and/or
98
(define my-or (lambda (op1 op2) (cond [op1 true] [else (cond [op2 true] [else false])])))
(define my-and (lambda (op1 op2) (cond [op1 (cond [op2 true] [else false])] [else false])))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
• Spezielle Formen können nicht als Parameter einer Prozedur übergeben werden …
• Zur Illustration schauen wir uns die Scheme Funktionen andmap und ormap an
99
OK, aber wozu soll das gut sein?
Um die Komponierbarkeit zu erhöhen Closure-Prinzip!
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
100
(andmap even? `(2 6)) = true
Der Fall andmap und ormap;; andmap : (X -> boolean) (listof X) -> boolean;; determines whether p holds for every item on alox;; (andmap p (list x-1 ... x-n)) = ;; (and (p x-1) (and ... (p x-n)))
(define (andmap p alox) (cond [(empty? alox) true] [else (and (p (first alox))
(andmap p (rest alox)))] ))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
101
(ormap even? (list 5 1) = false
Der Fall andmap und ormap
;; ormap : (X -> boolean) (listof X) -> boolean
;; determines whether p holds for at least one item
;; on alox
;; (ormap p (list x-1 ... x-n)) =
;; (or (p x-1) (or ... (p x-n)))
(define (ormap p alox) (cond [(empty? alox) false] [else (or (p (first alox)) (ormap p (rest alox)))]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
Nach unserem Rezept könnten wir in dem Fall abstrahieren, wenn nur and, or Funktionen wären …
102
Der Fall andmap und ormap
(define (ormap p alox) (cond [(empty? alox) false ] [else (or (p (first alox))
(ormap p (rest alox)))]))
(define (andmap p alox) (cond [(empty? alox) true ] [else (and (p (first alox))
(andmap p (rest alox)))]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
103
Der Fall andmap und ormap
Eigentlich haben wir ja bereits eine abstrakte Funktion, die wir wieder verwenden können, um andmap and ormap abzuleiten.Wir bräuchten andormap gar nicht.
(define (andormap bool-op init p alox) (cond [(empty? alox) init] [else (bool-op (p (first alox))
(andormap bool-op init p (rest alox)))]))
(define (andmap3 p l) (andormap my-and true p l))
(define (ormap3 p l) (andormap my-or false p l))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Das ultimative Lambda …
104
(define (prod alon) (fold 1 * alon))(define (sum alon) (fold 0 + alon))
(define (andmap4 p alox) (fold true my-and (map p alox)))
(define (ormap4 p alox) (fold false my-or (map p alox)))
;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ü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
105
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
[Erinnerung: Die Rolle von Abstraktion]
• Programmierer können die Wartungskosten senken, indem sie Programme richtig organisieren
• Erstes Prinzip: Passe die Struktur der Funktion an die Struktur der Daten an. – Erleichtert Erweiterungen von Funktionen, wenn die
Menge der möglichen Eingabedaten sich verändert• Zweites Prinzip: Führe angemessene
Abstraktionen ein – Jede abstrahierte Funktion erzeugt einen
eindeutigen Kontrollpunkt für mindestens zwei verschiedene Funktionen, oft für mehr
106
Jetzt wo wir Funktionen höherer Ordnung kennen, ist es an der Zeit, das erste Prinzip nochmals zu betrachten …
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Addition der Quadrate allerungeraden Knoten eines Baums …
(define (sum-of-odd-squares alon) (cond [(empty? alon) 0]
[(not (cons? alon)) (if (odd? alon) (square alon) 0)]
[else (+ (sum-of-odd-squares (first alon)) (sum-of-odd-squares (rest alon)))]))
107
Prozessstruktur folgt der Datenstruktur
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Sammeln der geraden Fibonacci-Zahlen von 0..n
108
0 für n = 0Fib(n) = 1 für n = 1
Fib(n-1) + Fib(n-2)sonst
Prozessstruktur folgt der Datenstruktur;; sammelt die geraden Fib(k) für k = [0..n] (define (even-fibs n) (local ((define (process k) (cond [(> k n) empty] [else (local ((define f (fib k))) (cond [(even? f) (cons f (process (+ k 1)))] [else (process (+ k 1))]))]) )) (process 0)))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
(define (sum-of-odd-squares tree) (cond ((empty? tree) 0) ((not (cons? tree)) (if (odd? tree) (square tree) 0)) (else (+ (sum-of-odd-squares (first tree)) (sum-of-odd-squares (rest tree))
) ) ) ))
Prozessstruktur folgt der Datenstruktur
109
Können Sie Ähnlichkeiten zwischen den beiden Prozeduren erkennen?
(define (even-fibs n) (local ((define (process k) (cond [(> k n) empty] [else (local ((define f (fib k))) (cond [(even? f) (cons f (process (+ k 1)))] [else (process (+ k 1))]))]))) (process 0)))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Fokus auf die Prozessphasen …
Eine abstraktere Beschreibung der Berechnung zeigt …• sum-of-odd-squares:
– Zählt die Blätter eines Baumes auf – Filtert sie, um die ungeraden zu erhalten– Bearbeitet die ungeraden, indem sie quadriert
werden – Akkumuliert die Ergebnisse mittels +, Start mit 0
• even-fibs:– Zählt die ganzen Zahlen von 0 bis n auf – Bearbeitet jede ganze Zahl, indem die Fibonaccizahl
berechnet wird– Filtert sie um die geraden zu bekommen– Akkumuliert die Ergebnisse mittels cons, Start mit der
leeren Liste 110
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Fokus auf die Prozessphasen …
111
Aufzählen:Blätter
Filtern:ungerade?
Aufzählen:Zahlen
Filtern:even?
map:fib
map:square
Akkumul.:+, 0
Akkumul.:cons, empty
sum-of-odd-squares
even-fibs
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Prozessstruktur folgt der Datenstruktur• Die Struktur des Prozessflusses geht bei dieser
Strukturierung verloren… • Es gibt keine klaren Teile, die zu den Elementen
der Prozessflussdarstellung passen; sie sind vermischt
112
enumerationaccumulationprocessing
filtering
(define (sum-of-odd-squares tree) (cond [(empty? tree) 0] [(not (cons? tree)) (if (odd? tree) (square tree) 0) ] [else (+ (sum-of-odd-squares (first tree)) (sum-of-odd-squares (rest tree))
) ] ))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Zerlegung in Prozessphasen
• Ein Prozess kann häufig in Sequenzen von Schritten zerlegt werden, z.B.: – Kompilierung– Auffinden von gemeinsamen Wörtern in zwei
Textdateien• Häufige Arten von Schritten
– Aufzählen, filtern, bearbeiten, akkumulieren
113
1) Erstelle eine Liste aller Blätter [aufzählen]2) Hole die ungeraden Knoten
aus der Liste [filtern]3) Erstelle die Liste der Quadrate
[bearbeiten]4) Addiere die Quadrate
[akkumulieren]
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ein Mehrzweck-Filter
114
(define (filter test alox) (cond [(empty? alox) empty] [(test (first alox)) (cons (first alox) (filter test (rest alox)))] [else (filter test (rest alox))]))
(filter even? (list 4 5 7 2 6 9 10 1)) ->(4 2 6 10)
Abstraktion über den Test, indem das Prädikat als Parameter übergeben wird.
Eine Vorlage für den Filter-Prozess
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Ein Mehrzweck-Zusammenfalter
115
• Abstraktion über den binären Operator (combine-op) zum Zusammenfalten, den Initialwert (init) und über die Liste, die zusammengefaltet wird (alox)
• Wir wissen nur, dass wir zusammenfalten, indem wir den binären Operator auf die Werte der Liste anwenden.;; fold : Y (X Y -> Y) (listof X) -> Y
(define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))]))
Eine Vorlage für den Akkumulations-Prozess
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Datenstruktur bedingt Enumeratoren
• Die Art, eine Datenstruktur zu durchlaufen, kann nicht unabhängig von der speziellen Datenstruktur sein …
116
(enumerate-interval 3 10) --> (3 4 5 6 7 8 9 10)
• Aufzählung von ganzen Zahlen…
(define (enumerate-interval lo hi) (cond [(> lo hi) empty] [else (cons lo
(enumerate-interval (+ lo 1) hi))]))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Datenstruktur bedingt Enumeratoren
• Blätter aufzählen…
117
if x --> ((1 3) 2 (5 (4 6))), then(enumerate-tree x) --> (1 3 2 5 4 6)
(define (enumerate-tree tree) (cond [(empty? tree) empty] [(not (cons? tree)) (list tree)] [else (append (enumerate-tree (first tree)) (enumerate-tree (rest tree)))]) )
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
sum-of-odd-squares alsKomposition von Schritten
118
[transduce]
[accumulate]
[filter]
enumerationaccumulation
processingfiltering
(sum-of-odd-squares ‘((1 3) 2 (5 (4 6))) )
35
(define (sum-of-odd-squares tree) (fold + 0 (map square (filter odd? (enumerate-tree tree)
) )
))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Andere Schritt-basierte Prozesse
119
(define (even-fibs n) (fold cons empty (filter even? (map fib (enumerate-interval 0 n)))))
(define (highest-programmer-salary records) (fold max 0 (map salary (filter programmer? records)) ))
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T5
Vorteile der Zerlegung in Schritte
• Unterstützung modularer Programmentwürfe– Entwürfe sind aus relativ unabhängigen Teilen
(Komponenten) zusammengesetzt• Die meisten Schritte können als Mehrzweck-Prozeduren
geschrieben werden, die wiederum als Vorlage für eine Vielzahl von Prozessen dienen können.
– Einfach zu schreiben und zu verstehen.
• Förderung modularen Entwurfs durch: – Bibliothek mit Standard-Komponenten– Eine konventionelle Schnittstelle für eine flexible
Verbindung der Komponenten.
120
Modulare Konstruktion ist eine mächtige Strategie, um die Komplexität im Entwurf zu
kontrollieren.
Nachteil bei dieser Art
von Entwürfen?