telecooperation/rbg technische universität darmstadt copyrighted material; for tud student use only...

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




Ä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




Ä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




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 ))])]))




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))])]))




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))])]))




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




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




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




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)])]))




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




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)




Ä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.





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)])]))





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)])]))




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 …




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




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




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




Überblick



Berechnungen

21




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




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




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




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





<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




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>)




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>




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

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“




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




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.




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)




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



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: 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




;; 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 ...




(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




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




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 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)




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))




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




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)




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)




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

48

(number -> number) (listof number) -> (listof number)

(IR -> symbol) (listof IR) -> (listof symbol)

(X -> Y) (listof X) -> (listof Y)

X Y




[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

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




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))




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




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))




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))




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




[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) ...)




sort von fold ableiten

57

Können wir fold verwenden, um Listen zu sortieren?

Erinnern wir uns an insertion sort…




[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)))]))




[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




sort von fold ableiten

60

;; sort : (listof number) -> (listof number) (define (sort lst) (local ((define (insert an alon) ... ) (fold empty insert lst)))


init empty

combine-op insert




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




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




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




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





65


(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)]))





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]))]))






• 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





• 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




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




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




Überblick



Berechnungen

71




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




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




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)




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




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)])]))




;; 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)])]))


77




(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))


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.




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))




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))




Überblick



Berechnungen

81




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))


Zur Erinnerung: die Definition von filter1





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 ))





• 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




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)))




(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




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))




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




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?




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)




Semantik von lambda

Zur Erläuterung evaluieren wir die folgende Applikation:

91


(filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8)






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




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 )




Semantik von lambda

Zur Erläuterung evaluieren wir erneut die Applikation:

94



(filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8)





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




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




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




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])))





• 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!





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)))] ))





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)))]))





Nach unserem Rezept könnten wir in dem Fall abstrahieren, wenn nur and, or Funktionen wären …

102


(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)))]))





103


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))





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)))





Überblick



Berechnungen

105




[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 …




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




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)))




(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)))




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




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




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))

) ] ))




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]




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




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




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))]))




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)))]) )




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)

) )

))




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)) ))




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?

telecooperation/rbg technische universität darmstadt copyrighted material; for tud student use only...

Documents