Software-Konstruktion mit LISP 9783110852769, 9783110117868

Citation preview

Programmierung komplexer Systeme 1 Herausgegeben von Fevzi Belli und Hinrich E. G. Bonin

Hinrich E. G. Bonin

Software-Konstruktion mit LISP

w DE

Walter de Gruyter

G Berlin • New York 1991

Dr. rer. pubi., Dipl.-Ing., Dipl.-Wirtsch.-Ing. Hinrich E. G. Bonin Professor für Verwaltungsinformatik an der Fachhochschule Nordostniedersachsen, Lüneburg

Das Buch enthält 65 Abbildungen

© Gedruckt auf säurefreiem Papier, das die US-ANSI-Norm über Haltbarkeit erfüllt.

Die Deutsche Bibliothek -

CIP-Einheitsaufnähme

Bonin, Hinrich: Software-Konstruktion mit LISP / Hinrich E. G. Bonin. Berlin ; New York : de Gruyter, 1991 (Programmierung komplexer Systeme ; 1) ISBN 3-11-011786-X NE: GT

© Copyright 1991 by Walter de Gruyter& Co., D-1000 Berlin 30. Dieses Werk, einschließlich aller seiner Teile, ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen,Übersetzungen,Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen. Printed in Germany. Druck: Gerike GmbH, Berlin. -Bindung: Lüderitz &BauerGmbH, Berlin. -Einbandentwurf: Johannes Rother, Berlin. - Textillustrationen: David Andersen, Berlin.

Vorwort der Herausgeber

Die Reihe „Programmierung komplexer Systeme" beschäftigt sich mit Realisierungs- und Zuverlässigkeitsaspekten komplexer Software-Systeme. Ihre Zielgruppe sind Ingenieure, Naturwissenschaftler, Studierende und Praktiker aller Fachrichtungen mit Informatik-Grundkenntnissen sowie DV-Verantwortliche für Entwicklung und Weiterbildung. Die Bände dieser Reihe möge ihnen das Programmieren von schwierigen, umfangreichen Aufgaben durchschaubarer machen. Gegen Mythen und Vorurteile wie beispielsweise „nicht möglich", „total einfach" oder „alles Glücksache" setzt diese Reihe den aktuellen Wissensstand der Forschung und die konkreten Erfahrungen der Praxis. Der Band 1 zeigt Programmieren als einen systematischen, disziplinierten Konstruktionsvorgang. Dazu wird LISP (Akronym für "LISI Processing") aus klassischen und neuen Blickwinkeln erläutert. LISP ist eine bewährte Sprache, geschaffen für die Bewältigung komplexer Aufgaben und prädestiniert für den Umgang mit Symbolen, abgeleitet aus dem Lambda-Kalkül und geprägt durch ihre Dualität von „Daten" und „Programm". LISP ermöglicht mit seinem modernen Dialekt Scheme ohne Ballast ein imperativ-, funktions- und objekt-geprägtes Programmieren. Der Band führt anhand von Beispielen aus der Verwaltungsund Büroautomation Schritt für Schritt über Funktionen höherer Ordnung zur Konstruktion mit Klassen, Instanzen und multipler Vererbung. Die Reihe präsentiert neben Bänden mit Lehrbuchcharakter (z.B. Band 3: „Logik für Software-Ingenieure" oder Band 5: „Einführung in die systemnahe Programmierung") neuere Forschungsergebnisse. So vertieft beispielsweise Band 2 Zuverlässigkeitsaspekte. Quantitative Modelle und Nachweisverfahren, wie sie im Hardware-Bereich längst bewährt sind, werden in einem innovativen Ansatz auf die Software übertragen. Band 4 dokumentiert neben der Einführung in die Thematik aktuelle Forschungsergebnisse in Form eines umfassenden Nachschlagewerkes über Maße und Meßverfahren zur Softwarekomplexität. Wir wünschen, daß die Reihe ihren Leserinnen und Lesern sowohl fundiertes Fachwissen wie Freude bei der Lektüre vermittelt. Den zukünftigen Autoren wünschen wir Mut und Ausdauer, ihre Innovationen leicht verständlich zu formulieren. Dabei wollen wir sie gern mit Rat und Tat unterstützen. Paderborn/Lüneburg, Februar 1991.

Fevzi Belli Hinrich E.G. Bonin

Vorwort

Nützliche Produkte entstehen kaum per Zufall. Sie erfordern einen sorgsam geplanten Herstellungsprozeß, wenn es gilt, sie wirtschaftlich, in gewünschter Qualität und termingerecht zu produzieren. Das planmäßige Konstruieren ist eine Aufgabe für Ingenieure. Sie kennen bewährte Grundkonstruktionen, mit denen sie die gestellte Aufgabe meistern. Stets greifen sie dazu auf schon existierende Halb- und Fertigprodukte (normierte Bausteine) zurück. Dieses Buch handelt vom planmäßigen Konstruieren von Software mit LISP (Akronym für ,JLISt Processing"). Es erläutert zweckmäßige Bausteine (Kapitel I), skizziert bewährte Konstruktionen (Kapitel II) und gibt praxisnahe Konstruktionsempfehlungen (Kapitel III). Programmieren ist einerseits eine kreative Arbeit, andererseits ist diese schöpferische Arbeit an und mit schnell änderbaren (Quellcode-)Texten systematisch und diszipliniert zu vollziehen; ganz im Sinne der Ingenieurdisziplin „Softwaretechnik" (engl.: Software Engineering). Warum gerade mit LISP ingenieurmäßiges Konstruieren erlernen? LISP ist doch ein „Oldie" mit mehr als 30 Jahren auf dem Buckel. Sicherlich ist dieser „Oldie" der „Klassiker" für den Umgang mit Symbolen und daher heute eine dominierende Sprache im Anwendungsgebiet „Künstliche Intelligenz". Übersehen wird leicht, daß LISP im Laufe der Zeit zu einer modernen Programmiersprache, einer leistungsfähigen, dialogorientierten Software-Entwicklungsumgebung und einer Menge sinnvoller Konstrukte (Vektoren, Klassen, Instanzen etc.) herangereift ist. Konzepte, die in ähnlich alten Sprachen, wie z.B. FORTRAN oder COBOL, nicht möglich sind, können in LISP problemlos formuliert werden. Mit LISP können wir funktionsgeprägte Konstruktionen zeigen, z.B. Funktionen höherer Ordnung, die sich selbst als Argument haben. Wir können Sprünge in die „Zukunft" und „Vergangenheit" eines Programms notieren (Continuation), Zahlen mit beliebig vielen Ziffern errechnen, unterschiedliche Werte mit gleichnamigen Variablen benennen (Pakete), Eigenschaften dynamisch vererben (objektgeprägte Konstruktionen), Bildschirmfenster definieren („Pop-up"-Fenster), Fraktalfiguren zeichnen (Graphik) und vieles mehr. Wenn LISP, welcher LISP-Standard? Common LISP (vgl. Steele u.a., 1984) oder Scheme (vgl. Rees/Clinger, 1986)? Um die Beispiele und Programm(fragment)e auf einem Personalcomputer der I B M XT-Klasse nachvollziehen zu können, kam das große Common LISP (ca. 1000 Seiten Dialektbeschreibung) nicht in Betracht. Dieses erfordert die Rechenkapazität einer Workstation (vgl. Anhang B). Das „kleine" Scheme (ca. 50 Seiten Dialektbeschreibung) bietet sich aufgrund der Stringenz des funktionalen Konzeptes (keine zusätzliche „function cell") und der Leistungsfähigkeit der eingebauten Konstrukte an. Dabei ist

VIII

Vorwort

Scheme auch bei dem hier eingesetzten PC System von Texas Instruments Inc. (Version 3.0, Betriebssystem MS-DOS) keinesfalls nur eine Untermenge von Common LISP. Das Buch wendet sich an alle, die Schritt für Schritt anhand von praxisnahen Beispielen LISP verstehen lernen wollen. Im Mittelpunkt steht das funktionsund objektgeprägte Programmieren. Dazu muß der Beginner viele Konstrukte erlernen. Als pragmatischer Leitfaden dient ihre Einteilung in Konstruktoren, Selektoren, Prädikaten und Mutatoren. Erklärt werden sie mit Beispielen, die vorwiegend aus dem Bereich der Verwaltungsautomation („kommerziellen DV") stammen. Beantwortet werden Fragen, die in allen Programmiersprachen relevant sind: Wie dokumentiert man durchschaubar? Wie benennt man eine Variable, eine Funktion, ein Makro etc.? Wie kommentiert man im Quellcodetext? Wie gliedert man ein komplexes Problem in weniger komplexe (Modularisierung)? Wie spezifiziert man in LISP-Notation (Pseudocode)? Sicherlich läßt sich LISP nüchtern und sachlich erläutern, ohne vom Glanz der „LISP-Philosophie" zu schwärmen. Dieses Buch versucht jedoch, die Begeisterung des Autors für das moderne LISP zu verdeutlichen. Erst wenn die „Lots of /nsidious Silly Parentheses" (spöttische Interpretation von LISP: viele heimtückische und blödsinnige Klammern) in ästhetische Konstrukte umschlagen, kommt zur Zweckmäßigkeit auch noch die Freude. Dieses Buch ist konzipiert als ein Arbeitsbuch zum Selbststudium und für Lehrveranstaltungen. Der LISP-Neuling möge es Abschnitt für Abschnitt sequentiell durcharbeiten. Der LISP-Vorbelastete kann zunächst die Zusammenfassungen der einzelnen Abschnitte studieren. Anhand ihrer zusätzlichen charakteristischen Beispiele ist individuell entscheidbar, ob der Inhalt des jeweiligen Abschnittes schon bekannt ist. Damit das Buch auch später als Nachschlagewerk hilfreich ist, enthält es sowohl Vorwärts- wie Rückwärts-Verweise. Ebensowenig wie z.B. Autofahren allein aus Büchern erlernbar ist, wird niemand zum „LISP wizard" (deutsch: Hexenmeister) durch Nachlesen von erläuternden Beispielen. Das intensive Durchdenken der Beispiele im Dialog mit einem LISP-System vermittelt jedoch, um im Bild zu bleiben, unstrittig die Kenntnis der Strassenverkehrsordnung und ermöglicht ein erfolgreiches Teilnehmen am Verkehrsgeschehen. Für diesen Lernprozeß wünsche ich der „Arbeiterin" und dem „Arbeiter" viel Freude. Danksagung: Für das große Interesse und die Durchsicht einer vorhergehenden Fassung danke ich meinen Kollegen Herrn Prof. Dr. Fevzi Belli, Herrn Prof. Dr. Günter Matthiessen und Herrn Dipl.-Ing. Thomas Goetz. Ohne die vielen Diskussionen mit Studentinnen und Studenten im Rahmen von LISP-Projekten z.B. Lehrveranstaltung „Teamorientierte Softwareentwicklung" (Universität Bremen, Fachbereich Mathematik und Informatik, WS 1987/88), Studienprojekt „FLAVOR" (Hochschule Bremerhaven, Studiengang Systemanalyse, SS 1988 WS 1988/89) und "LISP Programmierkurs" (Universität Hannover, Rechtsinformatik, WS 1988/89) wäre dieses Buch nicht in dieser Form entstanden. Ganz

Vorwort

IX

besonderer Dank gebührt an dieser Stelle den Hörerinnen und Hörern meiner Vorlesung „Nichtnumerische Programmierung" (Hochschule Bremerhaven und Fachhochschule Nordostniedersachsen), die durch ihre konstruktive Kritik an den ersten Manuskriptfassungen dieses Buch mitzugestalten halfen. Lüneburg, Dezember 1990

Hinrich E. G. Bonin '((V)ERFASSER)

Vereinbarungen und Notation

Aus Lesbarkeitsgründen sind nur die männlichen Formulierungen genannt; die Leserinnen seien implizit berücksichtigt. So steht z.B. das Wort „Programmierer" hier für Programmiererin und Programmierer. Klassische LISP-Systeme unterscheiden bei Symbolen nicht zwischen großen und kleinen Buchstaben. Die LISP-Konstrukte sind daher in Großbuchstaben dargestellt. Sie heben sich somit deutlich vom sonstigen Text ab. Dabei dient eine Textaufteilung auf mehrere Zeilen einer Verbesserung der Lesbarkeit. Sie hat keine Bedeutung für die Auswertung des über mehrere Zeilen verteilt notierten Konstruktes. Soweit möglich stehen deutsche Fachbegriffe. Ausnahmen bilden Begriffe, bei denen die Übersetzung nicht „eins-zu-eins" möglich ist und/oder die englische Fassung sich durchgesetzt hat, z.B. Flavor-System (deutsch: Aroma, Wohlgeschmack) als Bezeichnung für eine objektorientierte Software-Entwicklungsumgebung. Um das Verstehen des laufenden Textes zu sichern, sind Textpassagen im Sinne von gedanklichen Einschüben durch „eckige" Klammern abgegrenzt. Dabei treten folgende Einschübe auf: /Hinweis: „Text"/ „Text" verweist auf eine Besonderheit oder Empfehlung, entsprechend zu handeln. /Exkurs: „Text'7 Zum besseren Verstehen der Hintergründe erläutert „Text" einen zusätzlichen Aspekt ausführlicher. /LISP-System-Name: „Text'7 „Text" beschreibt eine Ausprägung des entsprechenden LISP-Dialektes. Notation für die Definition von LISP-Konstrukten: { } Der Inhalt zwischen den geschweiften Klammern kann einfach oder mehrfach vorkommen oder kann fehlen.

Nicht-terminales Symbol (vgl. Abschnitt 2.2); Eingrenzung eines Begriffes bei Formulierungen in Backus-Naur-Form (kurz: BNF)

()

LISP-Klammern Alternative (vgl. BNF Abschnitt 2.2)

Vereinbarungen und Notation

XII

Symbolischer Ausdruck

Notation für die Schnittstelle

zum

LISP-System:

eval> ==> ; Kommentar

eval>

Die Zeichenfolge „eval>" gibt an, daß die danach folgenden Zeichen dem Zyklus „Lesen, Auswerten, Ergebnisausgabe" (READEVAL-PRINT-Zyklus) übergeben werden. „eval>" steht anstelle der Aufforderung (Prompt) eines laufenden LISP-Systems, das eine Eingabe erwartet. LISP-Systeme verwenden unterschiedliche Aufforderungen und zusätzlich sind diese individuell modifizierbar. Wir benutzen eval> (vgl. z.B. Brooks, 1987; Narayanan/Sharkey, 1985) für Scheme. Zur Betonung eines bestimmten LISP-Dialektes ist ein Kennbuchstabe als Präfix vorangestellt: eval> ::= Scheme (vgl. Rees/Clinger, 1986) C-eval> Common LISP (vgl. Steele u.a., 1984) T-eval> ::= TLC-LISP (vgl. TLC-LISP, 1985)

==>

Dokumentiert das Ergebnis, d.h. die nach dem Pfeil dargestellten Zeichen werden vom PRINT-Teil ausgegeben. Das Semikolon kennzeichnet einen Kommentar. Alle Zeichen nach einem Semikolon in einer Zeile sind im READ-EVALPRINT-Zyklus Kommentare, d.h. werden vom LISP-System nicht ausgewertet (vgl. Abschnitt 11.2).

Inhalt

Vorwort Vereinbarungen und Notation I.

Konstrukte (Bausteine zum Programmieren)

1. Einführung: Handhabung von Konstrukten 1.1 Syntax: Symbolischer Ausdruck 1.2 Semantik: Regeln zum Auswerten (Evaluieren) 1.3 Repräsentation von Daten und Programm 1.4 Konstrukt: Schnittstelle und Implementation 1.4.1 LAMBD A-Konstrukt 1.4.2 Umgebung 1.5 Zusammenfassung: EVAL, APPLY und LAMBDA 2. Kombinieren von Konstrukten 2.1 Interaktion: Operand - Operation 2.2 Kontrollstrukturen 2.2.1 Sequenz 2.2.2 Selektion 2.2.3 Iteration 2.3 Zeitpunkt einer Wertberechnung 2.4 Typische Fehler 2.5 Zusammenfassung: LET, DO und MAP

VII XI 1 2 3 8 13 16 19 26 32 33 36 45 49 58 66 76 79 83

3. 3.1 3.2 3.3 3.4 3.5

Rekursion als Problemlösungsmethode Funktionsanwendung auf die Restliste Verknüpfung von Teilproblem-Lösungen Rekursive Konstrukte für rekursive Strukturen Geschachtelte Rekursion Zusammenfassung: Rekursion

85 89 92 94 97 100

II.

Konstruktionen (Analyse und Synthese)

105

4. 4.1 4.2 4.3 4.4

Verstehen einer Konstruktion Analyseaspekte Verbund von Konstruktor, Selektor, Prädikat und Mutator LISP-Klassiker: „Symbolisches Differenzieren" Zusammenfassung: Abstraktionsebene

106 110 113 115 121

5. 5.1

Abbildungsoption: Liste Zirkuläre Liste

123 129

XIV

Inhalt

5.2 5.3 5.4

Assoziationsliste Eigenschaftsliste Zusammenfassung: Liste, A-Liste und P-Liste

141 147 164

6. 6.1 6.2 6.3 6.4

Abbildungsoption: Vektor Vektor- Konstrukte Abbildung der CONS-Zelle als Vektor Höhenbalancierter Baum Zusammenfassung: Vektor

167 168 170 172 184

7. Abbildungsoption: Zeichenkette und Symbol 7.1 Mustervergleich 7.2 STRING-Konstrukte 7.3 Symbol und PRINT-Name 7.4 Generieren eines Symbols 7.5 Zusammenfassung: EXPLODE, IMPLODE und GENSYM

184 185 188 194 202 208

8. Abbildungsoption: Funktion mit zugeordneter Umgebung 8.1 Funktionen höherer Ordnung 8.1.1 Funktionale Abbildung der CONS-Zelle 8.1.2 Fixpunktoperator Y 8.1.3 Funktion ALTERNATE 8.2 Kontrollstruktur: Continuation 8.3 Syntaxverbesserung durch Makros 8.4 Lokaler Namensraum (Pakete) 8.5 Übersetzen von Funktionen 8.6 Zusammenfassung: Closure, Continuation, Makros und Pakete

211 213 214 218 224 226 233 239 250 252

9. 9.1 9.2 9.3 9.4

Generierte Zugriffskonstrukte Abschirmung von Werten DEFINE-STRUCTURE-Konstrukt Einfache statische Vererbung Zusammenfassung: Zugriffskonstrukte als Schnittstelle

257 258 261 265 269

10. 10.1 10.2 10.3 10.4 10.5

Klasse-Instanz-Modell Scheme Object-Oriented Programming System (SCOOPS) Multiple dynamische Vererbung Aktiver Slot Modifikation des Vererbungsgraphen Zusammenfassung: Spezialisierung und Faktorisierung

271 272 284 293 294 298

III.

Konstruktionsempfehlungen

303

11. Transparenz der Dokumentation 11.1 Benennung 11.2 Kommentierung

305 309 319

Inhalt

XV

11.3 Vorwärts-und Rückwärtsverweise 11.4 Zusammenfassung: Namen, Kommentare und Verweise

322 326

12. 12.1 12.2 12.3

Spezifikation mit LISP Anforderungen an Anforderungen Import-Export-Beschreibung Zusammenfassung: Spezifikation

330 334 338 342

13. 13.1 13.2 13.3 13.4 13.5

Wechsel der Abbildungsbasis Turtle Graphik Lösung: Nachrichtenversand Lösung: Verzweigungsfunktion Fraktalfigur Zusammenfassung: Graphik, SEND- und DISPATCH-Konstruktion.

344 344 346 353 360 362

14.

Ausblick

366

Anhang

369

A: Literaturverzeichnis

369

B: LISP-Systeme 1. Einführung 2. Rechner für LISP-Systeme 3. Software

384 384 387 390

C: PC Scheme Übersicht

394

D: Schlagwörter

398

I. Konstrukte (Bausteine zum Programmieren)

Wie jede Sprache, so dient auch eine formal(isiert)e Sprache der Kommunikation. Aufgabe einer Programmiersprache ist die Kommunikation zwischen Menschen über Texte („Botschaften"), die ein Rechner als Arbeitsanweisungen „interpretieren" und ausführen kann. Formulierungen in einer Programmiersprache haben einerseits Menschen, andererseits Rechner als Adressaten. Jeder Text in einer Programmiersprache hat zumindest im Erstellungsprozeß (Entwurfs-/Formulierungs-/Test-Zyklus) seinen Konstrukteur als Kommunikationspartner. Darüber hinaus wendet sich der Text an Dritte; an Mitkonstrukteure und an das Wartungs-/ Pflege- und Fortentwicklungs-Personal (vgl. Bild 1-1). Programmieren ist damit das Erstellen von Texten aus (sprachlichen) Konstrukten, welche die „Arbeit" eines Rechners bestimmen.

Bild

1-1.

Kommunikationsmittel

Programmiersprache

Programmiersprachen können stärker die Kommunikation mit dem Rechner oder die zwischen Programmierern unterstützen. Ein in Maschinencode notiertes Programm kann das gesamte Leistungsvermögen („Verstehbarkeitspotential") des Rechners effizient ausnutzen. Ein Programmierer kann ein solches Programm in der Regel nur mühsam verstehen. Ein Text, in einer Assembler-Sprache formuliert, ist im allgemeinen aufwendiger zu durchschauen als ein äquivalenter Text, notiert in einer höheren Programmiersprache. Dafür wird der Assembler-Text als eine l:l-Abbildung des Maschinencodes vom Rechner mit weniger Aufwand in konkrete Arbeitsschritte umgesetzt. Eine Programmier-

2

I. Konstrukte (Bausteine zum Programmieren)

spräche ist daher stets ein Kompromiß zwischen den unterschiedlichen Anforderungen der Kommunikations-"Partner" Mensch und Maschine. In einer natürlichen Sprache kann ein Sachverhalt klar und leicht verständlich oder umständlich („verkompliziert") und mißverständlich beschrieben werden. Kurze Sätze mit prägnanten Begriffen, verknüpft durch eine systematische Gliederung, helfen einen Sachverhalt besser, klarer und schneller zu vermitteln als lange Sätze mit stark verschachtelten Bezügen. In jeder Programmiersprache, also auch in „L/St Processing" (kurz LISP), steht man vor einem ähnlichen Formulierungsproblem. Es können leicht durchschaubare (transparente) oder undurchschaubare bzw. nur sehr schwer durchschaubare Texte notiert werden. Es geht daher um die Wahl geeigneter Begriffe (Sprachkonstrukte) und um ihre Kombination zu einem transparenten Text, der den Sachverhalt (die Problemlösung) so einfach wie möglich vermittelt. Im Kapitel I erläutern wir Konstrukte der Programmiersprache LISP und ihre Handhabung mit dem Ziel, ein „zweckmäßiges" (transparentes und effizientes) Programm zu konstruieren (Abschnitt 1). Programmieren wird als Lösen einer Konstruktionsaufgabe aufgefaßt (Abschnitt 2), wobei der Programmtext (Quellcodetext) die Konstruktion einerseits für den Programmierer (Transparenzaspekt) und andererseits für den Rechner (Effizienzsaspekt) dokumentiert. Bestimmte Konstruktionen sind für eine Programmiersprache charakteristisch. Für LISP sind es die Konstruktionen der rekursiven Problemlösungsmethode. Nicht jede weitverbreitete Programmiersprache verfügt über Konstrukte für rekursive Lösungen; z.B. besitzt COBOL (Abk. für engl.: common business oriented Zanguage) selbst im derzeit gültigem Standard (American National Standard COBOL X3.23-1985) über kein Konstrukt zur Formulierung rekursiver Definitionen; es müssen iterative (Ersatz-)Lösungen gewählt werden. Obwohl LISP iterative Konstrukte umfaßt (Abschnitt 2.2.3), unterstützt LISP rekursive Lösungen in besonderem Maße. Die Rekursion wird daher ausführlich erörtert (Abschnitt 3).

1. Einführung: Handhabung von Konstrukten Heute ist LISP eine universelle Programmiersprache, eine dialogorientierte Software-Entwicklungsumgebung, eine Menge vordefinierter Bausteine („Konstrukte") und ein Formalismus zur Spezifikation (Präzisierung) eines Problems. Die Ursprungsfassung konzipierte John McCarthy zwischen 1956 und 1958 am Massachusetts Institute of Technology Cambridge, Massachusetts (MIT) (vgl. McCarthy, 1960; McCarthy, 1966). Dabei konnte er auf frühere Arbeiten zurückgreifen, insbesondere auf die erste Listen-Verarbeitungs-Sprache mit dem Namen IPL (Akronym für: information-Processing Language), die Mitte der

1. Einführung: Handhabung von Konstrukten

3

fünfziger Jahre von Herbert A. Simon, A. Newell und J.C. Shaw entwickelt wurde. Mehr als 30 Jahre Geschichte haben zu einer großen Anzahl von LISP-Dialekten geführt (vgl. Anhang B) und zu mehreren Versuchen, einen Standard zu definieren und diesen durchzusetzen, zum Beispiel Common LISP (vgl. Steele u.a., 1984) oder Scheme (vgl. Rees/Clinger, 1986). Trotz der Vielfalt existierender Dialekte gibt es einen gemeinsamen LISP-Kern, das sogenannte „Pure LISP". Typisch für diesen Kern ist die Möglichkeit anwendungsspezifische Funktionen mit Hilfe des LAMBDA-Konstruktes (vgl. Abschnitt 1.4.1) definieren zu können. LISP ist konzipiert für den Umgang mit Symbolen. Wie der Name „L/St Processing" besagt, ist LISP geprägt: o durch die Liste als das Mittel zur Darstellung von Strukturen und o durch den Prozeß der Auswertung von Listen (symbolischen Ausdrücken). Beide Kennzeichen werden erst im Sinne einer „Kostprobe" vermittelt und in den folgenden Abschnitten unter verschiedenen Aspekten weiter vertieft. Zunächst ist es erforderlich die Syntax elementarer Konstrukte (engl.: primitives) zu erläutern. Danach gilt es die Semantik dieser Konstrukte zu beschreiben. Dabei geht es um die Bedeutung der elementaren Konstrukte, d.h. um die Werte, die solche Konstrukte aus (korrekten) Eingaben berechnen.

1.1 Syntax: Symbolischer Ausdruck Die Bausteine zur Konstruktion einer Liste sind die leere Liste und (Listen-)Elemente. Ein einfaches Element kann z.B. eine Zahl oder ein Symbol sein. Solche Elemente werden auch Atome genannt. Diese Bezeichnung weist darauf hin, daß sie einerseits eine (kleinste) betrachtbare Einheit und anderseits der Stoff zum Bau komplexer Konstruktionen sind. Später zeigen wir, daß auch in LISP die Atome aus elementaren Teilchen bestehen (vgl. Abschnitt 7.3). Die leere Liste wird dargestellt durch eine öffnende Klammer „(", unmittelbar gefolgt von einer schließenden Klammer „)". Diese leere Liste wird auch durch

4

I. Konstrukte (Bausteine zum Programmieren)

das Symbol NIL repräsentiert. Werden Elemente in die leere Liste eingefügt, wobei die Elemente selbst wiederum Listen sein können, dann entstehen geschachtelte Listen. Das Fundament („Mutter Erde") für solche komplexen Strukturen ist NIL, die leere Liste. Das Bild 1.1-1 zeigt Schritte zur Konstruktion einer geschachtelten Listestruktur. Die Liste selbst und jedes Element stellen einen sogenannten symbolischen Ausdruck dar (engl.: symbolic expression; abgekürzt „s-expression" oder kürzer „sexpr"; Plural "sexprs").

Erzeugte

Schritt 1. 2. 3. 4. 5. 6. Bild

Leere Liste: Element C eingefügt: Element B vorn eingefügt: Element A vorn e i n g e f ü g t : L i s t e (E F G) an d i e Stel e von A g e s e t z t : Element A vorn eingefügt: 1.1- 1. Beispiel:

Von

NIL

zu

einer

Struktur:

()

(C) (B C) (A B C) ((E F G) B C) (A (E F G) B C) geschachtelten

Liste

Ein symbolischer Ausdruck kann sein: o ein Symbol (auch Literalatom genannt), Z.B. A oder NULL? oder MEYER-AG, notiert als ein Buchstabe oder Sonderzeichen, gefolgt von keinem oder weiteren Buchstaben oder Sonderzeichen. o eine Zahl (auch Zahlatom genannt), Z.B. 77 oder +67.23, notiert mit optionalem Vorzeichen und gefolgt von einer oder mehreren Ziffer(n) und optionalem Dezimalpunkt. o ein Zeichen (engl.: character), Z.B #\a, dargestellt als Nummernzeichen # (engl.: sharp sign) gefolgt von einem Schrägstrich (engl.: backslash) und gefolgt von dem jeweiligen Zeichen. o eine Zeichenkette (engl.: string), Z.B. "Programmiersprachen bleiben bedeutsam", notiert als doppeltes Hochkomma, gefolgt von keinem, einem oder mehreren Zeichen und abgeschlossen wieder mit einem doppelten Hochkomma. o eine Liste von symbolischen Ausdrücken Z.B. (A (B)) oder (ABBUCHUNG! MEYER-AG 67.23), notiert als öffnende Klammer gefolgt von keinem, einem oder mehreren symbolischen Ausdrükken und einer schließenden Klammer.

1. Einführung: Handhabung von Konstrukten o und abhängig vom jeweiligen LISP-System weitere Typen und Strukturen Z.B. Vektoren, spezielle Symbole für Boolsche Wahrheitswerte, Umgebungen etc. Ein LISP-Programm ist ein symbolischer Ausdruck, der sich aus symbolischen Ausdrücken zusammensetzen kann, die sich wiederum aus symbolischen Ausdrücken zusammensetzen können usw. Ein LISP-Programm besteht letztlich aus zusammengesetzten symbolischen Ausdrücken einfachen Typs. Diese Typen haben Eigenschaften, die verstehbar sein sollten, unabhängig von den Implementations-Details des jeweiligen LISP-Systems (vgl. Bild 1.1-2). Jeder symbolische Ausdruck ist eine Datenstruktur und gleichzeitig ein syntaktisch korrektes LISP-Programm (im Sinne einer kontextfreien Analyse). Ein LISP-Programm bewirkt nichts anderes, als symbolische Ausdrücke ein- und auszugeben, neu zu konstruieren, zu modifizieren und/oder zu vernichten. Die LISP-Syntax ist durch die Regeln zur Bildung symbolischer Ausdrücke definiert. Die Liste, ein symbolische Ausdruck, kann sich wiederum aus Listen zusammensetzen. Die LISP-Syntax ist aufgrund dieser rekursiven Definition sehr einfach.

Konstrukte Konstrukt

Konstrukt

symbolisehe

Ausdrücke

- T Y P : Elementare

Symbol

sind

Zahl

L I S P - K o n s t r u k t e aus Zei chen

Benutzersicht

Zei chenkette

Liste

- Repräsentation:

Elementare L I S P - K o n s t r u k t e aus I m p l e m e n t a t i o n s s i c h t Realisierung abhanging vom jeweiligen LISP-System

Legende: === ::=

B e t r a c h t u n g s e b e n e ; V e r s t e h e n der e l e m e n t a r e n K o n s t r u k t e ohne I m p l e m e n t a t i o n s - D e t a i 1 k e n n t n i s s e

Bild 1.1-2. Symbolisehe

Ausdrücke

(kurz:

sexprs)

6

I. Konstrukte (Bausteine zum Programmieren)

Beispiele für Listen: (FRANZ MEYER-GMBH) (HANS 0TT0-0HG (ABTEILUNG 3 ) ) (T NIL NIL N I L ) ( ( ) NIL) ( ( E I N E ) (GUELTIGE L I S T E ) IST DIES MIT ZAHLATOM 12) ( ( ( ( ( A ) ) ) ( ( ( B ) ) ) ) ( 1 2 3 4 5 6 7 8 9))

Beispiel für eine unvollständige Liste-. ( D I E S ( I S T ) ) ((NICHT E I N E ) ) L I S T E )

Dieser Listennotation fehlt d i e öffnende Klammer am Anfang!

Um zu erkennen, ob eine gültige Liste vorliegt, bedarf es der Zuordnung der öffnenden Klammern „(" zu den schließenden Klammern „)". Nur wenn die Zahl der öffnenden Klammern gleich der Zahl der schließenden ist, kann eine oder können mehrere Listen vorliegen. Diese Bedingung ist notwendig, jedoch nicht hinreichend, wie der folgende Fall zeigt. ) ) ( K E I N E LISTE (

¡Keine L i s t e , da f a l s c h e

Klammernfolge!

Ein Verfahren zum Erkennen zusammengehörender Klammern ist daher erforderlich. Es stellt fest, ob es sich um eine oder mehrere Listen handelt oder keine ordnungsgemäße Liste vorliegt. Bei vielen öffnenden und schließenden Klammern ist nicht gleich überschaubar, welche Liste durch welche beiden Klammern begrenzt wird. Nicht zuletzt darauf beruht die spöttische Uminterpretation des Akronyms LISP in „Lots of /nsidious Silly Parentheses". Das folgende Beispiel verdeutlicht das Problem bei vielen Klammern. ( ( H I E R (SIND

(VIELE)(SCHOENE)))((KLAMMERN)(((ZU)))((ZAEHLEN))))

Moderne LISP-Systeme entschärfen diese Klammern-Zuordnungsproblematik durch integrierte Struktureditoren, die zu einer schließenden Klammer die zugehörende öffnende Klammer hervorheben, z.B. durch Aufblinkenlassen dieser Klammer (z.B. EDWIN in PC Scheme, vgl. Anhang C). Da beim Analysieren von LISP-Texten nicht immer eine entsprechende Rechnerunterstützung verfügbar ist, müssen die Klammern in der Praxis auch manuell „gezählt" werden. Es gibt verschiedene Empfehlungen für das Vorgehen beim Klammernzählen (vgl. z.B. Siklössy, 1976, S. 214 ff). Die Tabelle 1.1-1 skizziert ein Verfahren mit Angabe der Schachtelungstiefe von Listen in Listen. Dieses Verfahren, auf das obige Beispiel angewendet, ergibt folgende Schachtelungstiefen:

1. Einführung: Handhabung von Konstrukten

7

( (HIER (SIND (VIELE) (SCHOENE) ) ) 1 2 3 4 4 4 4 3 2 ( (KLAMMERN) 2 3 3

( 3

( 4

5

(ZU) 5 4

3

) ) ( (ZAEHLEN) ) ) ) 3 4 4 3 2 1

LISTENERKENN.UNG 1.

Erste

Zeichen

prüfen

Ist es e i n e ö f f n e n d e K l a m m e r , d a n n s e t z e i h r e S C H A C H T E L U N G S T I E F E a u f 1, andernfal1s b e e n d e L I S T E N E R K E N N U N G , d e n n es ist k e i n e 2.

Klammern

Liste.

markieren

Suche zeichenweise nach Zeichen bis zum letzten SCHACHTELUNGSTIEFE nach

Klammern, beginnend vom ersten Zeichen, und notiere die folgender Vorschrift:

Jede ö f f n e n d e K l a m m e r e r h ä l t eine um 1 h ö h e r e S C H A C H T E L U N G S T I E F E , wenn die z u l e t z t m a r k i e r t e Klamm e r (= V o r g ä n g e r k l a m m e r ) e i n e ö f f n e n d e K l a m m e r i s t , a n d e r n f a l l s e r h ä l t sie d i e S C H A C H T E L U N G S T I E F E d e r Vorgängerklammer. J e d e s c h l i e ß e n d e K l a m m e r e r h ä l t e i n e um 1 k l e i n e r e S C H A C H T E L U N G S T I E F E , wenn die zuletzt m a r k i e r t e Klamm e r (= V o r g ä n g e r k l a m m e r ) e i n e s c h l i e ß e n d e K l a m m e r i s t , a n d e r n f a l l s e r h ä l t sie die S C H A C H T E L U N G S T I E F E der Vorgängerklammer. 3.

Ergebnis

feststellen

Hat eine schließende Klammer die S C H A C H T E L U N G S T I E F E < 1 , dann liegt keine o r d n u n g s g e m ä ß e Liste vor. Es f e h l e n ö f f n e n d e K l a m m e r n . Hat eine schließende Klammer die S C H A C H T E L U N G S T I E F E = 1 , dann m a r k i e r t d i e s e das Ende einer Liste. Haben nur die erste und letzte Klammer die S C H A C H T E L U N G S T I E F E = 1 und ist d i e s e sonst > 1 , dann bilden alle Klammern eine Liste. Tab.1.1-1.

Verfahren zum bei Listen

Erkennen

der

Schachtelungstiefe

Ergebnis des Verfahrens: Es liegt eine ordnungsgemäße Liste vor. Die zunächst ungewohnte Vielzahl von Klammern zeigt nach kurzer Eingewöhnungszeit ihre Vorteile. Wir sparen damit das Schreiben vieler „BEGINEND"- oder „DO-OD"-Paare ein. Auch das Problem der Reichweite bei der

8

I. Konstrukte (Bausteine zum Programmieren)

Schachtelung von Alternativen (vgl. Abschnitt 2.2.2), das sogenannte „baumelnde" ELSE-Problem, wird vermieden.

(JT^ÄV)

= 3 =

( — )

( — ) ( — )

(

1.2 Semantik: Regeln zum Auswerten (Evaluieren) Der Prozeß, betont im Namen „L/St Processing", bewirkt die Auswertung von symbolischen Ausdrücken. Ein LISP-System liest einen symbolischen Ausdruck ein, z.B. von einer öffnenden Klammer bis zur korrespondierenden schließenden Klammer, und wertet diesen Ausdruck aus. Als Vollzug der Auswertung gibt es einen symbolischen Ausdruck zurück, der als Wert (engl.: value) des eingelesenen Ausdruckes betrachtet wird. Der Prozeß besteht aus drei Phasen: o Einlesen (READ-Phase), o Auswerten (EVAL-Phase) und o Ausgeben (PRINT-Phase). Ein LISP-System kann nach diesen drei Phasen den nächsten symbolischen Ausdruck auswerten. Der Prozeß ist somit ein READ-EVAL-PRINT-Zyklus (vgl. Bild 1.2-1). In diesem Buch sind die drei Prozeßphasen durch folgende Notation abgegrenzt: eval>

— >

¡Kommentar

Beispiel: eval>

(ABBUCHUNG! MEYER-AG 6 7 . 2 3 ) = = > 4 1 . 4 5

;Neuer

Saldo

Der nach dem Prompt eval> notierte symbolische Ausdruck durchläuft die READ- und die EVAL-Phase. Der symbolische Ausdruck, notiert nach dem Pfeil = = > , ist der ausgegebene Wert, d.h. das Ergebnis der PRINT-Phase. Der Text in einer Zeile, notiert hinter einem Semikolon, ist zusätzlicher Kommentar. Die Regeln zur Auswertung („Evaluierung") definieren die operationale Semantik von LISP, d.h. die Bedeutung der symbolischen Ausdrücke für die Abarbeitung durch das LISP-System. Diese „mechanische" Semantik ist in dem EVAL-

1. Einführung: Handhabung von Konstrukten

9

Konstrukt des LISP-Systems abgebildet. Die Regeln sind daher selbst in LISP formuliert.

- 0 eval> 12.34567 ==> 12.34567 eval> #\a ==> #\a eval> "Mein Programm: " ==> "Mein Programm: " eval> TRUE ==> #T e v a l > F A L S E ==>

()

¡Zeichen

(engl.:

character)

;Zeichenkette (engl.: string) ¡Repräsentation des W a h r h e i t s ; wertes "wahr" ¡Repräsentation des W a h r h e i t s ; wertes "nicht wahr"

10

I. Konstrukte (Bausteine zum Programmieren)

EVAL-Regel 2: Evaluieren einer Liste des Typs ( . . . )

Ist der symbolische Ausdruck eine Liste des Typs ( . . . ) dann ergibt sich der Wert durch Evaluieren der Argumente ... und anschließender Anwendung der Funktion auf diese Werte. Hier sei eine Funktion durch ein Symbol benannt. Zum Beispiel benennt das Symbol + üblicherweise die Additionsfunktion. (Anonyme Funktionen vgl. Abschnitt 1.4.1). ^Hinweis: Begriff "Funktion". Wie in LISP-ischer Terminologie üblich (vgl. z.B. Allen, 1978 oder Stoyan/Görz, 1984) sprechen wir hier von einer Funktion oder auch LISP-Funktion, obwohl das Konstrukt im mathematischen Sinne keine Funktion darstellt, sondern eine Prozedur oder einen Algorithmus. Der Begriff „Prozedur" betont den Prozeß für die Berechnung von Werten für eine Funktion. Mathematisch ist eine Funktion eine existierende eindeutige Zuordnung von Elementen der Definitionsmenge (engl.: domain) zu Elementen der Wertemenge (engl.: ränge), wobei es keinen Berechnungsprozeß gibt. Wenn verkürzt formuliert ist: „Eine Funktion F gibt den Wert Y zurück.", dann ist damit gemeint, daß die algorithmische Repräsentation der Funktion F den Wert Y produziert; kurz: Es handelt sich um die Ausführung der Prozedur F.] Mit der Nennung des Operations-Symbols als erstem Element einer Liste folgt LISP der Präfix-Notation. Die Präfix-Notation, auch Polnische Notation nach der polnischen Logikerschule um J. Lukasiewicz (1878 bis 1956) genannt, bezieht sich in LISP auf alle Operationen. Arithmetische Funktionen wie Addition, Subtraktion, Multiplikation oder Division haben damit eine gegenüber der Schulmathematik ungewohnte Schreibweise. Die Präfix-Notation gewährleistet eine einheitliche Syntax, unabhängig von der Zahl der Argumente. Die Operation steht stets an erster Stelle in einer Liste. Beispiele zur EVAL-Regel 2: eval> ( + 1 2 3) ==> 6 eval> (SIN 0) ==> 0. eval> (COS 1) ==> 0.54030230586814 eval> (* 11111111111111111111111111111111111111111111111111111 22222222222222222222222222222222222222222222222222222

33333333333333333333333333333333333333333333333333333) ==> 82304526748971193415637860082304526748971193415637857 61316872427983539094650205761316872427983539094650208 230452674897119341563786008230452674897119341563786 Die Argumente ... können Listen sein und damit ebenfalls dem Konstrukt-Typ ( ... ) entsprechen, so daß auch für sie die EVAL-Regel 2 anzuwenden ist.

1. Einführung: Handhabung von Konstrukten

11

eval> (+ 1 (+ 1 3) 1) ==> 6 eval> (MAX (+ 0 . 4 0 . 6 ) (+ 2.34 1)) ==> 3.34 eval> (+ ( - (+ (- 1 1) 1) 1) 1) ==> 1 EVAL-Regel 3: Evaluieren einer Liste des Typs (

... )

Ist der symbolische Ausdruck eine Liste des Typs ( < s p e z i e l 1es-symbol> . . . ) dann hängt der Wert von der Definition des speziellen Symbols ab. Ob von den einzelnen Argumenten ... einige evaluiert werden oder nicht, bestimmt die Definition, die das spezielle Symbol benennt. Ein LISP-System erkennt seine speziellen Symbole, so daß es nicht die EVAL-Regel 2 anwendet, sondern die für das spezielle Symbol definierte Evaluierung ausführt. Beispiele zur EVAL-Regel 3: Spezielles Symbol IF. Bei der Alternative (vgl. Bild 1.2-2) in der Art „if ... then ... eise ... end-if", die anhand des speziellen Symbols IF erkannt wird, evaluiert das LISP-System zunächst das erste Argument, hier cbedingungssexpr>. Sein Wert bestimmt die weitere Abarbeitung, d.h. welches Argument als nächstes zu evaluieren ist. Ist der Wert von ungleich NIL, d.h. die Bedingung gilt als erfüllt („True-Fall"), dann wird evaluiert und der gesamte IF-Ausdruck hat den Wert von . Ist der Wert von gleich NIL, d.h. die Bedingung gilt als nicht erfüllt („False-Fall"), wird die Alternative, formuliert als drittes Argument, evaluiert. Im „False-Fall" hat der gesamte IF-Ausdruck den Wert von . ( I F

)

Bild 1 . 2 - 2 . Alternative - Graphische D a r s t e l l u n g nach DIN 66261 (Struktogramme, v g l . Nassi/Shneiderman, eval> ( I F NIL "Ja" "Nein") ==> "Nein" eval> (IF #T "Ja" "Nein") ==> "Ja" eval> (IF 1 2 3) ==> 2

1973)

12

I. Konstrukte (Bausteine zum Programmieren)

eval>

( I F ANTWORT? "Dank f ü r d i e Z u s t i m m u n g . " "Denken S i e m i t ! " ) = = > "Dank f ü r d i e Z u s t i m m u n g . "

;Bei d i e s e m R ü c k a g e b e w e r t hat das Symbol ANTWORT? e i n e n Wert ; u n g l e i c h N I L . Er bestimmt s i c h nach der Regel f ü r das E v a l u ; i e r e n von Symbolen ( v g l . EVAL-REGEL 4 ) .

Spezielles Symbol DEFINE. eval>

( D E F I N E < s e x p r > ) ==>

Das spezielle Symbol DEFINE bindet ein Symbol an den Wert von im aktuellen Kontext, d.h. die Bindung findet in der Umgebung statt, in dem die DEFINE-Auswertung erfolgt. (Näheres zur Auswertungsumgebung später, vgl. z.B. Abschnitt 1.4.2). Dabei wird das erste Argument, hier , nicht evaluiert; das zweite, hier , jedoch. Der Wert des gesamten DEFINE-Konstruktes ist uninteressant und deshalb prinzipiell auch nicht spezifiziert. Da der READ-EVAL-PRINT-Zyklus für jeden eingelesenen symbolischen Ausdruck einen Wert zurückgibt (PRINT-Phase), hat auch das DEFINE-Konstrukt stets einen Wert. In PC Scheme wird dazu das gebundene Symbol als Wert zurückgegeben. Die Aufgabe des DEFINE-Konstruktes ist nicht die Rückgabe eines Wertes, sondern das Binden eines Symbols an einen Wert. Anders formuliert: Zwischen dem Symbol und seinem Wert entsteht eine Verbindung (Assoziation). Das Symbol „benennt" den Wert. Das DEFINE-Konstrukt ist somit der „Benennungsoperator" für symbolische Ausdrücke. /Common LISP: SETQ-Konstrukt. Die Bindung übernimmt in Common LISP und in vielen anderen Dialekten das SETQ-Konstrukt. Sein (Rückgabe-)Wert ist nicht das Symbol, sondern der Wert, an den das Symbol gebunden wird.7 eval> eval>

( D E F I N E MÜLLER-OHG ( * 0 . 1 4 1 0 0 ) ) ( D E F I N E MEYER-AG " D - 7 5 0 0 K a r l s r u h e " )

= = > MÜLLER-OHG = = > MEYER-AG

/Common LISP: C-eval>

(SETQ MÜLLER-OHG ( * 0 . 1 4 1 0 0 ) ) ==> 14

]

EVAL-Regel 4: Evaluieren eines Symbols Ist der symbolische Ausdruck ein Symbol, dann ist sein Wert derjenige symbolische Ausdruck, an den es in der (aktuellen) Umgebung gebunden ist. Gibt es keine entsprechende Bindung, dann führt das Evaluieren des Symbols zu keinem Wert, sondern abhängig vom jeweiligen LISP-System zu einer Fehlermeldung und zum Übergang in einen Fehlerkorrektur-Modus (engl.: inspect/debug-level). Beispiele zur EVAL-REGEL 4:

e v a l > ( D E F I N E SCHMIDT-GMBH 1 4 . 8 9 ) = = > SCHMIDT-GMBH e v a l > SCHMIDT-GMBH = = > 1 4 . 8 9 e v a l > ( D E F I N E MEYER-AG SCHMIDT-GMBH) = = > MEYER-AG

1. Einführung: Handhabung von Konstrukten eval> M E Y E R - A G ==> 14.89 eval> OTTO ==> ERROR V a r i a b l e not defined in current OTTO [inspect] ;Testmodus

13

environment

1.3 Repräsentation von Daten und Programm Im Mittelpunkt der Softwarekonstruktion steht der Begriff „Algorithmus". Darunter versteht man ein eindeutig bestimmtes Verfahren (Prozeß) oder die Beschreibung eines solchen Verfahrens. Diese intuitive Definition verdeutlicht, daß es bei einem Algorithmus nicht nur um ein Verfahren geht, sondern auch um seine Beschreibung. Sie kann in einer natürlichen oder formalen Sprache (z.B. in LISP) oder mit Hilfe eines graphischen Darstellungsmittel (z.B. Struktogramm) erfolgen. Bedeutsam ist die Eindeutigkeit der Beschreibung mit Hilfe eines endlichen Textes. Bestimmt wird ein Algorithmus durch die Vorgabe: o einer Menge von Eingabe-, Zwischen- und Endgrößen, o einer Menge von Elementaroperationen und o der Vorschrift, in welcher Reihenfolge welche Operationen wann auszuführen sind. /Exkurs: Algorithmus. Bei den theoretisch fundierten Definitionen des Alogrithmusbegriffs z.B. von A. M. Turing oder A. A. Markow geht es um Aufzählbarkeit, Berechenbarkeit und Entscheidbarkeit. In diesem Zusammenhang hat A. Church nachgewiesen, daß bei jeder möglichen Präzisierung des Algorithmusbegriffs die dadurch entstehende Klasse von berechenbaren Funktionen mit der Klasse der allgemein rekursiven Funktionen zusammenfällt (Näheres vgl. z.B. Klaus/Liebscher, 1979).] Im heutigen Programmieralltag z.B. bei der Erstellung eines Buchungsprogrammes in COBOL spricht man eher vom „Programm" als vom "Algorithmus". Dabei unterscheidet man strikt zwischen den „Daten" (Eingabe-, Zwischen- und Endgrößen) und dem „Programm" (Vorschrift basierend auf Elementaroperationen), obwohl im „von Neumann"-Rechner die Trennungslinie zwischen Programm und Daten unscharf ist. Man verbindet mit dem Begriff „Programm" etwas Aktives wie Datenerzeugen, -modifizieren oder -löschen. Die „Daten" selbst sind dabei passiv. Sie werden vom „Programm" manipuliert. Diese Unterscheidung hat für symbolische Ausdrücke wenig Aussagekraft; denn jeder symbolische Ausdruck ist einerseits ein „Programm", dessen Ausgabe (Wert) er im Zusammenwirken mit den EVAL-Regeln definiert, und andererseits das Mittel, um in LISP „Daten" darzustellen. Von Bedeutung ist in LISP die Frage, ob und wie ein symbolischer Ausdruck evaluiert wird. Sie ist entscheidend, wenn man eine Unterteilung in „Daten" und „Programm" vornehmen will. Bei einer Zeichenkette, z.B. "Programmieren ist das Abbilden von Wissen", besteht kein Grund diese zu evaluieren, weil sie selbst das Ergebnis ist. Zahlen, Zeichen und Zeichenketten haben eher passiven

14

I. Konstrukte (Bausteine zum Programmieren)

S Charakter; sie zählen zur Kategorie „Daten". Die Liste ist ambivalent. Sie gehört sowohl zur Kategorie „Daten" als auch zur Kategorie „Programm". Das folgende Beispiel verdeutlicht diese Ambivalenz. Beispiel:

Buchungsprogramm

Vom Konto MEYER-AG ist ein Betrag von DM 67,23 abzubuchen. Wir formulieren folgende Liste: eval>

(ABBUCHEN!

MEYER-AG

67.23)

==>

1200.45

Wir erhalten den neuen Saldo DM 1200.45, vorausgesetzt es existiert eine Funktion ABBUCHEN! und ein Konto MEYER-AG mit dem alten Saldo DM 1267.68 . Das Ergebnis von 1200.45 entstand durch „Laufenlassen" des Programmes: (ABBUCHEN! MEYER-AG 67.23). Diese Liste führt zu einer Ausgabe („Output"), indem sie dem READ-EVAL-PRINT-Zyklus übergeben wird; wir müßten sie der Kategorie „Programm" zuordnen. Jetzt wollen wir annehmen, daß die Information, vom Konto MEYER-AG sei ein Betrag von DM 67.23 abzubuchen, im Sinne von Daten einem LISP-System einzugeben ist. Wir können z.B. unterstellen, es sei nur zu beschreiben, daß abzubuchen ist, aber die Buchung selbst ist nicht zu vollziehen, weil das Konto MEYER-AG noch nicht freigegeben ist. Zunächst könnte diese Information statt als Liste als Zeichenkette dem READ-EVAL-PRINT-Zyklus übergeben werden: eval>

"ABBUCHEN!

MEYER-AG

67.23"

==>

"ABBUCHEN!

MEYER-AG

67.23"

Behalten wir jedoch die Liste bei, dann dürfen die EVAL-Regeln auf diese Liste nicht angewendet werden. Die Auswertung wäre zu blockieren, so daß ABBUCHEN! nicht als Name einer Funktion interpretiert wird. EVAL-Regel 3 bietet die Möglichkeit, anhand eines speziellen Symbols über die Auswertung der Argumente zu entscheiden. Das spezielle Symbol QUOTE repräsentiert diesen „Auswertungsblocker". Um EVAL-Regel 3 zur Anwendung zu bringen, muß

1. Einführung: Handhabung von Konstrukten

15

die Liste als Argument für das spezielle Symbol QUOTE geschrieben werden. Wir formulieren daher: eval>

(QUOTE (ABBUCHEN!

MEYER-AG

67.23)) = = > (ABBUCHEN!

MEYER-AG

67.23)

Da das Einfügen eines symbolischen Ausdrucks in die Liste mit dem Auswertungsblocker QUOTE als erstem Element häufig vorkommt, gibt es dafür eine Kurzschreibweise mit dem Hochkomma ' (engl.: quote mark). Es wird in der READ-Phase zum eigentlichen QUOTE-Konstrukt aufgelöst. eval>

'(ABBUCHEN!

MEYER-AG 6 7 . 2 3 )

==>

(ABBUCHEN!

MEYER-AG

67.23)

Wird das Evaluieren einer Liste blockiert, dann verhält sie sich analog zu einer Zeichenkette. Sie bleibt „bestehen". Wir müßten sie aus dieser Sicht der Kategorie „Daten" zuordnen. Einprägsam formuliert: Die „Quotierung" blockiert die Auswertung. Ein quotierter symbolischer Ausdruck entspricht einer Konstanten. Beispiele zum QUOTE-Konstrukt: e v a I > ' ( A B C ) ==> eval > C A 'B ' C ) = = > ERROR .

(AB

C)

Nach E V A L - R e g e l 3 i s t d e r Wert von (QUOTE A) = = > A D i e s e s A i s t weder d e r Programmcode e i n e r Funktion entsprechend EVAL-Regel noch d e r e i n e s s p e z i e l l e n S y m b o l s e n t s p r e c h e n d E V A L - R e g e l 3.

eval>

(SIN ' ( + 0.2 0 . 3 ) ) = = > ERROR . D i e Q u o t i e r u n g des A r g u m e n t s v e r h i n d e r t d i e A u s w e r t u n g von ( + 0 . 2 0 . 3 ) = = > 0 . 5 . Der S i n u s e i n e r L i s t e i s t n i c h t d e f i n i e r t , s o daß e i n e F e h l e r m e l d u n g e r f o l g t .

eval>

(SIN

(+ 0.2

0.3))

==>

0.479425538604203

/Hinweis: Flüchtigkeitsfehler. Häufig haben (Flüchtigkeits-)Fehler ihre Ursache in einer vergessenen oder falschen Hochkomma-Notierung. Prüfen Sie deshalb zunächst, ob der symbolische Ausdruck selbst oder sein Wert gemeint ist (vgl. Abschnitt 2.4).] Das Komplement zum QUOTE-Konstrukt ist das EVAL-Konstrukt. Es bewirkt die Anwendung der EVAL-Regeln. Diese transformieren eine „Konstante" als Datum wieder in die Rolle eines „Programms". In LISP sind „Programme" und „Daten" gleichermaßen als symbolischer Ausdruck abgebildet. Als Merksatz formuliert: Die Repräsentation von LISP-Programmen als LISP-Daten ist eine

16

I. Konstrukte (Bausteine zum Programmieren)

Haupteigenschaft dieser Programmiersprache. Sie ermöglicht das Manipulieren von Programmen durch Programme ohne die übliche Trennung in Systemprogrammierung und Anwednungsprogrammierung. Jeder LISP-Benutzer kann sein LISP-System selbst verbessern, wobei viele dieser Verbesserungen letztlich zur Verbesserung der kaufbaren LISP-Systeme geführt haben (vgl. McCarthy, 1980). Die folgenden EVAL-Beispiele dienen als erster Einstieg. Im Zusammenhang mit der Diskussion des Umgebungskonzeptes (vgl. Abschnitt 1.4.2) wird das EVAL-Konstrukt weiter erklärt. Beispiele zum EVAL-Konstrukt: eval> eval> eval> eval> eval> eval> eval> eval> eval> eval> eval>

'(+ 1 2) = = > (+ 1 2) ( E V A L '(+ 1 2 ) ) = = > 3 ( E V A L ' ( E V A L '(+ 1 2 ) ) ) = = > 3 ( D E F I N E M E I N E - A D D I T I O N '(+ 1 2)) = = > M E I N E - A D D I T I O N MEINE-ADDITION ==> (+ 1 2) (EVAL MEINE-ADDITION) ==> 3 ( D E F I N E N A C H R I C H T 'CIF A N T W O R T ? " M e y e r A G z a h l t ! " "Meyer AG zahlt nicht!") ==> NACHRICHT ( D E F I N E A N T W O R T ? ()) = = > A N T W O R T ? (EVAL NACHRICHT) ==> "Meyer AG zahlt nicht!" ( D E F I N E A N T W O R T ? 'Ja) = = > A N W O R T ? (EVAL NACHRICHT) ==> "Meyer AG zahlt!"

1.4 Konstrukt: Schnittstelle und Implementation Bisher wurde gezeigt: Ist der auszuwertende symbolische Ausdruck eine Liste, dann definiert das erste Element, ob die restlichen Listenelemente (Argumente) evaluiert werden oder nicht. Die restlichen Listenelemente können als Eingabe aufgefaßt werden. Sie sind Eingabe („input") für die Funktion, die durch das erste Listenelement benannt wird. Entsprechendes gilt, wenn das erste Element einen speziellen Fall benennt (EVAL-Regel 3). Die Eingabe-Schnittstelle zum Programmcode eines Konstruktes, das angewendet wird, bestimmt die Zulässigkeit eines Argumentes. So muß die Anzahl der angegebenen Argumente der jeweiligen Schnittstellen-Definition genügen. Zusätzlich muß der Typ eines Arguments passen. Arithmetische Funktionen fordern z.B. numerische Argumente, also symbolische Ausdrücke vom Typ Zahl bzw. Ausdrücke, die zum Typ Zahl evaluieren. Allgemein formuliert: Die Argumente müssen konsistent zur Schnittstelle sein. Beispiele zur Anzahl und zum Typ von Argumenten: eval>

eval> eval> eval>

(IF A N T W O R T ? " g e s t e r n " " h e u t e " " m o r g e n " ) = = > E R R O R ... ; Zu v i e l e A r g u m e n t e ( D E F I N E ) = = > E R R O R ... ;Zu w e n i g e A r g u m e n t e (DEFINE OTTO "Witzig" "Hudelig") = = > E R R O R ... ; Zu v i e l e A r g u m e n t e ( D E F I N E " M E Y E R - A G " " S a l d o i s t DM 1 2 3 . 4 5 " )

1. Einführung: Handhabung von Konstrukten ==>

ERROR

...

eval> (DEFINE MEYER-AG "Saldo eval> MEYER-AG ==> " S a l d o ist DM 1 2 3 . 4 5 "

eval>

(+ 1 2 ' A L T E R - W E R T ) = = > E R R O R ...

;Wertassoziation ; e i n Symbol

17 verlangt

ist DM 1 2 3 . 4 5 " ) = = >

MEYER-AG

¡Zeigt d e n W e r t der ; vorhergehenden DEFINE-Anwendung

; N i c h t n u m e r i s c h e r O p e r a n d für ; arithmetische Operation

eine

Betrachten wir einen symbolischen Ausdruck als gegebenes Konstrukt (als einen bereitgestellten Baustein) zur Abarbeitung einer spezifizierten Aufgabe, dann werden Angaben benötigt über: 1. die (Eingabe-)Schnittstelle, 2. den (Ausgabe-) Wert und über 3. die Nebeneffekte. /Hinweis: Mehrere (Ausgabe-)Werte (engl.: multiple valúes). Manche LISPSysteme, z.B. Common LISP, gestatten als Ergebnis des Evaluierens die Rückgabe von mehreren Werten. Da mehrere Werte (hilfsweise) in einer Liste zusammenfaßbar sind, betrachten wird diese Option nicht weiter./ zu 1) Schnittstelle: Die Kenntnis der Schnittstelle ist für die Wahl korrekter Argumente notwendig. zu 2) Wert: Zumindest muß der Typ des symbolischen Ausdrucks bekannt sein, den wir als Wert des Evaluierens erwarten, wenn wir diesen Wert als Argument für ein weiteres Konstrukt einsetzen wollen. Bekannt sein muß z.B., ob das Konstrukt eine Zahl, ein Symbol oder eine Liste als Wert hat. Beispiel für einen falschen Argument-Typ: eval>

(+ 3 ( D E F I N E M E Y E R - A G

2 4 5 . 3 4 ) 4) = = >

ERROR

...

Die A d d i t i o n s f u n k t i o n e r f o r d e r t n u m e r i s c h e A r g u m e n t e . Der W e r t des K o n s t r u k t e s ( D E F I N E M E Y E R - A G 5) ist M E Y E R - A G , a l s o ein S y m b o l . Es k o m m t w e g e n der I n k o m p a t i b i l i t ä t m i t der S c h n i t t s t e l l e der A d d i t i o n s f u n k t i o n zum F e h l e r .

zu 3) Nebeneffekt: Wenn symbolische Ausdrücke evaluiert werden, können sie nicht nur ihren Wert zurückgeben, sondern zusätzlich den Wert symbolischer Ausdrücke verändern. Sie verursachen einen Nebeneffekt, auch Seiteneffekt genannt. Bisher haben wir als einen solchen symbolischen Ausdruck das DEFINE-Konstrukt vorgestellt, d.h. die Liste mit dem speziellen Symbol DEFINE als erstem Element. Die Nebeneffekte eines Konstruktes müssen bekannt sein, um ihre Wertveränderungen einkalkulieren zu können.

18

I. Konstrukte (Bausteine zum Programmieren) Beispiel für einen Nebeneffekt: eval > S C H U L Z E - G M B H = = > eval > ( D E F I N E M E Y E R - A G ==> MEYER-AG

30.45 (DEFINE SCHULZE-GMBH 123.45)) ;Wert des D E F I N E - K o n s t r u k t e s ist in S c h e m e das g e b u n d e n e S y m b o l . N e b e n e f f e k t der M E Y E R - A G B i n d u n g ist d i e B i n d u n g von S C H U L Z E - G M B H an 1 2 3 . 4 5 . ==> SCHULZE-GMBH eval > M E Y E R - A G eval > (+ 0 . 5 5 S C H U L Z E - G M B H ) = = > 124.

/Exkurs: Signatur. Zur Spezifikation mit Hilfe von elementaren Funktionen (Operationen, nebeneffektfreien Konstrukten) fassen wir die Informationen: - Name der Funktion, - Typ der Argumente („domain" der Funktion) und - Rückgabewert („ränge" der Funktion) unter dem Begriff Signatur zusammen (vgl. Abschnitt 2.2).]

E I N G A B E :

Argument(e)

Schnittstelle [formale Parameter]

K 0 N S T R U K T:

A U S G A B E :

311d 1 . 4 - 1 .

I m p l e m e n t a t i on [Körper]

Wert(e)

Nebeneffekt(e)

LISP-Konstrukt

Solange es um Konstrukte geht, die das jeweilige LISP-System als eingebaute Konstrukte dem Benutzer direkt bereitstellt, ist ihre Implementation eine zweitrangige Frage. Bedeutsam sind für uns ihre Leistungskriterien: Anwortzeit- und Speicherplatz-Bedarf. Eine Darstellung des eigentlichen Programmcodes, der zur Anwendung kommt, hilft selten. Wir interessieren uns nicht für eine "externe" maschinenabhängige Repräsentation des Programmcodes (wohlmöglich, in Form von hexadezimalen Zahlen). Wesentlich ist die Abstraktion in Form des Symbols, das auf den Programmcode verweist. Beispielsweise interessiert uns bei der Additionsfunktion die Abstraktion in Form des + Symbols, verbunden mit Angaben zur Schnittstelle (hier: beliebig viele numerische Argumente), zum

1. Einführung: Handhabung von Konstrukten

19

(Rückgabe-)Wert (hier: eine Zahl) und zur Frage von Nebeneffekten (hier: keine). Soll ein selbst definiertes Konstrukt wie ein eingebautes Konstrukt benutzbar sein, dann ist es vorab zu implementieren. Implementation bedeutet hier: Es ist zu entscheiden, aus welchen dem LISP-System bekannten Konstrukten es zusammensetzbar ist. Unser Konstrukt besteht aus symbolischen Ausdrücken, auf die das LISP-System die EVAL-Regeln erfolgreich anwenden kann. Für die Einführung fassen wir zusammen (vgl. auch Bild 1.4-1): Definition Konstrukt: Ein Konstrukt („Baustein") ist ein symbolischer Ausdruck, konzipiert für die Anwendung der EVAL-Regeln. Sein Einsatz setzt Informationen voraus über: o die Schnittstelle (Anzahl der Argumente, Typ eines jeden Argumentes sowie die Festlegung, welche Argumente evaluiert werden.), o den (Rückgabe-)Wert (Vorhersage des Typs, z.B. ob Zahl, Symbol, Liste etc.) und über o Nebeneffekte (Veränderung des eigenen Zustandes und/oder des Zustandes von anderen symbolischen Ausdrücken). /Hinweis: Konstrukt. Der lateinische Begriff Konstrukt (Construct, Constructum) bezeichnet eine Arbeitshypothese für die Beschreibung von Phänomenen, die der direkten Beobachtung nicht zugänglich sind, sondern nur aus anderen beobachteten Daten erschlossen werden können. In der Linguistik ist z.B. Kompetenz ein solches Konstrukt. Wir bezeichnen mit Konstrukt einen verwendbaren „Baustein", der bestimmte Eigenschaften hat./ Beispiel zur Bezeichnung Konstrukt: Wir sprechen von einem DEFINE-Konstrukt, wenn es sich um die folgende Zeile handelt: (DEFINE

F00

'(INTERFACE

VALUE

SIDE-EFFECTS

BODY))

1.4.1 LAMBDA-Konstrukt Im Rahmen der EVAL-Regeln wurde gezeigt (vgl. Abschnitt 1.2), daß sich der Wert eines Konstruktes durch die Applikation (Anwendung) des Programmcodes auf die Argumente ergibt. Dabei bestimmt das erste Listenelement den Programmcode. Betrachten wir eine Funktion y = f(x), dann ist die grundlegende Operation die Applikation von f auf ein Argument x, um den Wert y zu erhalten. Bisher wurden eingebaute Konstrukte (Funktionen), wie z.B. + oder - oder MAX, auf Argumente angewendet. Nun wollen wir eigene Funktionen konstruieren. Grundlage dazu bildet das LAMBDA-Konstrukt. Es basiert auf dem Lamb-

20

I. Konstrukte (Bausteine zum Programmieren)

da-Kalkül, einem mathematischen Formalismus zur Beschreibung von Funktionen durch Rechenvorschriften. Alonzo Church hat für die Präzisierung der Berechenbarkeit diesen Lambda-Kalkül formuliert (vgl. Church, 1941; zur Evaluierung von Lambda-Ausdrükken vgl. Landin, 1964; zum Kalkülverstehen vgl. z.B. MacLennan, 1990; zur Implementation vgl. Allen, 1978). Programmiersprachen nach dem Modell des Lambda-Kalküls simulieren die sogenannten a - und ß-Reduktionsregeln des Kalküls mit Hilfe einer Symbol-Wert-Tabelle (Umgebung, vgl. Abschnitt 1.4.2). Die Simulation nutzt eine „Kopierregel", wobei an die Stelle der formalen Parameter (LAMBDA-Variablen) im Orginal in der Kopie die aktuellen Parameter (Argumente) gesetzt werden. Der griechische Buchstabe „X" selbst hat keine besondere Bedeutung. A. Church hat ihn in Anlehnung an die Notation von A.N. Whitehead und B. Russell benutzt (vgl. MacLennan, 1990, p. 357). Zur Eingabe auf alphanumerischen Terminals wird üblicherweise das Symbol LAMBDA verwendet. Eine selbst definierte Funktion entsteht durch Evaluierung des LAMBDAKonstruktes. eval>

(LAMBDA < s c h n i t t s t e l 1 e >

= = > # : : = S i e wird durch e i n e n oder mehrere f o r m a l e P a r a m e t e r im S i n n e von " P I a t z h a l t e r - V a r i a b l e n " f ü r d i e Argumente r e p r ä s e n t i e r t . M e h r e r e " P l a t z h a l t e r " werden a l s E l e m e n t e e i n e r L i s t e n o t i e r t . Die formalen Parameter b e z e i c h n e t man a l s L A M B D A - V a r i a b l e oder a l s l o k a l e V a r i a b l e n . Die f o r m a l e n P a r a m e t e r werden d u r c h S y m b o l e a n g e g e b e n .

::=

#

)

S i e w i r d d u r c h K o n s t r u k t e , b e i denen f o r m a l e P a r a m e t e r an S t e l l e n von A r g u m e n t e n s t e h e n , k o n s t r u i e r t . S i e w i r d auch a l s Term ( e n g l . : f o r m ) b e z e i c h n e t , um zu v e r d e u t l i c h e n , daß es e i n s y m b o l i s c h e r A u s d r u c k i s t , d e r e v a l u i e r t w i r d . Im Zusammenhang m i t d e r S c h n i t t s t e l l e bez e i c h n e t man d i e R e c h e n v o r s c h r i f t a l s (Funktions-)Körper ( e n g l . : body).

: : = S i e i s t d e r R ü c k g a b e w e r t des R E A D - E V A L P R I N T - Z y k l u s und r e p r ä s e n t i e r t h i l f s w e i s e d a s e n t s t a n d e n e F u n k t i o n s o b j e k t , d . h . den Programmcode, der d u r c h d i e S c h n i t t s t e l l e und d i e R e c h e n v o r s c h r i f t d e f i n i e r t i s t .

/Exkurs: Begriff "Argument". Argument ist die Bezeichnung für "Element der Definitionsmenge" einer Funktion. Ist f(x) definiert, so nennt man (salopp) auch

21

1. Einführung: Handhabung von Konstrukten

die Variable x Argument. Exakt sind jedoch nur die für x einzusetzenden Werte als die Argumente von f zu bezeichnen (vgl. z.B. Scheid, 1985).7 /Exkurs: Begriff "Variable". In Programmiersprachen ist die Variable primär als Gegensatz zur Konstanten zu sehen. Sie ist mit einer „Quantität" verbunden, die variiert werden kann. In der Mathematik benutzt man den Begriff „Variable" bei Funktionen im Sinne eines bestimmten, aber anonymen Elements einer Definitionsmenge (z.B. „X sei eine nichtnegative relie Zahl ...").] Beispiel fiir die Definition einer Funktion: Es ist eine Funktion ABBUCHEN zu definieren, die von einem Konto einen Betrag abbucht. Um den Vorgang leicht verstehen zu können, sind einige Zwischenschritte angebracht. Als ersten Schritt formulieren wir folgendes LAMBDA-Konstrukt: eval > (LAMBDA (ALTER_SALDO A B B U C H U N G S B E T R A G ) (- A L T E R _ S A L D O A B B U C H U N G S B E T R A G ) ) ==> # < P R O C E D U R E >

¡Schnittstelle ¡Rechenvorschrift

Die Schnittstelle hat die beiden formalen Parameter ALTER_ SALDO und ABBUCHUNGSBETRAG. Die Rechenvorschrift besteht nur aus der Subtraktionsfunktion, so daß wir eine Zahl als (Rückgabe-)Wert erwarten, wenn die entstandene Funktion angewendet wird. Wegen der Präfix-Notation bestimmt das erste Element einer Liste den anzuwendenden Programmcode. Beispielsweise benennt das Symbol Bindestrich (-) das Funktionsobjekt (den Programmcode) für die Subtraktion. Ermittelt man den Wert vom Symbol Bindestrich (gemäß EVAL-Regel 4, vgl. Abschnitt 1.2), dann erhält man das Funktionsobjekt und kann es auf die Werte seiner Argumente anwenden. Entsprechend ist das LAMBDA-Konstrukt als erstes Element einer Liste zu notieren. Die restlichen Listenelemente sind die Argumente, auf die das durch Evaluierung erzeugte Funktionsobjekt angewendet wird. Anwendung (Applikation) des eval>

LAMBDA-Konstruktes:

((LAMBDA < s c h n i t t s t e l 1 e > < r e c h e n v o r s c h r i f t > ) ... ) —•>

Da die Schnittstellendefinition zu erfüllen ist, sind in unserem Beispiel zwei weitere Listenelemente als Argumente anzugeben. eval>

;; 1. Listenelement ergibt Funktion ((LAMBDA (ALTER_SALDO A B B U C H U N G S B E T R A G ) (- A L T E R _ S A L D O A B B U C H U N G S B E T R A G ) ) 110.00 ¡2. Listenelement ist ihr 1. A r g u m e n t 50.00 ¡3. Listenelement ist ihr 2. A r g u m e n t ) ==> 60. ¡Wert

22

I. Konstrukte (Bausteine zum Programmieren)

Die Zuordnung des ersten Arguments, hier 110.00, zur LAMBDA-Variablen ALTER_ SALDO und des zweiten Arguments, hier 50.00, zur LAMBDA-Variablen ABBUCHUNGSBETRAG wird durch die Reihenfolge definiert. Die Argumente werden gemäß ihrer Reihenfolge an die LAMBDA-Variablen gebunden. Die Bindung der LAMBDA-Variablen folgt der Idee von Stellungsparametern. Ein gleichzeitiges Vertauschen der Reihenfolge der (nebeneffektfreien) Argumente und der LAMBDA-Variablen führt daher zum gleichen Wert. eval>

((LAMBDA (ABBUCHUNGSBETRAG ALTER_SALD0) (- ALTER_SALDO ABBUCHUNGSBETRAG)) 50.00

110.00)

==>

60.

Für den Wert des Konstruktes ist die Benennung der LAMBDA-Variablen unerheblich; soweit nicht Namenskonflikte mit freien Variablen auftreten (Näheres zur Konfliktlösung vgl. Abschnitt 7.4). Für das Verstehen eines Konstruktes ist die Benennung jedoch von entscheidender Bedeutung (Näheres dazu vgl. Abschnitt 11.1). Das folgende Konstrukt hat die Symbole X und Y als LAMBDAVariablen und bewirkt ebenfalls die obige Abbuchung. eval>

((LAMBDA

(X

Y)

(-

Y

X))

50.00

110.00)

==>

60.

;So

nicht!

Wird das LAMBDA-Konstrukt evaluiert, entsteht eine anonyme Funktion. Anonym, weil sie keinen Namen hat. Um die definierte Funktion zu benennen, wird ein Symbol an sie gebunden, d.h. der Wert eines Symbols ist das evaluierte LAMBDA-Konstrukt. Eine solche Bindung bewirkt in Scheme das DEFINEKonstrukt. eval> eval>

( D E F I N E ABBUCHEN (LAMBDA ( A L T E R _ S A L D 0 ABBUCHUNGSBETRAG) ( - A L T E R _ S A L D 0 A B B U C H U N G S B E T R A G ) ) ) ==> ABBUCHEN ==> #

ABBUCHEN

/Hinweis: Funktionsdefinition. Das Konstrukt mit dem der Benutzer eine Funktion definieren kann, hat in LISP-Systemen verschiedene Namen und unterschiedliche Wirkungen. In TLC-LISP heißt es DE, in Common LISP DEFUN. Allen gemeinsam ist das Verknüpfen eines Symbols mit einem Funktionsobjekt .] Das Symbol ABBUCHEN kann nun wie ein eingebautes Konstrukt, z.B. wie das Subtraktions-Konstrukt, angewendet werden. eval> eval>

( A B B U C H E N 1 1 0 . 0 0 5 0 . 0 0 ) ==> ( - 2 3 . 4 0 2 . 3 0 ) ==> 2 1 . 1

60.

Als leicht merkbares, begrenzt verallgemeinerbares Motto formuliert: „Form follwos function". Dieser beinahe klassische Leitsatz der (Industrie-)Designer gilt auch in LISP.

1. Einführung: Handhabung von Konstrukten (DEFINE

VERDOPPLUNG

23

(LAMBDA

(ZAHL)

Lfunction—I

(*

2

ZAHL)))

I—form—I

Das Anwenden einer Funktion auf Argumente ist mit dem APPLF-Konstrukt explizit notierbar. Es entspricht z.B.: eval> eval>

( ' < a r g _ l > ... ') ==> (APPLY < f u n k t i o n > ' ( < a r g _ l > . . . < a r g _ n > ) ) ==> < v a l u e >

Wir können daher auch formulieren: eval>

eval>

;; A p p l i k a t i o n e i n e r anonymen F u n k t i o n (APPLY (LAMBDA ( A L T E R . S A L D O ABBUCHÜNGSBETRAG) ( - ALTER_SALDO ABBUCHUNGSBETRAG)) •(110.00 5 0 . 0 0 ) ) ==> 60. ;; A p p l i k a t i o n d e r b e n a n n t e n F u n k t i o n ABBUCHEN (APPLY ABBUCHEN ' ( 1 1 0 . 0 0 5 0 . 0 0 ) ) = = > 6 0 .

Das explizit notierbare Applikationskonstrukt hat folgende Struktur: e v a l > (APPLY

)

==>

Das APPLY-Konstrukt evaluiert seine beiden Argumente, d.h. sowohl den Ausdruck als auch den Ausdruck . Die Evaluierung von muß zu einer Liste führen. Die Elemente dieser Liste sind die Werte an welche die LAMBDA-Variablen von gebunden werden und zwar in der genannten Reihenfolge. eval> eval>

( D E F I N E VORGANG-1 ' ( 1 1 0 . 0 0 (APPLY ABBUCHEN VORGANG-1)

50.00)) ==> ==> 60.

VORGANG-1

/Exkurs: Mehrere Argumente. Bei dem Ausdruck ( ) sei eine Funktion und der Wert von die Liste L. Ist für ein Argument definiert, dann wird auf L angewendet. Ist jedoch für mehrere Argumente definiert und sollten deren Werte durch die Elemente von L dargestellt werden, dann ist stattdessen (APPLY ) zu notieren. Im Fall der Liste ist zu unterscheiden zwischen ( ) für „single-argument functions" und (APPLY ) für „multi-argument functions"./ Da das Binden eines Symbols an eine anonyme Funktion, also die Namensvergabe für eine Funktion, eine häufige Aufgabe ist, gibt es in LISP-Systemen dazu eine syntaktische Vereinfachung. Das explizite Notieren von L A M B D A entfällt bei der Kurzschreibweise. Statt (DEFINE (LAMBDA ( . . . ) . . . ) ) kann verkürzt geschrieben werden

24

I. Konstrukte (Bausteine zum Programmieren)

(DEFI NE ( ... ) ...) Bezogen auf unser Beispiel ABBUCHEN können wir daher alternativ formulieren: eval> (DEFINE ABBUCHEN (LAMBDA (ALTEFLSALDO ABBUCHUNGSBETRAG) (- ALTER.SALDO ABBUCHUNGSBETRAG))) ==> ABBUCHEN eval> (DEFINE (ABBUCHEN ALTER_SALDO ABBUCHUNGSBETRAG) (- ALTER_SALDO ABBUCHUNGSBETRAG)) ==> ABBUCHEN /Hinweis: Syntax DEFINE-Konstrukt. Diese syntaktische Vereinfachung des DEFINE-Konstruktes wird im folgenden nicht genutzt. Die Langform dokumentiert unmißverständlich, daß die anonyme Funktion wie ein sonstiger Wert benannt wird. Sie verdeutlicht, daß im Rahmen dieser Benennung keine Unterscheidung zwischen verschiedenen Typen von symbolischen Ausdrücken gemacht wird. Ein Symbol wird stets mit der Syntax (DEFINE ) gebunden. (Zur Diskussion der Vor- und Nachteile einer Unterscheidung der Bindung eines Funktionswertes von einem sonstigen Wert vgl. z.B. Gabriel/Pitman, 1988 oder Allen, 1987). Zusätzlich besteht die Gefahr, daß eine LlSP-Implementation die syntaktische Vereinfachung nicht in diese Langform transformiert (z.B. Kyoto Common LISP, vgl. Yuasa/Hagiya, 1987, p. 105, oder ältere PC Scheme Versionen, die in ein NAMED-LAMBDA-Konstrukt transformieren).; Wir halten fest: Das LAMBDA-Konstrukt ist in zwei Rollen zu betrachten: 1. Funktionale Abstraktion, d.h. Definition einer Funktion anonyme Funktion: (LAMBDA . . . ) benannte Funktion: (DEFINE (LAMBDA . . . )) 2. Applikation, d.h. Anwendung einer Funktion anonyme Funktion: ((LAMBDA . . . ) . . . ) benannte Funktion: ( . . . ) Im folgenden erweitern wir die Funktion ABBUCHEN um die Fortschreibung des Kontos. Dazu wird ein Beispielkonto MEYER-AG mit dem Anfangswert 1000000.00 initialisiert. eval> (DEFINE MEYER-AG 1000000.00)

MEYER-AG

Wendet man die Funktion ABBUCHEN an, dann ist festzustellen, daß wir für die Abbuchung eine bleibende Zustandsänderung des Kontos benötigen. Die Zustandsänderung ist bisher nicht als Rechenvorschrift in dem ABBUCHENKonstrukt definiert.

1. Einführung: Handhabung von Konstrukten eval>

(ABBUCHEN MEYER-AG 3 0 0 0 0 0 . 0 0 ) ==> 700000. ; e r s t e Abbuchung

eval>

(ABBUCHEN

MEYER-AG 8 0 0 0 0 0 . 0 0 ) zweite Abbuchung - schön aber u n s i n n i g , denn w i r den Wert - 1 0 0 0 0 0 . 0 0 .

==>200000.

25

f ü r d i e MEYER-AG, erwarten

Das SET!-Konstrukt (engl, pronounced: „set-bang") ändert den Wert eines Symbols. eval>

(SET!

)

==>

Wenn ein Symbol (in den erreichbaren Umgebungen) existiert, ersetzt das SET!Konstrukt seinen Wert durch den Wert von . Da der bisherige Wert „zerstört" wird, bezeichnet man SET! als ein destruktives Konstrukt. Destruktive Konstrukte verändern Zustände. Wir sind allgemein nicht an ihrem (Rückgabe-)Wert interessiert, sondern an dem Nebeneffekt, d.h. an der Zustandsänderung. Der Wert eines destruktiven Konstruktes ist daher prinzipiell nicht spezifiziert. Abhängig vom jeweiligen LISP-System wird ein Wert zurückgegeben, um dem READ-EVAL-PRINT-Zyklus zu genügen (vgl. Abschnitt 1.2). Bewirkt ein Konstrukt einen Nebeneffekt, dann fügen wir der Bezeichnung dieses destruktiven Konstruktes ein „ ! " (Ausrufezeichen) hinzu. eval> eval> eval>

( D E F I N E SCHULZE-GMBH - 6 0 0 0 0 . 0 0 ) = = > SCHULZE-GMBH ( S E T ! SCHULZE-GMBH + 1 2 3 4 . 5 6 ) = = > 1 2 3 4 . 5 6 SCHULZE-GMBH ==> 1 2 3 4 . 5 6

Wir können die definierte Funktion ABBUCHEN, wie folgt, benutzen, um den Kontostand bleibend zu verändern: eval> eval> eval> eval> eval>

MEYER-AG ==> 1000000. ¡Anfangswert ( S E T ! MEYER-AG (ABBUCHEN MEYER-AG 3 0 0 0 0 0 . 0 0 ) ) = = > 7 0 0 0 0 0 . MEYER-AG ==> 700000. ¡ K o n t o s t a n d nach 1. A b b u c h u n g ( S E T ! MEYER-AG (ABBUCHEN MEYER-AG 8 0 0 0 0 0 . 0 0 ) ) = = > - 1 0 0 0 0 0 . MEXER-AG ==> - 1 0 0 0 0 0 . ; K o n t o s t a n d nach 2. Abbuchung

Diese Schreibweise ist recht umständlich. Wir ergänzen daher die Funktion zum Abbuchen direkt um die Zustandsänderung des Kontos, d.h. um den Nebeneffekt. Das Konstrukt ABBUCHEN nennen wir deshalb jetzt A B B U C H E N ! (am Ende mit einem Ausrufezeichen versehen). Um eine Funktion A B B U C H E N ! verstehen zu können, erläutern wir vorab einige Aspekte von EVAL und A P P L Y , bezogen auf die jeweilige Umgebung. Im Abschnitt 8 befassen wir uns eingehend mit der Funktion und ihrer Umgebung.

26

I. Konstrukte (Bausteine zum Programmieren)

1.4.2 Umgebung Wenn ein Symbol mit dem DEFINE-Konstrukt kreiert und an einen Wert gebunden wird, dann muß das LISP-System das Symbol und den Wert speichern. Die Assoziation des Symbols zum Wert wird in der Umgebung aufgebaut, die zum Zeitpunkt des Evaluierens des DEFINE-Konstruktes aktuell ist. Eine Umgebung ist konzeptionell als eine Liste vorstellbar, deren Elemente wieder Listen sind. Eine solche Liste ist eine sogenannte Assoziationsliste (vgl. Abschnitt 5.2). ((

)

...

(

))

Befindet man sich auf der Systemebene von PC Scheme, dann ist das Symbol USER-INITIAL-ENVIRONMENT an die aktuelle Umgebung gebunden. Verkürzt formuliert: Die aktuelle Umgebung heißt USER-INITIAL-ENVIRONMENT. Eingebaute Konstrukte, wie z.B. die arithmetischen Funktionen +, - , / und *, sind in PC Scheme in einer eigenen Umgebung, genannt USER-GLOBAL-ENVIRONMENT, gebunden. Mit dem ACCisSS-Konstrukt kann auf den Wert eines Symbols in einer angegebenen Umgebung zugegriffen werden. eval> eval> eval> eval> eval>

(DEFINE (ACCESS (ACCESS (ACCESS (ACCESS

MEYER-AG 1 0 0 0 0 0 0 . 0 0 ) ==> MEYER-AG MEYER-AG U S E R - I N I T I A L - E N V I R 0 N M E N T ) = = > 1 0 0 0 0 0 0 . 0TT0-AG USER-INITIAL-ENVIRONMENT) ==> #!UNASSIGNED MEYER-AG USER-GL0BAL-ENVIR0NMENT) ==> #!UNASSIGNED + USER-GLOBAL-ENVIRONMENT) ==> #

Die Beispiele MEYER-AG und OTTO-AG zeigen, daß ein Symbol als #!UNASSIGNED bezeichnet wird, wenn es in der Umgebung nicht vorkommt. Dabei kann es durchaus in einer anderen Umgebung existieren. Beim Evaluieren des DEFINE-Konstruktes auf Systemebene („top level") hat die Umgebung den Namen USER-INITIAL-ENVIRONMENT. Das EVALKonstrukt ermöglicht die explizite Angabe der gewünschten Umgebung. Wir können daher hier als gleichwertige Ausdrücke formulieren: eval>

(DEFINE

MEYER-AG

1000000.00)

==>

MEYER-AG

oder eval>

(EVAL ==>

'(DEFINE MEYER-AG

MEYER-AG 1 0 0 0 0 0 0 . 0 0 ) USER-INITIAL-ENVIR0NMENT) ;Zu b e a c h t e n i s t das Q u o t i e r e n des D E F I N E K o n s t r u k t e s im E V A L - K o n s t r u k t . Es i s t e r f o r d e r l i c h , weil das E V A L - K o n s t r u k t auch s e i n e r s t e s Argument e v a l u i e r t .

Das Evaluieren eines LAMBDA-Konstruktes führt zum Aufbau einer neuen Um-

1. Einführung: Handhabung von Konstrukten

27

gebung. Um diesen Vorgang zu verdeutlichen, definieren wir eine Funktion, deren Name keine Rolle spielt: Wir nennen sie FOO, so gut wie SINNLOS. /Hinweis: Bedeutungsloser Name. Das Symbol FOO ist eine Silbe ohne Bedeutung, allerdings mit einer langen LISP-Historie. FOO wird allgemein verwendet, wenn der Name des Konstruktes unerheblich ist. Reicht ein Symbol nicht aus, dann verwendet man häufig als weitere bedeutungslose Namen B A R und B A Z J eval>

eval> eval> eval>

( D E F I N E FOO (LAMBDA ( X ) ( D E F I N E MEIN-SYMBOL 0) ( S E T ! M E I N - S Y M B O L 1 0 ) ) ) = = > FOO FOO = = > # < P R O C E D U R E F 0 0 > (FOO 5 ) = = > 10 ; Rückgabewert des S E T ! - K o n s t r u k t e s MEIN-SYMBOL = = > ERROR Symbol i s t n i c h t d e f i n i e r t i n d e r a k t u e l l e n Umgebung USER-INITIAL-ENVIRONMENT

eval>

(ACCESS ==>

MEIN-SYMBOL

USER-INITIAL-ENVIRONMENT) Soll

#!UNASSIGNED

die

Fehler-Situation

mieden werden, nachgeschaut in

der

kann

werden,

Umgebung

mit

verACCESS

ob d a s

gebunden

Symbol

ist.

Weil ein LAMBDA-Konstrukt eine neue Umgebung auftaut, führt die folgende spontane Formulierung nicht zur gewünschten Zustandsänderung unseres Kontos. eval>

( D E F I N E ABBUCHEN! (LAMBDA (K0NT0_NAME ABBUCHUNGSBETRAG) ( S E T ! K0NT0_NAME ; h i e r w i r d d a s Symbol ;: EVAL, w e i l j e t z t der Wert von ; ; b e n ö t i g t wi r d . (-

(EVAL

K0NT0_NAME)

benötigt K0NT0_NAME

ABBUCHUNGSBETRAG)))) ==>

eval>

MEYER-AG ==>

eval>

(ABBUCHEN!

eval>

MEYER-AG = = >

ABBUCHEN!

1000000.

'MEYER-AG 1000000.

300000) ;Nicht

==>

700000.

verändert!

Die destruktive Veränderung des SET!-Konstruktes betrifft die vom L A M B DA-Konstrukt erzeugte Umgebung und nicht die USER-INITIAL-ENVIRONMENT, in der das Symbol M E Y E R - A G den assoziierten Wert hat, der zu verändern ist. Für die gewünschte Funktion A B B U C H E N ! benötigen wir ein Konstrukt zum

28

I. Konstrukte (Bausteine zum Programmieren)

Erzeugen einer Liste. Bisher haben wir Listen direkt notiert und nicht mit einem Konstrukt erzeugt. Jetzt nutzen wir den eingebauten Konstruktor LIST. LIST-Konstrukt:

Es hat als Wert eine Liste, gebildet aus den Werten seiner Argumente. eval>

(LIST

...

)

eval> eval> eval> eval> eval>

(LIST (LIST) (LIST (LIST (LIST

'A 'B ' C ) ==> (A B C) ==> ( ) ( ) ) ==> (()) 'SET! ' M E Y E R - A G 1 2 . 3 4 ) ==> ( S E T ! M E Y E R - A G 1 2 . 3 4 ) 'SET! ' M E Y E R - A G ( - 50 3 9 ) ) = = > ( S E T ! M E Y E R - A G 1 1 )

==>

(

...

)

Die Funktion ABBUCHEN! läßt sich mit dem LIST-Konstrukt und dem EVALKonstrukt bei explizit angegebener Umgebung, wie folgt, notieren: eval>

eval> eval> eval>

( D E F I N E ABBUCHEN! (LAMBDA (KONTCLNAME ABBUCHUNGS_BETRAG) (EVAL (LIST 'SET! KONTCLNAME (- ( E V A L K0NT0_NAME) ¡ W e r t von K0NT0_NAME ABBUCHUNGSBETRAG)) U S E R - I N I T I A L - E N V I R O N M E N T ) ) ) ==> ABBUCHEN! M E Y E R - A G ==> 1 0 0 0 0 0 0 . (ABBUCHEN! ' M E Y E R - A G 3 0 0 0 0 0 . 0 0 ) ==> 700000. (ABBUCHEN! ' M E Y E R - A G 8 0 0 0 0 0 . 0 0 ) ==> - 1 0 0 0 0 0 .

Das ABBUCHENI-Konstrukt, definiert auf der Basis des LAMBDA-Konstruktes, gibt nicht nur einen Wert zurück, sondern verändert auch den Wert seines ersten Arguments. Es entspricht dem Bild 1.4-1. Die Schnittstelle wird durch die beiden LAMBDA-Variablen KONTO. NAME und ABBUCHUNGS_ BETRAG dargestellt. Den Nebeneffekt ruft das enthaltene SET!-Konstrukt hervor. Die explizite Angabe der Umgebung beim EVAL-Konstrukt sorgt dafür, daß der Wert in der richtigen Umgebung verändert wird. Wir betrachten im folgenden das Bild 1.4.2-1, um die Symbol-Wert-Assoziation und ihre Implementation zu erläutern. Faßt man eine Symbol-Wert-Assoziation als die Benennung eines Wertes auf, dann hat das Symbol die Rolle einer Variablen. Wir bezeichnen ein Symbol als Variable, wenn wir seine Wert-Assoziation betonen wollen. In Programmiersprachen benennen Variable häufig Werte („Objekte") in zwei Schritten (vgl. z.B. Clinger, 1988, p. 224). Eine Variable verweist auf einen Speicherplatz (hier in LOCATIONS). Dieser Speicherplatz enthält umgangssprachlich den Wert; präzise formuliert: Den Zeiger, der auf den Wert zeigt. Gewöhnlich sprechen wir verkürzt von dem Wert der Variablen. Wesentlich ist, daß es aufgrund dieses zweistufigen Benennungsverfahrens zwei Wege gibt, um das zu ändern, was eine Variable benennt:

1. Einführung: Handhabung von Konstrukten

29

Legende: 9999 #!UNASSIGNED

::= Bezeichnet den Platz, der "ungebunden" entspri cht. ::= Bezeichnet den Wert ("Objekt"), der "nicht initialisiert" entspricht.

Bild 1.4.2-1. Zweistufiges

Verfahren

zur

Benennung

von

Merten

o Durch Bindung (engl.: binding) kann die Variable zu einem anderen Speicherplatz (hier: LOCATIONS) zeigen. o Durch Zuweisung (engl.: assignment) kann ein anderer Wert an dem Platz gespeichert werden, an den die Variable gebunden ist. Den Speicher (hier: STORE) kann man sich als ein Lexikon mit einem Schlagwort für jeden Platz (in LOCATIONS) vorstellen. Das Lexikon dokumentiert, welcher Wert an diesem Platz gespeichert ist. Viele Eintragungen weisen aus, daß kein Wert an ihrem Platz gespeichert ist, d.h. der Platz ist nicht initialisiert, weil er (noch) nicht benutzt wird. Eine Umgebung ist ebenfalls ein Lexikon. Es enthält Schlagwörter für jede ihrer Variablen, die ausweisen, an welchen Platz die Variable gebunden ist. Manche Eintragungen dokumentieren, daß die Variable ungebunden ist, d.h. die Variable ist an keinen eigenen Platz gebunden, sondern an den Platz, der „ungebunden" entspricht. Aus der zeitlichen Perspektive sind daher zwei Aspekte zu betrachten:

30

I. Konstrukte (Bausteine zum Programmieren)

o Namen, die ihre Werte („Quantitäten") ändern und o Werte, die ihre Namen ändern. In der klassischen Programmierung, z.B. in der COBOL-Welt, konzentriert man sich auf die Namen und verfolgt schrittweise ihre Werteänderung. Im Kontext der LAMBDA-Bindung ist die zweite Sicht zweckmäßig. Es geht um Werte, die neu benannt werden. Die LAMBDA-Variable ist ein neuer Name für den Wert eines Arguments. So gesehen ist das LAMBDA-Konstrukt ein UmbenennungsKonstrukt (vgl. Steele, 1976). /Exkurs: Aliasname. Die Möglichkeit einem existierenden Objekt mehrere Namen geben zu können, verursacht Transparenzprobleme. Ist das Objekt über jeden Namen modifizierbar, dann müssen wir stets alle Namen verfolgen, um eine Aussage über den Objektzustand machen zu können (vgl. z.B. Abschnitt 5.1). eval> eval> eval> eval>

(DEFINE F00 "Otto") ==> F00 (ALIAS BAR F00) ==> BAR (SET! BAR "Emma") ==> "Emma" F00 ==> "Emma" ¡ m o d i f i z i e r t mit BAR-Änderung

]

Wird in Scheme ein LAMBDA-Konstrukt evaluiert, dann kennt die entstandene Funktion in welcher Umgebung sie evaluiert wurde. Das durch # repräsentierte (Funktions-)Objekt ist verknüpft mit seiner Definitions-Umgebung. Die Umgebung und die Funktion bilden eine Einheit. Bildlich gesehen umhüllt die Umgebung die Funktion. Für die Verknüpfung von Umgebung und Funktion hat sich daher der englische Begriff „closure" (deutsch: Hülle oder auch Abschließung) durchgesetzt. Die Umgebung ist „geschlossen" im Hinblick auf die Variablen (engl.: closed over the variables), weil diese nicht außerhalb bzw. ohne diese Umgebung zugreifbar sind. In Scheme hat das THE-ENVIRONMENT-Konstrukt die aktuelle Umgebung als Wert. Hier ein kurzes Beispiel (Näheres vgl. Abschnitt 8). eval> (DEFINE F00 (LAMBDA () (DEFINE BAZ (LAMBDA (X Y) (+ X Y))) (THE-ENVIRONMENT))) ==> F00 eval> (EVAL '(BAZ 2 4) (F00)) ==> 6 Das CLOSURE-Konzept wurde 1964 von P. Landin im Zusammenhang mit seinem Vorschlag für die Auswertung von Lambda-Ausdrücken angegeben (vgl. Landin, 1964). Es ist die Lösung für Probleme beim Umgang mit Funktionen als Argumente und als Rückgabewerte von Funktionen. Diese sogenannten FUNARG-Probleme treten auf, wenn die Funktion beim Aufruf nicht mehr über ihre Definitionsumgebung verfügt (vgl. z.B. Moses, 1970).

1. Einführung: Handhabung von Konstrukten

31

/Hinweis: FUNARG-Probleme. Man spricht vom „downward funarg"-Problem, wenn eine LAMBDA-Variable an eine Funktion gebunden wird; d.h. eine Funktion ist Wert eines Argumentes. Das „upward funarg"-Problem entsteht, wenn der Wert einer Funktion eine Funktion ist, d.h. eine Funktion gibt eine anschließend anzuwendende Funktion zurück.7 Klassische LISP-Systeme können die Funktion nur mit der Umgebung abarbeiten, die bei ihrem Aufruf besteht. Die Definitions-Umgebung ist nicht mit der Funktion verknüpft. Da die Umgebung beim Aufruf von der Situation zum jeweiligen Aufrufungszeitpunkt abhängt, ist diese stets eine andere. Es besteht eine dynamische Situation; man spricht daher von einer „dynamischen Bindung". Das CLOSURE-Konzept ist demgegenüber eine „statische Bindung", da sich die Definitionsumgebung für die Funktion nicht ändert. Im Scheme-Kontext bezeichnet man eine „statische Bindung" als „lexikalische Bindung" und die „dynamische Bindung" als „fluid binding". Wenn eine Funktion angewendet wird, dann sind die Werte der Argumente in den Funktionskörper zu „übernehmen". Die folgenden drei Schritte stellen ein Erklärungsmodell für diese Übernahme dar (vgl. Bild 1.4.2-1): 1. Schritt: Binden der LAMBDA-Variablen o Es werden neue Plätze (in LOCATIONS) für jede LAMBDA-Variable der Funktion belegt. o Die Werte der Argumente des Funktionsaufrufes werden in den korrespondierenden neuen Plätzen gespeichert. Das führt zu einem neuen STORE. o Die LAMBDA-Variablen werden dann an die neuen Plätze (in LOCATIONS) gebunden. Dies entspricht einer Neubenennung von Werten. o Diese Bindung bewirkt eine neue Umgebung (ENVIRONMENT). In der neuen Umgebung zeigen die LAMBDA-Variablen auf die neuen Plätze (in LOCATIONS). 2. Schritt: Evaluieren in neuer Umgebung Die Rechenvorschrift der Funktion wird in der neuen Umgebung in Verbindung mit dem neuen STORE evaluiert. 3. Schritt: Aktualisieren der alten Umgebung Nach vollzogener Auswertung werden die geschaffenen Bindungen der LAMBDA-Variablen wieder aufgelöst. Die alte Umgebung wird wieder zur aktuellen Umgebung. Bildlich formuliert, entspringt die „lexikalische Bindung" folgender Überlegung: Wenn jemand einen Satz (Funktion) formuliert, dann unterstellt er seinen

32

I. Konstrukte (Bausteine zum Programmieren)

Worten (Symbolen) eine bestimmte Bedeutung. Er unterstellt z.B. die Erläuterungen im Sinne des Lexikons „Duden". Sein Satz wird möglicherweise falsch interpretiert, wenn der Leser ein anderes Lexikon annimmt. Die Verknüpfung der Funktion mit dem Definitionslexikon soll die korrekte Interpretation sichern.

1.5 Zusammenfassung: EVAL, APPLY und LAMBDA LISP (LISt Processing) ist eine formale Sprache, eine dialogorientierte Software-Entwicklungsumgebung, eine Menge vordefinierter Konstrukte und ein Formalismus zur Spezifikation. LISP-Konstrukte haben eine einfache Syntax (Grammatik) und (als Dialekt Scheme) eine einfache Semantik (Bedeutung). Symbole, Zahlen, Zeichen, Zeichenketten und Listen sind symbolische Ausdrücke. Jeder symbolische Ausdruck ist ein syntaktisch korrekt konstruiertes LISP-„Programm". Die Regeln zur Auswertung symbolischer Ausdrücke (EVAL-Regeln) definieren die Semantik. Sie bilden das EVAL-Konstrukt Den READ-EVAL-PRINT-Zyklus notieren wir wie folgt: eval> = >

Ist eine Liste zu evaluieren, dann bestimmt das erste Element, wie die restlichen Listenelemente behandelt werden. Benennt z.B. das erste Element eine Funktion, dann sind die restlichen Elemente Argumente, die vor der Übernahme in den Funktionskörper evaluiert werden. Abweichend von der üblichen Notation f(x,y) verschiebt LISP die Funktion f in die Klammer und verwendet als Trennzeichen das Leerzeichen statt dem Komma. Die Funktionsapplikation kann auch durch das APPLY-Konstrukt explizit angegeben werden. Ist das erste Element ein spezielles Symbol, z.B. DEFINE oder IF, dann hängt es vom jeweiligen Symbol ab, ob Argumente evaluiert werden oder nicht. Das spezielle Symbol QUOTE blockiert die Auswertung. Das Symbol EVAL führt zur Anwendung der EVAL-Regeln, wobei eine Umgebung explizit angebbar ist. Das EVAL-Konstrukt dient als Gegenstück zum QUOTE-Konstrukt. NIL repräsentiert die leere Liste und den Wahrheitswert „nicht wahr" (#F; engl.: false). Alle Werte ungleich NIL werden als Wahrheitswert „wahr" (#T; engl.: true) aufgefaßt. Ein Konstrukt ist ein symbolischer Ausdruck, gekennzeichnet durch Schnittstelle, (Rückgabe-) Wert(e) und gegebenenfalls durch Nebeneffekt(e). Das LAMBDA-Konstrukt dient zur Definition von eigenen Konstrukten. Die LAMBDA-Variablen bilden die Schnittstelle; die Rechenvorschrift setzt sich aus eigenen und/oder eingebauten Konstrukten zusammen. Der Wert eines Symbols ist von der Umgebung abhängig, in der das Symbol evaluiert wird. In Scheme hat die Ausgangsumgebung den Namen USER-INITIAL-ENVIRONMENT. Jedes LAMBDA-Konstrukt baut eine eigene Umgebung auf. Es übernimmt damit die Aufgabe der Neubenennung von Werten.

2. Kombinieren von Konstrukten Charakteristische

33

Beispiele fiir Abschnitt 1:

eval > eval> eval> eval> eval>

( D E F I N E MÜLLER-OHG 'KUNDE). = = > MÜLLER-OHG ( D E F I N E MEYER-AG (QUOTE MÜLLER-OHG)) = = > MEYER-AG (EVAL MEYER-AG) = = > KUNDE MEYER-AG = = > MÜLLER-OHG MÜLLER-OHG = = > KUNDE

eval> eval>

(EVAL ' ( E V A L ' ( E V A L ' ( E V A L ' ( + 1 2 ( + 1 ( + 2 ( + 3 ( + 4 ) ) ) ) = = > 10

eval> eval>

( D E F I N E ZUSTIMMUNG? " n i e und n i m m e r " ) = = > ZUSTIMMUNG? ( I F ZUSTIMMUNG? " W ä h l e n ! " " N i c h t w ä h l e n ! " ) Der Wert von " n i e und nimmer" i s t => " W ä h l e n ! " u n g l e i c h NIL. Die Bedingung g i l t a l s e r f ü l l t , daher w i r d der "True - F a l l " evalui e r t .

eval> eval>

( D E F I N E ZUSTIMMUNG? ( + 2 3 ) ) = = > ZUSTIMMUNG? ( I F ZUSTIMMUNG? "Wä l e n ! " " N i c h t w ä h l e n ! " ) ==> "Wählen!" ;Der Wert 5 i s t u n g l e i c h N I L . ; E v a l u i e r t w i r d daher der ; "True-Fall".

eval>

(DEFINE

3

4)))))

=> 10

EINZAHLEN!

(LAMBDA

(K0NT0_NAME

(EVAL

(LIST

EINZAHLUNGSBETRAG)

'SET!

K0NT0_NAME

( + (EVAL KONTO.NAME)

EINZAHLUNGSBETRAG))

USER-INITIAL-ENVIRONMENT))) e v a l > MEYER-AG = = >

==>

EINZAHLEN!

1000000.

eval>

(EINZAHLEN!

'MEYER-AG 3 0 0 0 0 0 . 0 0 )

==>

1300000.

eval>

(EINZAHLEN!

'MEYER-AG 8 0 0 0 0 0 . 0 0 )

==>

2100000.

eval>

(DEFINE + - ) ==> +

eval>

(+ 3 4) ==>

¡ A c h t u n g , es w i r d e i n e i n g e b a u t e s ; Symbol m o d i f i z i e r t !

-1

2. Kombinieren von Konstrukten Eine spezifizierte Aufgabe zu programmieren bedeutet, passende Konstrukte selbst zu definieren und diese mit fremden Konstrukten zu kombinieren. Solches „Handhaben" von Konstrukten im Sinne eines Problemlösungsvorganges ist nicht isoliert betrachtbar und bewertbar. Ob eine Lösung („Konstruktion") zweckmäßig ist oder nicht, zeigt sich nicht nur in Bezug zur spezifizierten Aufgabe, die es gilt (möglichst!) korrekt abzubilden. Zusätzlich soll die Konstruktion

34

I. Konstrukte (Bausteine zum Programmieren)

leicht an eine geänderte Situation anpaßbar sein. Die zu erreichende SoftwareQualität bezieht sich auf die Gesamtheit von Eigenschaften und Merkmalen; auf die Gebrauchstauglichkeit (funktionale Qualität), die Entwicklungsfähigkeit und die Übertragbarkeit (realisierungstechnische Qualität). Das Einbeziehen der Anforderungen des gesamten Software-Lebenszyklusses ist zwingend erforderlich (Näheres vgl. Abschnitt 12). Die Bewertung einer Konstruktion umfaßt alle Phasen, z.B.: Problemanalyse, Anforderungsdefinition, Konzeptionierung, logischer Entwurf, Detailentwurf, Programmierung, Testen, Implementation, Betrieb und Wartung/Pflege/ Fortentwicklung (vgl. Bild 2-1). Sie wirft unterschiedlichste Fragen auf: ökonomische, gesellschaftliche, soziale, organisatorische, juristische und viele mehr. Unsere Thematik „Konstruktion" zielt auf die software-technischen Fragen. W i r konzentrieren uns auf die Probleme, die man üblicherweise Software-Ingenieuren zur Lösung überträgt. Viele relevante Konstruktionsaspekte wie z.B. die Sozialverträglichkeit werden nicht diskutiert. Zieht man einen Vergleich zum Bau eines Fahrgastschiffes, dann werden Aspekte der Seetüchtigkeit und Sicherheit anhand der Dicke der Stahlwände geklärt, während die Frage, ob es überhaupt genügend Fahrgäste gibt, dabei nicht berücksichtigt wird. Schon diese eingegrenzte Betrachtung des klassischen Lebenszyklusses (vgl. z.B. Boehm, 1981) zwingt uns permanent zur Entscheidung: Ist diese Konstruktion oder eine ihrer möglichen Alternativen zu wählen? Beispiel:

Entscheidung für eine Lösung

In einem Programm zur Verwaltung von Kunden sei zu überprüfen, ob vorab die Frage nach dem Namen und dem Alter des Kunden beantwortet wurde. Welches der beiden Programmfragmente ist zu bevorzugen und warum? Lösung eval> eval> eval>

1: (DEFINE (DEFINE (DEFINE

eval>

(FOÜ'A

Lösung 2: eval> (DEFINE eval> (DEFINE

A T ) ==> A ; A n w o r t des Namens B ( ) ) ==> B ¡ A n t w o r t des A l t e r s F00 ( L A M B D A (X Y ) ( I F X Y ( ) ) ) ) ==>

B) ==>

F00

()

ANTWORT-NAME T R U E ) ==> A N T W O R T - N A M E A N T W O R T - A L T E R F A L S E ) ==> A N T W O R T - A L T E R

eval > (AND'ANTWORT-NAME

ANTWORT-ALTER)

==>

()

Offensichtlich ist Lösung 2 mit dem AND-Konstrukt leichter verstehbar als L ö sung 1, obwohl beide Lösungen ähnlich aufgebaut sind. Die Lösung 2 weist

2. Kombinieren von Konstrukten

35

einprägsame (mnemotechnisch besser gewählte) Symbole auf und greift auf das AND-Konstrukt der Booleschen Algebra zurück, das als häufig verwendetes Konstrukt schneller durchschaut wird als das hier selbstdefinierte Äquivalent, das als FOO-Konstrukt formuliert ist. Die Auswahlentscheidung zwischen Lösungsalternativen ist allgemein nicht trivial. Es ist schwierig festzulegen, welche Aufgabenteile (Leistungen) in einem Konstrukt zusammenzufassen sind, und wie das Konstrukt im Detail zu formulieren ist. Für das Problem, eine komplexe Aufgabe zweckmäßig in kleinere Einheiten (Konstrukte) zu modularisieren (gliedern), gibt es selten eine Lösung, die unstrittig gegenüber ihren möglichen Alternativen nur Vorteile bietet. Die Menge der konkurrierenden und zum Teil sogar sich widersprechenden Forderungen verhindert, daß es den eindeutigen „Favoriten" gibt. Die Entscheidungen zur Bildung eines Konstruktes sind daher Kompromißentscheidungen. Eine „tragfähige" Kompromißlösung ist einerseits von den allgemein bewährten und anerkannten Konstruktionsregeln und andererseits von individuellen Bevorzugungen und Erfahrungen geprägt. Der folgende Abschnitt stellt anhand des Beispiels einer Kontenverwaltung die Bildung von Konstrukten dar. Im Kapitel II wird mit diesem Beispiel die

36

I. Konstrukte (Bausteine zum Programmieren)

Modularisierung im Zusammenhang mit verschiedenen Abbildungsoptionen (Liste, Vektor, Zeichenkette etc.) weiter vertieft.

2.1 Interaktion: Operand - Operation Bei der Bildung eines Konstruktes orientiert man sich intuitiv an Fachbegriffen des jeweiligen Aufgabengebietes. Sie bezeichnen z.B. reale Objekte (Gegenstände) oder konzeptionelle Einheiten. In unserem Beispiel Kontenverwaltung könnten daher erste Orientierungspunkte sein: Ein Konto, eine Buchung oder ein realer Gegenstand wie der Aktenschrank im Büro des Buchhalters. Ein Konstrukt bildet dann Eigenschaften und ihre Veränderungen einer solchen „realen" Einheit in Wechselwirkung mit anderen „realen" Einheiten ab. Es modelliert die Eigenschaften und Aktionen. Die gedankliche Verknüpfung zwischen „realen" Einheiten und den Sprachkonstrukten ist die Basis für das Formulieren und Verstehen von Programmen. Ein direkter Bezug zwischen „realer" Einheit und Konstrukt, z.B. hergestellt durch eine Namensgleichheit, erleichtert daher das Verstehen (Näheres vgl. Abschnitt 11.1). Die Matrix (Bild 2.1-1) verdeutlicht Alternativen zur Bildung von Konstrukten. Sie skizziert in der Realität vorgefundene Arbeiten/Aktivitäten als Operatoren, bezogen auf Operanden, deren Zustand manipuliert wird. Entsprechend dieser Matrix kann man ein Konstrukt bilden, das ausgehend von einer bestimmten Operation alle möglichen Operanden zusammenfaßt. In diesem Fall ist die Matrixspalte die Klammer für die Zusammenfassung zu einem Konstrukt. Zu definieren sind dann die Konstrukte: NEUANLEGEN, LÖSCHEN, ANMAHNEN etc. .

Operanden KUNDE LIEFERANT KASSENKONTO

Bild 2.1-1. Matrix:

Operati onen NEUANLEGEN LOSCHEN xl x2 x3

Operanden

ANMAHNEN

yi y2 y3

-

Operationen

...

zl z2 Fehl er

- zeilen- oder s p a l t e n o r i e n t i e r t e Konstrukten -

Bildung

von

37

2. Kombinieren von Konstrukten

Das Konstrukt NEUANLEGEN ist auf KUNDE, LIEFERANT, KASSENKONTO etc. anzuwenden. Ist der Operand ein Kunde, dann ist die Operation xl auszuführen. Beim Operand vom Typ Lieferant ist es die Operation x2. Es ist daher zwischen den verschiedenen Typen von Operanden zu unterscheiden. Für diese Unterscheidung gibt es in LISP das COM)-Konstrukt (conrfitional expression). Diese Fallunterscheidung ersetzt eine tiefe Schachtelung von IF-Konstrukten. Bevor wir die Struktur von NEUANLEGEN definieren, wird vorab das COND-Konstrukt erläutert. Konditional-Konstrukt COND: Das COND-Konstrukt wählt die zutreffende Bedingung aus einer Menge beliebig vieler Bedingungen aus. Es entspricht einer Eintreffer-Entscheidungstabelle (vgl. Abschnitt 2.2.2) und hat folgende Struktur: eval > (COND ( < s e x p r n > ... ) ( ...

Eine Liste (

...), genannt Regel oder Klausel (engl.: clause), bildet einen Fall ab. Dabei ist

die Bedingung (das Prädikat) für den einzelnen Fall und die optionalen bis sind die symbolischen Ausdrücke, die der Reihe nach ausgewertet werden, wenn die Bedingung

erfüllt ist.

ist erfüllt, wenn der Wert von

ungleich NIL ist. Der Wert des COND-Konstruktes, also , wird dann nach Evaluierung von bis durch den zuletzt ermittelten Wert bestimmt. Falls j>0, also ein evaluiert wurde, ist der Wert von ; ist j=0, dann ist gleich dem Wert von

. Die Bedingungen werden der Reihe nach von beginnend geprüft, bis erstmals der Wert von

ungleich NIL ist, d.h. als wahr interpretiert wird. Die restlichen Bedingungen werden nicht ausgewertet. Ist keine Bedingung ungleich NIL, dann ist das CONDKonstrukt Undefiniert. Sein Wert wird dann durch NIL repräsentiert. Beispiele zum COND-Konstrukt: eval> (DEFINE ABSOLUTWERT (LAMBDA (X) ( C O N D ( ( < X 0 ) (* -1 X ) ) ("SONST" X)))) = = > ABSOLUTWERT eval> (ABSOLUTWERT -5) ==> 5 eval> (ABSOLUTWERT 5) = = > 5

38

I. Konstrukte (Bausteine zum Programmieren)

eval>

(DEFINE

eval>

;; Anonyme F u n k t i o n m i t N e b e n e f f e k t ( ( L A M B D A (X V ) ¡Anwendung d e r anonymen F u n k t i o n (COND ( ( = X Y ) ( S E T ! * W E G * " K l a u s e l = " ) (* X Y)) ( ( < X Y) ( S E T ! *WEG* " K l a u s e l x < y " ) ( + X Y ) ) ( ( < Y X) ( S E T ! *WEG* " K l a u s e l x > y " ) ( - X Y ) ) (T ( S E T ! *WEG* " K l a u s e l sonst") "Unbekannte Relation!"))) 12 2 3 ) ¡Argumente = = > 35 ¡ R ü c k g a b e w e r t *WEG* ==> " K l a u s e l x < y " ¡Bewirkter Nebeneffekt

eval> eval> eval>

*WEG*

'UNBENUTZT)

==>

*WEG*

( D E F I N E OTTO ( ) ) = = > OTTO ;; Keine K l a u s e l t r i f f t zu! (COND ( ' ( ) "Konstant Nichts") ( ( E V A L ( ) ) "Wert von N i c h t s (OTTO ( ) ) ) = = > ( )

ist

Nichts")

¡1. ¡2. ¡3.

Klausel Klausel Klausel

Beim letzten Beispiel ist nicht sofort erkennbar, ob der Wert des COND-Konstruktes NIL für das Zutreffen der 3. Klausel oder für das Nichtzutreffen aller drei Klauseln steht, d.h. den Undefinierten Fall von COND repräsentiert. Um dieses „Durchlaufen" zu vermeiden, ist es zweckmäßig, am Schluß eines COND-Konstruktes eine True-Klausel zu formulieren. Diese wird entsprechend dem historischen LISP durch das Symbol T abgebildet, wobei an das Symbol T ein Wert ungleich NIL gebunden ist. /Hinweis: T-Klausel. Jeder symbolische Ausdruck, dessen Wert ungleich NIL ist, kann als Prädikat verwendet werden, um eine Klausel zu definieren, die auf jeden Fall zutrifft, also die Aufgabe einer Sonst-Regel (otherwise case) übernimmt. Traditionell verwenden man das Symbol T, obwohl in Scheme der Wahrheitswert ,true' die Standardrepräsentation #T hat./ Für die Unterscheidung z.B. zwischen einem Kunden und einem Lieferanten entsprechend Bild 2.1-1, benötigen wir passende Prädikate, damit das CONDKonstrukt die Auswahl der jeweiligen Operationen übernehmen kann. Für die Typerkennung unterstellen wir hier, daß die Daten eines Kunden in Form einer Liste abgebildet sind, deren erstes Element das Symbol KUNDE ist. Für einen Lieferanten, ein Kassenkonto etc. gibt es entsprechende Listen. (Optionen für eine geeignete Abbildung vgl. Abschnitte 5 bis 10). Vorab definieren wir mit Programmfragment 2.1-1 zwei Kunden, einen Lieferanten und ein Kassenkonto: eval>

(DEFINE

MEYER-AG

'(KUNDE

eval>

(DEFINE

MÜLLER-OHG

eval>

(DEFINE

SCHULZE-GMBH

"Daten

'(KUNDE

zur

"Daten

'(LIEFERANT

Meyer

zur

AG"))

==> MEYER-AG OHG")) = = > MÜLLER-OHG zur SCHULZE-GMBH")) = = > SCHULZE-GMBH

Müller

"Daten

2. Kombinieren von Konstrukten eval>

(DEFINE

39

VERWAHRUNG-1 ' ( K A S S E N K O N T O " D a t e n zum V e r w a h r k o n t o - 1 " ) )

Programmfragment

2.1-1.

Beispiele Kassenkonto

==>

VERWAHRUNG-1

für Kunde, Lieferant gemäß Bild 2.1-1.

und

Um in diesem Beispiel das Symbol MEYER-AG als Kunde zu erkennen, benötigen wir einen Selektor für das erste Element einer Liste und ein Konstrukt, das auf Gleichheit testet. Im Zusammenhang mit dem benötigten Selektor erläutern wir zusätzlich den korrespondierenden Konstruktor. Selektoren CAR und CDR: Das klassische „Pure LISP" basiert auf den beiden Selektoren CAR (historisch bedingte Abkürzung für Contents of Address part of Register; phonetisch [ka:]) und CDR (Contents of Decrement part of Register; phonetisch [kAdd:]). Sie ermöglichen es, die Teile einer Liste zu selektieren. Dabei hat das CAR-Konstrukt das erste Element der Liste, d.h. den sogenannten Kopf, und das CDR-Konstrukt die Rest/wie als Wert. Diese CAR-CDR-Notation bezieht sich auf die klassische Repräsentation von Listen, d.h. auf Adressen im Rechner (vgl. Abschnitt 5). Sie sollte jedoch nicht den Blick dafür verstellen, daß Listen abstrakte Formalobjekte sind, deren Implementation zunächst untergeordnete Bedeutung hat. Plakativ formuliert: Bei der Konstruktion beschäftigen wir uns mit abstrakten Formalobjekten und nicht mit bekannten Adressen! eval> eval> eval> eval> eval> eval>

(CAR M E Y E R - A G ) = = > KUNDE (CAR (CDR M E Y E R - A G ) ) = = > " D a t e n z u r (CAR S C H U L Z E - G M B H ) = > LIEFERANT (CAR (CDR S C H U L Z E - G M B H ) ) = = > " D a t e n (CAR VERWAHRUNG-1) = = > KASSENKONTO (CAR (CDR V E R W A H R U N G - 1 ) ) = = > " D a t e n

Programmfragment

Meyer

AG"

zur

Schulze

GMBH"

zum

Verwahrkonto-1"

2 . 1 - 2 . S e l e k t i o n des Operanden-Typs und der zugehörenden Daten (von Programmfragment2.1 -1)

Beispiele zum CAR- und CDR-Konstrukt: eval> eval> eval> eval>

(CDR (CAR (CAR (CAR

'BREMEN) = = > ERROR . . . ¡ k e i n e L i s t e - QUOTE ! ! ! "BREMEN") = = > ERROR . . . ¡keine Liste - S t r i n g !!! (CDR ' ( E I N S ZWEI D R E I V I E R ) ) ) = = > ZWEI (CDR (CDR (CDR ' ( E I N S ZWEI D R E I V I E R ) ) ) ) ) = = > V I E R

Zur Reduzierung des Schreibaufwandes einer Kette geschachtelter Selektoren ermöglichen LISP-Systeme eine verkürzte Schreibweise in der Form C.. .R, z.B. CADR oder CDDDR. Üblicherweise können CAxR oder CDxR formuliert, wobei x eine Folge von bis zu drei Buchstaben A bzw. D sein kann. Zusätzlich

40

I. Konstrukte (Bausteine zum Programmieren)

existiert ein Selektor, der auf eine angegebene Elementeposition zugreift (vgl. LIST-REF-Konstrukt in Abschnitt 3.3). eval> (CADR '(EINS ZWEI DREI VIER)) ==> ZWEI eval> (CAAR '((EINS) ZWEI))) ==> EINS eval> (CDDDDDAAR ' ( 1 2 3 4 5 6 7 8 9 ) ) ==> ERROR . . . ¡CDDDDDAAR i s t nicht d e f i n i e r t ; und wäre auch unzweckmäßig Werden die Selektoren CAR und CDR auf die leere Liste angewendet, dann ist ihr Rückgabewert nicht definiert. Ihr Wert ist Undefiniert, so wie es der Wert bei der Division einer Zahl durch 0 ist. Abhängig von der jeweiligen LISP-Implementation wird jedoch NIL oder eine Fehlermeldung oder ein sonstiges Zeichen (z.B. ,,-L") zurückgegeben. In PC Scheme haben die Selektoren dann den Wert NIL. eval> eval> eval> eval> eval> eval >

(CAR (CDR (CAR (CDR (CAR (CDR

Konstruktor

( ) ) ==> () ( ) ) ==> () ' ( ) ) ==> () ' ( ) ) ==> () " ( ) ) ==> QUOTE " ( ) ) ==> ( ( ) ) CONS:

Während die beiden Selektoren CAR und CDR eine Liste in zwei Teile „zerlegen", „verbindet" der Konstruktor CONS (to construct) zwei symbolische Ausdrücke. Das CONS-Konstrukt hat eine Schnittstelle für zwei Argumente. Es hat als Wert eine neue Liste, wenn das zweite Argument eine Liste ist. Der Wert ist die neue Liste mit dem Wert des ersten Arguments als erstes Element dieser Liste. Kurz formuliert: CONS fügt einen symbolischen Ausdruck als Kopf an den Anfang einer Liste. (Häufige engl. LISP-Phrase: ,.1*11 cons something up"). Beispiele zum

CONS-Konstrukt:

eval> (CONS 'FREIE '(HANSESTADT BREMEN)) ==> (FREIE HANSESTADT BREMEN) eval> (CONS 1 NIL) ==> (1) eval> (CONS 10 '(20 30)) ==> (10 20 30)

Ist der Wert des zweiten Arguments keine Liste, dann hat das CONS-Konstrukt ein sogenanntes Punkt-Paar (engl.: dotted pair) als Wert, wobei der linke Teil der Wert des ersten Argumentes und dessen rechter Teil der Wert des zweiten Argumentes von CONS ist. Die Bezeichnung „dotted pair" leitet sich davon ab, daß zwischen die evaluierten Argumente ein Punkt eingefügt wird. eval> (CONS 'NOCH 'NICHT) ==> (NOCH . NICHT) Die externe Darstellung eines Punkt-Paares, die als Eingabe und Ausgabe verwendet wird, hat die Reihenfolge: öffnende Klammer, symbolischer Ausdruck,

2. Kombinieren von Konstrukten

41

Zwischenraum, Punkt, Zwischenraum, symbolischer Ausdruck und dann schließende Klammer. Die Zwischenräume sind erforderlich, um ein Punkt-Paar von einer Gleitkommazahl zu unterscheiden, bzw. um den Punkt nicht als Namensteil eines Symbols aufzufassen. eval> eval> eval>

(+ 1.2 3.4) ==> 4.6 (CONS 1 . 2 3 . 4 ) = = > ( 1 . 2 . 3 . 4 ) (CONS ' B R E M E R - L A G E R H A U S . A G ( ) ) ==> (BREMER-LAGERHAUS.AG)

¡Gleitkommazahlen ;Punkt-Paar! ¡Punkt als Namensteil

Das Punkt-Paar verweist auf die interne Abbildung eines symbolischen Ausdrukkes im Speicher des LISP-Systems. Bei der CONS-Anwendung wird (in den klassischen LISP-Implementationen) eine sogenannte LISP-Zelle (auch CONSZelle genannt) im Speicher mit den Adressen der Werte der beiden Argumenten generiert. Eine Liste ist damit ein Spezialfall einer Punkt-Paare-Struktur (vgl. Bild 2.1-2). Sie ist entweder: o ein NIL-Zeiger oder o ein Punkt-Paar, dessen CAR-Teil ein symbolischer Ausdruck ist und dessen CDR-Teil eine Liste ist. Für unser Thematik „Konstruktion" ist die Zusicherung entscheidend: Was ein Konstruktor zusammenfügt, ist ohne Verlust durch korrespondierende Selektoren „zerlegbar", d.h. wiedergewinnbar. eval> (CAR (CONS 'BAUTEIL-1 'BAUTEIL-2)) —> BAUTEIL-1 eval> (CDR (CONS 'BAUTEIL-1 'BAUTEIL-2)) —> BAUTEIL-2 Die Definition von eigenen Konstruktoren und passenden Selektoren vertiefen wir im Abschnitt 4. Prädikate: EQ?-Konstrukt und EQUAL?-Konstrukt Wenn zwei symbolische Ausdrücke miteinander verglichen werden, sind drei Fälle zu unterscheiden: o Identität: Beiden Angaben bezeichnen dasselbe „Objekt". o Gleichheit: Beide Angaben haben den gleichen Wert. Es sind aber prinzipiell zwei Abbildungen der „Objekte" (Werte) feststellbar, d.h. die Werte sind an zwei verschiedenen Stellen gespeichert (Merkformel: „Zwillinge"). o Ungleichheit. Die Gleichheit stellen wir häufig im Hinblick auf eine Austauschbarkeit fest. Zweck ist es „Gleiches durch Gleiches" zu ersetzen. Beispielsweise wollen wir den symbolischen Ausdruck (+ 1 2) durch die Zahl 3 ersetzen. Sprechen wir von Gleichheit im Sinne von NichtUnterscheidbarkeit, dann ha-

42

I. Konstrukte (Bausteine zum Programmieren)

Punkt-Paar-Struktur:

(A

. ((B

r?

0-

oV

A

,

V

o

. NIL)

. (C

.

NIL)))

NIL

V

C

NIL

v B

Legende: CAR- CDRPart Part

::=

o

::=

>

CONS-Zelle Zeiger

(Adresse)

::= NIL-Zeiger, Bild

2.1-2.

CONS-Zel1en-

entspricht:

Da rstel1ung

der

o—>

Liste

NIL (A (B)

C)

ben alle Tests für beide „Objekte" stets identische Resultate. Eine Identitätsfeststellung bei zwei Argumenten bedingt das Prüfen zweier Namen, die dasselbe „Objekt" benennen. Das Vergleichsprädikat im Sinne einer solchen Identitätsfeststellung heißt EQ (abgekürzt von £Qual; phonetisch [i:kju:]) oder ähnlich z.B. E Q ? in Scheme. Bei Symbolen nimmt das EQ?-Konstrukt Identität an, wenn beide Argumente sich auf dasselbe interne „Objekt" im LISP-System beziehen (Prüfung der Gleichheit von Adressen, vgl. Abschnitt 5). Bei Zahlatomen ist man an ihrer numerischen Wertgleichheit interessiert und nicht daran, ob das LISP-System die beiden Argumente (Zahlen) als dasselbe „Objekt" interpretiert oder nicht. Gelöst wird dieses Problem entweder durch ein eigenständiges Vergleichskonstrukt für Zahlatome (z.B. = bei Scheme) oder durch entsprechende „Erweiterung" von EQ (vgl. z.B. TLC-LISP). In modernen LISP-Systemen ist dieses Vergleichen häufig als eine sogenannte generische Funktion realisiert. Eine solche Funktion stellt selbst fest von welchem Typ die übergebenen Werte sind und aktiviert dann das zugeordnete Vergleichskonstrukt. Sind die symbolischen Ausdrücke im Sinne der Ersetzbarkeit „Gleiches durch Gleiches" zu prüfen, dann ist das EQUAL?-Konstrukt anzuwenden. Hat schon das EQ?-Konstrukt für zwei Argumente den Wert „wahr", dann hat auch das

2. Kombinieren von Konstrukten

43

EQUAL?-Konstrukt für diese Argumente den Wert „wahr". (Achtung: Die Umkehrung gilt nicht!). Mit dem EQ?-Konstrukt sind wir in der Lage, Prädikate für die Erkennung von Kunden, Lieferanten, Kassenkonten etc. zu definieren. Da diese Prädikate zum Unterscheiden zwischen verschiedenen „Objekten" dienen, bezeichnet man sie auch als Diskriminatoren. eval>

;; S y m b o l K u n d e ist (EQ? ( C A R M E Y E R - A G )

eval>

;; D i e S y m b o l e s i n d i d e n t i s c h , d i e I n f o r m a t i o n , d a ß s i e ;; E l e m e n t e e i n e r L i s t e s i n d , i s t z w e i m a l a b g e b i l d e t , ;; d a h e r k e i n e I d e n t i t ä t . (EQ? M E Y E R - A G ' ( K U N D E " D a t e n z u r M e y e r A G " ) = = > ()

eval>

;; G l e i c h h e i t v o n L i s t e n s t r u k t u r e n u n d L i s t e n e l e m e n t e n (EQUAL? M E Y E R - A G '(KUNDE "Daten zur M e y e r AG") ==> #T

eval>

;; E i n S y m b o l ist n i c h t g l e i c h e i n e r ( E Q U A L ? ' K U N D E " K U N D E " ) = = > ()

Programmfragment

in S c h e m e n u r e i n m a l 'KUNDE) ==> #T

gespeichert

Zeichenkette

2 . 1 - 3 . E r k e n n e n des Operandentyps KUNDE (von P r o g r a m m f r a g m e n t 2 . 1 - 1 )

In Scheme haben Prädikate üblicherweise als Kennzeichen am Ende ihres Namens ein Fragezeichen, daher nennen wir die Prädikate KUNDE?, LIEFERANT?, KASSENKONTO? etc. Entsprechend der Matrix-Spalte (Bild 2.1-1.) kann NEU ANLEGEN mit der Struktur von Programmfragment 2.1-4 definiert werden. eval>

(DEFINE

KUNDE?

eval>

(DEFINE

LIEFERANT?

eval>

(DEFINE

K A S S E N K O N T O ? ( L A M B D A (X) (EQ? ( C A R X) ' K A S S E N K O N T O ) ) )

eval>

eval> eval> eval>

(DEFINE (COND

(LAMBDA

(X)

(LAMBDA

(EQ? (X)

( C A R X) (EQ?

'KUNDE)))

( C A R X)

==> KUNDE? 'LIEFERANT))) ==> LIEFERANT? ==>

KASSENKONTO?

NEUANLEGEN (LAMBDA (OPERAND) ((KUNDE? OPERAND) 'XI) ((LIEFERANT? OPERAND) 'X2) ( ( K A S S E N K O N T O ? O P E R A N D ) 'X3) (T ( W R I T E L N " O p e r a t i o n e n f ü r : " O P E R A N D "noch nicht d e f i n i e r t ! " ) ) ) ) ) ==> NEUANLEGEN ( N E U A N L E G E N S C H U L Z E - G M B H ) = = > X2 ( N E U A N L E G E N V E R W A H R U N G - 1 ) = = > X3 ( N E U A N L E G E N '(A B C ) ) = = >

44

I. Konstrukte (Bausteine zum Programmieren) Operation

für:

(A B C) n o c h n i c h t

Programmfragment2.1-4.

definiert!

Operation NEUANLEGEN als Konstrukt-Basis ( v g l . B i l d und Programmmfragment

2.1-1).

Im Programmfragment 2.1-4 sind die Operationen xl, x2 und x3 nicht ausformuliert, sondern nur als Konstanten angegeben. Zur Ausgabe einer Fehlermeldung nutzen wir das WRITELN-Konstrukt (write /ine newline). Es evaluiert seine Argumente, faßt die Werte zu einer Zeile zusammen, gibt diese (am aktuellen Ausgabegerät) aus und bewirkt einen Zeilenvorschub. Bei einem komplexen Problem führt die Zusammenfassung von Operationen entsprechend der Matrix-Spalten (Bild 2.1-1) zu einer Hierarchie von Konstrukten. Diese Hierarchie ist geprägt durch die Operationen (Aktionen) des jeweiligen Aufgabengebietes. Beispielsweise käme man zur Operation NEUANLEGEN über ein hierarchisch höheres Konstrukt. Wir nehmen an, daß diese Auswahloperation den Namen VERWALTEN habe. Das Konstrukt VERWALTEN ermittelt dann anhand seines Operanden, daß NEUANLEGEN auszuführen sei. So entsteht eine operations-geprägte Konstruktion. Sie ist gegliedert (modularisiert) in Operationen. Im Mittelpunkt der symtema(naly)tischen Überlegungen stehen die Aktionen (Prozesse, Vorgänge). Wären nach Fertigstellung der Konstruktion weitere Operanden, z.B. Sachkonten, einzubeziehen, dann sind in den Operationen NEUANLEGEN, LÖSCHEN etc. jeweils die entsprechenden Funktionen für die Sachkonten einzubauen. Dies ist im Falle vieler bestehender Operationen ein sehr aufwendiges und fehleranfälliges Unterfangen, weil fertiggestellte Konstrukte z.B. NEUANLEGEN modifiziert werden müssen. Damit sind neue Fehler für schon programmierte Operandentypen nicht ausschließbar. Sind solche Änderungen wahrscheinlich, dann empfiehlt es sich, die Konstrukte aus der Matrixzeilen-Sicht zu entwickeln, statt sie aus der MatrixspaltenSicht zu bilden. Exemplarisch ist das Konstrukt KUNDE als Programmfragment 2.1-5 definiert. Es skizziert die Operanden-Sicht in stark vereinfachter Art. eval>

eval>

( D E F I N E KUNDE (LAMBDA ( O P E R A T I O N ) (COND ((NEUANLEGEN? OPERATION) ' X l ) ((LÖSCHEN? OPERATION) ' Y l ) ((ANMAHNEN? OPERATION) 'ZD (T (WRITELN " F ü r Kunden i s t : " OPERATION "noch n i c h t d e f i n i e r t ! " ) ) ) ) ) (DEFINE

NEUANLEGEN?

(LAMBDA

(XHEQ?

(CAR X)

==>

KUNDE

'NEUANLEGEN))) = = > NEUANLEGEN?

2. Kombinieren von Konstrukten eval>

( D E F I N E MEYER-AG (KUNDE ' ( N E U A N L E G E N

Programmfragment

2.1-5.

45

"Daten

zur

Operand KUNDE ( v g l . B i l d und

Meyer

AG")))

==>

MEYER-AG

als Konstrukt-Basis Programmfragment 2 . 1 - 1 )

Auch hier führen die Abstraktionsschritte zu einer Hierarchie von Konstrukten. Beim Ergänzen um den Operanden SACHKONTO werden die bestehenden Konstrukte wie KUNDE, LIEFERANT etc. nicht berührt. Das Zusammenfassen aller Operationen bietet daher ein Modularisierungs-Konzept, das ein Hinzufügen von neuen Konstrukten im Sinne von Operanden erleichtert. Ist allerdings eine neue Operation z.B. UMBENENNEN später zu ergänzen, dann sind die Konstrukte KUNDE, LIEFERANT, KASSENKONTO etc. zu modifizieren. So entsteht eine operanden-geprägte Konstruktion. Sie hat einen objekt-orientierten Aufbau. Im Mittelpunkt der symtema(naly)tischen Überlegungen stehen die Operanden im Sinne von Objekten (Näheres dazu vgl. Abschnitt 10). Die Frage, ob die Lösung „Operation als Konstrukt-Basis" (Programmfragment 2.1-4) oder die Lösung „Operand als Konstrukt-Basis" (Programmfragment 2.1-5) zweckmäßiger ist, bedingt eine Prognose über die Fortentwicklung des Softwareproduktes. Das skizzierte Beispiel Kontenverwaltung verdeutlicht, daß unsere Konstruktions-Entscheidungen im Kontext des gesamten SoftwareLebenszyklus zu treffen sind. Die Erfüllung einer funktionalen Anforderung z.B. das korrekte Abbilden einer Buchung ist notwendig, aber nicht hinreichend. Hinzukommen muß die Abdeckung von erwartbaren Anforderungen aus den späteren Phasen des Lebenszyklus. In unserem Kontext „Konstruktion" ist stets zu unterscheiden, ob es um die Realisierung relativ kleiner Konstrukte (Menge einzelner „Anweisungen/Befehle") oder um große Konstrukte (ganze Programmeinheiten) geht. Im ersten Fall ist die Reihenfolge der Aktivierung einzelner „Anweisungen/Befehle" zu diskutieren. Im zweiten Fall geht es um die Koordination von ganzen Programmteilen (Moduln), also um abgeschlossene Folgen von „Anweisungen/Befehlen". Zunächst widmen wir uns der Realisierung kleiner Konstrukte, die häufig als „Programmierung im Kleinen" (engl.: programming-in-the-small) bezeichnet wird (vgl. z.B. DeRemer/Kron, 1976). Wir fangen also „klein" an und skizzieren mit wachsendem LISP-Fundus Verknüpfungs-Techniken für das „Programmieren im Großen" (engl.: programming-in-the-large).

2.2 Kontrollstrukturen Legen wir fest, wann, unter welchen Bedingungen und wie oft einzelne Konstrukte auszuwerten sind, dann definieren wir die Kontrollstruktur (engl.: control structure). Sie beschreibt, ob und in welcher Reihenfolge Programm(teil)e ausge-

46

I. Konstrukte (Bausteine zum Programmieren)

führt werden. Man bezeichnet sie korrekterweise auch als Steuerungsstruktur oder auch als Ablaufsteuerung. In der Terminologie imperativgeprägter Programmiersprachen (z.B. COBOL oder Pascal, Näheres vgl. Abschnitt 4) spricht man vom Steuerungsfluß oder Kontrollfluß (engl.: flow of control). Kombinierbar sind Konstrukte durch eine Hintereinanderausführung. Diese Verkettung nennt man im Zusammenhang mit Funktionen Komposition. In der Mathematik wird die Komposition zweier Funktionen f und g notiert als „fog" und gelesen als „f verkettet mit g" oder „g eingesetzt in f ' oder „f nach g". Diese Komposition ist in LISP als (F (G X)) zu formulieren mit F und G als Funktionen, die für ein Argument definiert sind (engl.: unary functions). Der Wert dieser Komposition ist der Wert von (F Y), wobei Y der Wert von (G X) ist. Die Komposition (F (G X)) ist nur dann sinnvoll, d.h. nicht Undefiniert, wenn X die Schnittstelle von G und Y die Schnittstelle von F erfüllen. Anders formuliert: Die Komposition bedingt, daß X in der Definionsmenge von G und die Wertemenge von G in der Definitionsmenge von F enthalten sind. Beispiele für die Komposition: eval> (DEFINE ADD2 (LAMBDA (ZAHL) (+ 2 ZAHL)))==>ADD2 eval> (DEFINE MUL3 (LAMBDA (ZAHL) (* 3 ZAHL))) ==> MUL3 eval> (ADD2 (MUL3 1)) ==> 5 eval> (MUL3 (ADD2 1)) ==> 9 eval> (DEFINE A2M3 (LAMBDA (ZAHL) (ADD2 (MUL3 ZAHL)))) ==> A2M3 eval> (A2M3 1) ==> 5 eval> ;; Komposition zweier anonymer Funktionen ((LAMBDA (ZAHL) (+ 2 ZAHL)) ((LAMBDA (ZAHL) (* 3 ZAHL)) 1)) ==> 5 Elementare Kontrollstrukturen sind: o die Folge (Sequenz) o die Auswahl (Selektion) und o die Wiederholung (Iteration). Bevor wir ihre Realisierung diskutieren, sind nochmals die bisher erläuterten Konstruktionsmittel in Backus-Naur-Form (vgl. folgenden Exkurs) als Tabelle 2.2-1 zusammengestellt. Sie zeigt atomare Komponenten (wie Symbol oder Zahl), Grundprozeduren (wie CONS, CAR oder CDR) und zusätzlich elementare Kontrollstrukturen. Z.B. ermöglicht das LAMBDA-Konstrukt das Verknüpfen von Konstrukten als Sequenz. ^Exkurs: Backus-Naur-Form. Die von John W. Backus und Peter Naur definierte Notation ist geeignet, die Syntax einer Programmiersprache zu spezifizieren. Eine BNF-Metasprach-Variable, auch syntaktische Einheit genannt, ist eine Variable, deren Wert auf Zeichen zurückführbar ist, die in der gegebenen Sprache (hier LISP) zulässig sind. Aus Klarheitsgründen sind die BNF-Metasprach-Variablen in spitze Klammern „" eingeschlossen.

2. Kombinieren von Konstrukten

47

Damit unterscheiden sich diese „nonterminal symbols" (kurz „nonterminals") von den Symbolen in LISP, die auch als „terminal symbols" (kurz „terminals") bezeichnet werden. Die BNF-Metasprach-Gleichheit, dargestellt durch „::=", kann aufgefaßt werden als „ist konstruierbar aus". Dabei wird eine Wahlmöglichkeit im Sinne einer Oder-Verknüpfung durch den senkrechten Strich „ | " dokumentiert. Eckige Klammern [ ... ] kennzeichnen die Möglichkeit, das Eingeklammerte weglassen zu können. Geschweifte Klammern { ... } dokumentieren, daß das Eingeklammerte beliebig oft wiederholt oder aber auch ganz weggelassen werden kann.7

=



=

({()

=

|

=



|

...

;und w e i t e r e T y p e n ; z.B. Zeichen oder ; Zeichenkette |

|

|

| |

=



=

( < z i f f e r > | I ... ;und wei t e r e T y p e n ; z.B. 12.34

=

| +

| -

A | B | C | D | E | F | G | H | I | J | K IM IN 10 | P IQ I R IS IT I U IV I W I X I Y I Z I a I b ' | .!. |'z L



0

I


I ?

| 1

| 2

| 3

!

| § ;und w e i t e r e T y p e n z B & | 4'| 5 j 6 | 7 | 8 | 9

Legende: vgl. obigen Exkurs B a c k u s - N a u r - F o r m ; Z e i c h e n h i n t e r d e m S e m i k o l o n in e i n e r Tab.2.2-1.

Zeile

Erörterte Konstruktions-Mittel (Teil - d a r g e s t e l l t in B a c k u s - N a u r - F o r m -

sind

Kommentar

1)

Die Tabelle 2.2-1 definiert auszugsweise ein LISP-System; es umfaßt keinesfalls alle Kontrakte eines LISP-Dialektes wie Scheme. Wir können jedoch mit ihr wesentliche Charakteristika diskutieren. So kann z.B. kein Konto mit dem

48

I. Konstrukte (Bausteine zum Programmieren)

::=

(QUOTE

)

)

¡Kreieren

einer

Konstanten

¡Einfügen

in e i n e

|

(CONS

|

( C A R )

¡Selektion

des

ersten

|

( C D R )

¡Selektion

der

Restliste

|

(LIST

¡Bilden

einer

Liste

|

(DEFINE

¡Binden

eines

Symbols

|

(SET!

|

(COND {(

|

(LAMBDA (KsymbolX)

|

(APPLY

|

(EVAL

|

(

I))



< s e x p r >)

)

¡Modifizieren

¡Defintion ( )) )

einer

¡Applikation

[])

( (}

einer

Elementes

Bindung

;Fallunterschei dung

KsexprX)})

Liste

¡Auswerten

))

Funktion

einer

Funktion

in e i n e r

Umgebung

¡Komposition

Legende: siehe Exkurs Backus-Naur-Form ; ::= K o m m e n t a r Tab.2.2-1.

Erörterte Konstruktions-Mittel (Teil - d a r g e s t e l l t in B a c k u s - N a u r - F o r m -

2)

Namen 1234 entsprechend unserem Konto MEYER-AG (vgl. Abschnitt 2.1) gebildet werden. eval>

(DEFINE 1234 ( K U N D E ' ( N E U A N L E G E N " D a t e n zu = = > E R R O R ... ¡ F e h l e r h a f t e s S y m b o l f ü r

Konto 1234"))) DEFINE

Die Zahlatome sind von Symbolen (auch Literalatome genannt) zu unterscheiden. Nur mit Symbolen ist das Kreieren einer Wert-Assoziation in einer Umgebung möglich. Zahlatome haben sich selbst als Wert; stellen aber keine Variable dar (vgl. Abschnitt 1.4.2). Eine Funktion kann daher nicht mit einem Zahlatom benannt werden. Auch die Schnittstelle der eigenen Konstrukte, gebildet durch die LAMBDA-Variablen, erfordert Symbole. Zahlatome sind dort nicht verwendbar. Wir stellen fest: Für Zahlatome gibt es Restriktionen im Vergleich zu Literalatomen (Symbolen). Zahlatomen fehlt die sogenannte „first-class"-Eigenschaft (vgl. folgenden

2. Kombinieren von Konstrukten

49

Exkurs "First-class"-Objekt). So kann die arithmetische Funktion, die den Wert ihres Argumentes um 1 erhöht, nicht +1 heißen, weil +1 als Zahlatom interpretiert wird. Die Umkehrung dieser Zeichenfolge ist in Scheme ein Symbol. Die Funktion ist daher mit 1+ benennbar. e v a l > (1+ 2) ==> 3 e v a l > (+1 2) ==> ERROR . . . e v a l > (+ 1 2) ==> 3

;1+ i s t e i n Symbol ;+l i s t k e i n Symbol ;+ i s t ein Symbol

/Exkurs: "First-class-Objekt" (auch „first-class-citizen" genannt). Im LISPKontext haben „Objekte" (Werte) dann „first-class"-Eigenschaften, wenn folgende Bedingungen erfüllt sind (vgl. z.B. dinger, 1988, p. 224): o Objekte haben eine Identität. Diese ist unabhängig von jedem Namen, unter dem Objekte gekannt werden können. So kann ein Objekt auch mehrere Namen haben. (Diese Eigenschaft fehlt Zahlatomen.) o Objekte können anonym bleiben. Z.B. evaluiert das LAMBDA-Konstrukt zu einer anonymen Funktion. o Objekte können ohne Verlust ihrer Identität überall gespeichert werden; als Werte von Variablen oder in komplexen Datenstrukturen. o Objekte können sowohl Argument als auch Rückgabewert einer Funktion sein. o Objekte „sterben" nicht. Ein Objekt wird unbenutzbar („unzugreifbar") und damit zwecklos. Der von ihm belegte Speicherplatz kann vom LISP-System als wieder „verfügbar" erklärt werden, vorausgesetzt, die Unbenutzbarkeit wird erkannt. Das LISP stellt fest,ob ein Objekt als „Müll" (engl.: garbage) zu betrachten ist. Algorithmen, die dies erkennen, bezeichnet man als „garbagecollection"-Algorithmen. R. Popplestone spricht in diesem Kontext von „items", die fundamentale Rechte besitzen (Näheres vgl. Allen, 1978).y

2.2.1 Sequenz Wir nehmen an, ein symbolische Ausdruck GESAMT setzt sich aus den Teilen TEIL-1, TEIL-2 und TEIL-3 zusammen, wobei diese Teile ebenfalls symbolische Ausdrücke sind. Vorstellbar ist, daß GESAMT ein Programm ist, das aus den Moduln TEIL-1, TEIL-2 und TEIL-3 besteht. Aufgrund der Abbildungsgleichheit von Programm und Daten ist auch annehmbar, daß GESAMT eine Datenstruktur abbildet z.B. eine Anschrift, die aus der Folge Straße (TEIL-1), Postleitzahl (TEIL-2) und Wohnort (TEIL-3) besteht. Eine Sequenz mit dem Namen GESAMT und den Teilen TEIL-1, TEIL-2, TEIL-3 stellt Bild 2.2.1-1 graphisch dar.

50

I. Konstrukte (Bausteine zum Programmieren)

Diese Darstellungsform wurde von M. A. Jackson insbesondere für den Programmentwurf vorgeschlagen (vgl. Jackson, 1979). Zur Erläuterung der Selektion (Abschnitt 2.2.2) und der Iteration (Abschnitt 2.2.3) wird ebenfalls die Jackson-Notation genutzt.

Die abgebildete Sequenz sei die Zerlegung (Modularisierung) eines Programms. Das „Laufenlassen" des Programms GESAMT bedeutet das Abarbeiten der Moduln TEIL-1, TEIL-2 und TEIL-3. Wir formulieren daher eine Funktion GESAMT aus den Teilen TEIL-1, TEIL-2 und TEIL-3, wie folgt: eval > eval > eval> eval> eval>

(DEFINE (DEFINE (DEFINE (DEFINE (GESAMT)

G E S A M T ( L A M B D A () T E I L - 1 T E I L - 2 T E I L - 3 ) ) = = > G E S A M T T E I L - 1 " < s e x p r > für Modul T E I L - 1 " ) = = > T E I L - 1 T E I L - 2 " < s e x p r > für M o d u l T E I L - 2 " ) = = > T E I L - 2 T E I L - 3 " < s e x p r > für M o d u l T E I L - 3 " ) = = > T E I L - 3 = = > " < s e x p r > für Modul T E I L - 3 " ; R ü c k g a b e w e r t ist d e r W e r t v o n T E I L - 3

Programmfragment

2.2.1-1.

Sequenz

von

Symbolen

Im Programmfragment 2.2.1-1 werden die Werte von TEIL-1, TEIL-2 und TEIL-3 zum Zeitpunkt ihrer Definition ermittelt. Stände an der Stelle von " für Modul TEIL-3" z.B. der symbolischen Ausdruck (WRITELN "Der Sinus ist: " (SIN (+ 0.2 0.3))) dann wird dieses Sinus-Berechnungsprogramm beim Evaluieren des DEFINE-Konstruktes ausgeführt, wobei TEIL-3 an den Rückgabewert des WRITELN-Konstruktes gebunden wird, hier NIL. Die Ausgabe der Druckzeile ist auf dem Bildschirm erfolgt. Die Anwendung von GESAMT führt nur zum Ermitteln der Bindung von TEIL-3. Dieser wahrscheinlich ungewollten Effekt ist vermeidbar, indem wir an den Modul einen „gequoteten" symbolischen Ausdruck (eine Konstante) binden; z.B. für TEIL-3:

51

2. Kombinieren von Konstrukten eval>

(DEFINE TEIL-3 '(WRITELN "Der

Sinus

ist:

" (SIN

(+ 0 . 2 0 . 3 ) ) ) )

==>

TEIL-3

Verfahren wir für TEIL-1 und TEIL-2 entsprechend, dann ist die Sequenz GESAMT wie folgt zu definieren: eval>

(DEFINE GESAMT ( L A M B D A () (EVAL TEIL-1)

(EVAL TEIL-2)

(EVAL TEIL-3)))

==>

GESAMT

Statt das QUOTE-Konstrukt einzusetzen, können wir die Moduln TEIL-1, TEIL-2 und TEIL-3 auch als LAMBDA-Konstrukte definieren, so daß erst die Applikation von GESAMT die Auswertung der Moduln bewirken soll. ;;; G E S A M T u n d d i e M o d u l n T E I L - 1 , T E I L - 2 ;;; s i n d a l s F u n k t i o n e n d e f i n i e r t .

und

eval>

(DEFINE

GESAMT

(LAMBDA

()

(TEIL-1)

(TEIL-2)

eval>

(DEFINE TEIL-1

(LAMBDA

()

"

eval>

(DEFINE

TEIL-2

(LAMBDA

()

"

eval>

(DEFINE TEIL-3

(LAMBDA

()

"

Programmfragment

2.2.1-2.

Sequenz

von

TEIL-3

(TEIL-3))) ==> GESAMT f ü r Modul T E I L - 1 " ) ) ==> TEIL-1 für Modul T E I L - 2 " ) ) ==> TEIL-2 für Modul T E I L - 3 " ) ) ==> TEIL-3 Funktionsanwendungen

Im Programmfragment 2.2.1-2 werden die Moduln TEIL-1, TEIL-2 und TEIL-3 nur abgearbeitet. Ihnen werden vom (Haupt-)Modul GESAMT keine Werte übergeben. Um Werte über eine Schnittstelle von GESAMT für die sequentielle Abarbeitung der Moduln TEIL-1, TEIL-2 und TEIL-3 bereitzustellen, definieren wir GESAMT mit LAMBDA-Variablen, z.B. mit den Parametern P _ X und P_ Y. eval> eval>

(DEFINE GESAMT ( L A M B D A (P_X P _ Y ) ( T E I L - 1 ) ( T E I L - 2 ) ( T E I L - 3 ) ) ) = = > G E S A M T (GESAMT ARGUMENT-1 ARGUMENT-2) = = > " für Modul T E I L - 3 "

Wir können die Abarbeitungsfolge TEIL-1, TEIL-2 und TEIL-3 auch so interpretieren, daß ihr Ergebnis den Namen GESAMT hat. Der Wert von GESAMT repräsentiert die vollzogene Sequenz. eval>

(DEFINE GESAMT ( ( L A M B D A (P_X

P_Y)

(TEIL-1) (TEIL-2) (TEIL-3)) ARGUMENT-1 ARGUMENT-2)) ==>

GESAMT

Jetzt wird die anonyme Funktion auf den Wert der beiden Argumente ARGU-

52

I. Konstrukte (Bausteine zum Programmieren)

MENT-1 und ARGUMENT-2 angewendet, wobei alle Nebeneffekte z.B. WRITELN-Konstrukte sofort zum Tragen kommen. Der Wert der Sequenz wird durch das DEFINE-Konstrukt mit dem Symbol GESAMT assoziiert. Auch hier können wir durch QUOTE- und EVAL-Konstrukte den Zeitpunkt der Ausführung festlegen (vgl. Abschnitt 2.3). e v a l > (DEFINE GESAMT •((LAMBDA (P_X P_Y)

(TEIL-1) (TEIL-2) (TEIL-3)) ARGUMENT-1 ARGUMENT-2)) ==> GESAMT e v a l > (EVAL GESAMT) ==> " < s e x p r > f ü r Modul T E I L - 3 "

Bei der Anwendung einer anonymen Funktion, insbesondere wenn diese durch ein umfangreiches LAMBDA-Konstrukt mit vielen LAMBDA-Variablen dargestellt wird, ist die Zuordnung der Argumente zu den LAMBDA-Variablen unübersichtlich. In LISP gibt es deshalb eine syntaktische Verbesserung in Form des LET-Konstruktes. e v a l > (LET ( ( < v a r i a b l e _ l >

)

( < v a r i a b l e _ n > )) ) ==> < v a l u e >

ist zurückführbar auf: e v a l > ((LAMBDA

(

) ) < a r g u m e n t _ l > . . . ) ==> < v a l u e >

/Hinweis: LET-Implementation. Das LET-Konstrukt ist häufig als Makro-Konstrukt realisiert. Makros werden in zwei Schritten abgearbeitet. Zunächst wird aus einem Makro ein neuer symbolischer Ausdruck konstruiert. Diesen Schritt nennt man „Expandieren". Im zweiten Schritt wird der entstandene Ausdruck evaluiert. In PC Scheme ist das Ergebnis des ersten Schrittes mittels EXPANDMACRO darstellbar (Näheres vgl. Abschnitt 8.3). Damit können wir zeigen in welchen Ausdruck das LET-Konstrukt expandiert, e v a l > (EXPAND-MACRO ' ( L E T ( ( A 1) (B 2 ) ) (F00 A B ) ) ) ==> ((LAMBDA (A B) (F00 A B ) ) 1 2)

]

Das L£T-Konstrukt entspricht der Applikation eines LAMBDA-Konstruktes. Wir können es als ein Konstrukt betrachten, das zunächst lokale Variablen definiert und mit diesen Bindungen seinen Funktionskörper auswertet. (LET ( ( < 1 o k a l e _ v a r i a b l e _ l >

)

;Binden der 1. ; Variablen

lokalen

2. Kombinieren von Konstrukten

53

( )) ) ==>

¡Bindung der n-ten ; lokalen Variablen

Den syntaktischen Vorteil des „LET-Schreibstils" gegenüber dem "LAMBDASchreibstil" verdeutlicht das folgende Beispiel: eval> ((LAMBDA (W X Y Z) (LIST (CAR (CDR W)) (CAR (CDR X)) (CAR (CDR Y)) (CAR (CDR Z)))) '(MEANS M) '(OF 0) '(REQUIREMENTS R) '(ENGINEERING E)) ==> ( M O R E ) eval> (LET ((W '(MEANS M)) (X '(OF 0)) (Y '(REQUIREMENTS R)) (Z '(ENGINEERING E))) (LIST (CAR (CDR W)) (CAR (CDR X)) (CAR (CDR Y)) (CAR (CDR Z)))) ==> ( M O R E ) Intuitiv vermutet man in der Bindung der lokalen Variablen eines LET-Konstruktes die Möglichkeit, eine Sequenz zu konstruieren. Da das LET-Konstrukt einer Applikation eines LAMBDA-Konstruktes entspricht, ist der Vorgang der Auswertung der Argumente vom Vorgang der Bindung der LAMBDA-Variablen an die Werte zu unterscheiden. Bezogen auf das LET-Konstrukt formuliert: Es werden zunächst alle Werte der lokalen Variablen in einer prinzipiell beliebigen Reihenfolge ermittelt, dann findet die Bindung der jeweiligen Variablen statt. Da die Reihenfolge dieser Wertermittlung nicht allgemeingültig festliegt (sondern sogar als Ansatz für eine Parallelverarbeitung in LISP dient), sollten wir beim LET-Konstrukt keine Sequenz unterstellen, wie im folgenden Beispiel: eval> (LET ((F00 (WRITELN "1. Phase")) (BAR (WRITELN "2. Phase"))) (LIST F00 BAR)) ==> 1. Phase 2. Phase (() ( ) ) Zu berücksichtigen ist, daß die Ermittlung aller Werte vor der Bindung an die LAMBDA-Variablen erfolgt. Beim LET-Konstrukt sind sie daher bei der Wertermittlung nicht zugreifbar. eval> (LET ((X 3) (Y (* 2 X))) (+ X Y)) ==> ERROR . . .

;Das Symbol X i s t nicht in der ; aktuellen Umgebung d e f i n i e r t .

Hilfsweise können wir die Sequenz durch Schachtelung von LET-Konstrukten

54

I. Konstrukte (Bausteine zum Programmieren)

abbilden, die nur eine lokale Variable ausweisen (vgl. Curryfizieren einer Funktion, Abschnitt 8.1.2): eval> (LET ((X 3)) (LET C C Y (* 2 X))) (+ X Y))) ==> 9 In LISP-Systemen gibt es eine übersichtlichere Lösung durch das L£T*-Konstrukt. Dieses bindet die lokalen Variablen der Reihe nach. Zunächst wird der Wert für die erste Variable ermittelt und dann wird diese gebunden. Danach wird jede neue Bindung in der Umgebung ausgewertet, die durch die vorhergehenden lokalen Variablen erweitert wurde. eval> (LET* ((X 3) (Y (* 2 X))) (+ X Y)) ==> 9 /Hinweis: LET*-Implementation. Das LET*-Konstrukt ist häufig wie das LETKonstrukt als Makro-Konstrukt implementiert (Näheres vgl. Abschnitt 8.3). Es expandiert unser obiges Beispiel, wie folgt: eval > (EXPAND-MACRO '(LET* ((X 3) (Y (* 2 X))) (+ X Y))) ==> ((LAMBDA (X) (LET* ((Y (* 2 X))) (+ X Y))) 3) ] Das LET*-Konstrukt ermöglicht die Abbildung der Sequenz TEIL-1, TEIL-2 und TEIL-3 (vgl. Bild 2.2.1-1.), wie folgt: eval> (DEFINE GESAMT (LET* ((TEIL-1 (TEIL-2 (TEIL-3 TEIL-3 ))

" f ü r TEIL-1") " f ü r TEIL-2") " f ü r TEIL-3")) ==> GESAMT

Entsprechend unserer Diskussion über die funktionale Alternative ist die Sequenz auch, wie folgt, definierbar: eval> (DEFINE GESAMT (LET* ((TEIL-1 (TEIL-2 (TEIL-3 (TEIL-1)

(LAMBDA (LAMBDA (LAMBDA (TEIL-2)

() " () " () " (TEIL-3)))

für für für ==>

TEIL-1")) TEIL-2")) TEIL-3"))) GESAMT

Solange bei der Ermittlung des Wertes für eine lokale Variable kein Bezug auf die Variable selbst genommen wird, ist die Reihenfolge „erst Wertermittlung (Auswertung des Argumentes), dann Bindung" ausreichend. Soll jedoch ein rekursiver Bezug möglich sein, dann muß die Variable bei ihrer Wertermittlung in der Umgebung der Auswertung schon existieren. Notwendig sind dann folgende Schritte:

2. Kombinieren von Konstrukten

55

1. Erweiterung der Auswertungsumgebung um die Variable (dabei kann die Variable an einen beliebigen Wert gebunden sein), 2. Ermittlung des Wertes für diese Variable und 3. Bindung der Variablen an den Wert in derselben Umgebung. Diese Schrittfolge simuliert das folgende LET-Konstrukt: eval> (LET ((F00 ^UNDEFINIERT*)) (SET! F00 (LAMBDA ( . . . ) . . . F00 . . . ) ) (F00 . . . ) . . . ) ==> . . .

¡Schritt 1 ¡ S c h r i t t e 2 und 3

In vielen LISP-Dialekten, so auch in Scheme, heißt das äquivalente Konstrukt LETREC, wobei der Postfix REC die Abkürzung für "rekursiv" ist. Wir behandeln das LETREC-Konstrukt bei der Erörterung der Rekursion (vgl. Abschnitt 3.3). Mit dem Fixpunktoperator Y skizzieren wir eine Implementationsalternative (vgl. Abschnitt 8.1.2). Das LETREC-Konstrukt deckt die Sequenz ebenso ab wie das L E T - K o n strukt. Zu beachten ist dabei die Reihenfolge für die Bindung einer Variablen. Im ersten Schritt wird die Variable in der Umgebung vermerkt und überdeckt damit eine globale Defintion, obwohl ihr „Startwert" im Prinzip nicht zugreifbar sein sollte. In PC Scheme ist dieser „Startwert" jedoch gleich NIL. Folgende Formulierungen bauen auf diesem „Startwert" auf. Wir vermeiden derartige Konstruktionen, zumal sie darüber hinaus leicht zu Fehler führen. eval> (DEFINE F00 'BAR) ==> F00 eval> (LETREC ((F00 (LIST F00 F00))) F00) ==> ( ( ) ( ) ) eval> (LETREC ((F00 (* 2 F00))) . . . ) ==> ERROR . . . ;Nichtnumerischer Operand f ü r ; a r i t h m e t i s c h e Funktion Die bisherige Diskussion der Sequenz fußt auf dem LAMBDA-Konstrukt. Gezeigt wurde, daß die Sequenz als Applikation der anonymen Funktion formulierbar ist: eval> ((LAMBDA (P_X P_Y) TEIL-1 TEIL-2 TEIL-3) ARGUMENT-1 ARGUMENT-2) ==> . . . Ein LISP-System verfügt für die Sequenz über ein „spezielles" Konstrukt (im Sinne von EVAL-Regel 3, vgl. Abschnitt 1.2). In Scheme ist es das BEGINKonstrukt. Ist das Symbol BEGIN das erste Listenelement, dann werden die Argumente der Reihe nach ausgewertet. Der Wert des letzten Argumentes ist der Wert des gesamten BEGIN-Konstruktes.

56 eval>

I. Konstrukte (Bausteine zum Programmieren) (BEGIN

... ) — >

entspricht damit: eval>

((LAMBDA ()

... )) — >

Wir können uns daher das LAMBDA-Konstrukt als ein Konstrukt vorstellen, das ein implizites BEGIN-Konstrukt enthält. Eine implizit formulierte Sequenz ist in einigen LISP-Konstrukten implementiert, z.B. im COND-Konstrukt (nicht jedoch im IF-Konstrukt, vgl. Programmfragment 2.2.1-3). Die Sequenz ist auch aufgrund der festen Reihenfolge, die EVAL-Regel 2 vorgibt, abbildbar (vgl. Abschnitt 1.2). Danach sind erst die Argumente auszuwerten, ehe die Funktion darauf angewendet wird. Wir definieren daher ein LAMBDA-Konstrukt mit einem formalen Parameter *DUMMY*, so daß die Angabe eines Argumentes möglich ist. Die Applikation dieser anonymen Funktion bildet dann die Sequenz dadurch ab, daß das Argument bildet und der Funktionskörper ist. eval>

((LAMBDA

(*DUMMY*)

)

)

==>

Sicherzustellen ist allerdings, daß die Bindung von *DUMMY* an keinen Einfluß auf die Berechnung von hat. Anders formuliert: Die LAMBDA-Variable *DUMMY* darf nicht als freie Variable im Ausdruck vorkommen. Durch die Komposition entsprechener LAMBDA-Konstrukte ist eine Sequenz mit n-Elementen abbildbar. Eine Sequenz mit drei Elementen ist dann, wie folgt, zu notieren: eval>

;;;; ;;;; eval> eval>

;;;; ;;;; eval>

((LAMBDA (*DUMMY*) ((LAMBDA (*DUMMY*) ) ) Sequenz - B e i s p i e l m i t e x p l i z i t notierendem BEGIN-Konstrukt

)

==>

zu

( D E F I N E *KUNDEN-ANZAHL* 0) = = > *KUNDEN-ANZAHL* ( D E F I N E * L I E F E R A N T E N - A N Z A H L * 0) = = > * L I E F E R A N T E N - A N Z A H L *

Fall

1:

E i n e S e l e k t i o n mit S e q u e n z e n , BEGIN-Konstrukt erfordern.

( D E F I N E ZÄHLUNG (LAMBDA (OPERAND) ( I F (KUNDE? OPERAND) ( B E G I N ( S E T ! *KUNDEN-ANZAHL*

die ein

explizites

(+ 1 *KUNDEN-ANZAHL*))

2. Kombinieren von Konstrukten

(IF

eval> ;;;;

(ZÄHLUNG Fall

2:

(WRITELN "Bearbeite Kunden!")) (LIEFERANT? OPERAND) (BEGIN (SET! ^ L I E F E R A N T E N - A N Z A H L * (+ 1 * L I E F E R A N T E N - A N Z A H L * ) ) (WRITELN "Bearbeite Lieferant!")) (WRITELN "Weder Kunde noch Lieferant"))))) ==> ZÄHLUNG

SCHULZE-GMBH)

Nutzung

eval>

(DEFINE (COND

eval>

(ZÄHLUNG

57

der

==>

"Bearbeite

impliziten

Sequenz

Lieferanten!" im

COND-Konstrukt

ZÄHLUNG (LAMBDA (OPERAND) ((KUNDE? OPERAND) ( S E T ! * K U N D E N - A N Z A H L * (+ 1 * K U N D E N - A N Z A H L * ) ) (WRITELN "Bearbeite Kunden!")) ((LIEFERANT? OPERAND) (SET! * L I E F E R A N T E N - A N Z A H L * (+ 1 * L I E F E R A N T E N - A N Z A H L * ) ) (WRITELN "Bearbeite Lieferant!")) (T ( W R I T E L N " W e d e r K u n d e n o c h L i e f e r a n t " ) ) ) ) } ==> ZÄHLUNG SCHULZE-GMBH)

Programmfragment2.2.1-3.

==>

"Bearbeite

Sequenzmi (vgl.

Lieferanten!"

tBEGIN-Konstrukt

Programmfragment

2.1-4)

Im Zusammenhang mit dem BEGIN-Konstrukt ist das ßZiG/TVO-Konstrukt zu nennen. Es wertet seine Argumente der Reihe nach aus und gibt als Rückgabewert den Wert des ersten Argumentes zurück. Da die Zählung der Argumentente intern üblicherweise mit Null beginnt, wurde an den Namen BEGIN einfach eine Null gehängt. eval>

(BEGINO

)

— >

Das BEGINO-Konstrukt läßt sich als syntaktische Vereinfachung von folgendem LET-Konstrukt auffassen: (BEGINO

...

)

entspricht: (LET

((X < s e x p r _ 0 > ) (Y ( L A M B D A () < s e x p r _ l > ( B E G I N (Y) X ) )

...

)))

/Hinweis: BEGINO-Implementation. Das BEGINO-Konstrukt ist häufig als Makro-Konstrukt realisiert. Das BEGINO-Makro führt zu einem LAMBDA-Konstrukt mit einem vom LISP-System generiertem Symbol als LAMBDA-Variable. eval>

( E X P A N D - M A C R O '(BEGINO 'TEIL-1 'TEIL-2 'TEIL-3)) ==> ( ( L A M B D A (S500000) (BEGIN (QUOTE TEIL-2) (QUOTE TEIL-3) %00000)) (QUOTE TEIL-1))

]

I. Konstrukte (Bausteine zum Programmieren)

58

Beispiel zum BEGINO-Konstrukt: Definiert ist ein Konstrukt zum Stapeln von Werten („Objekten") nach dem Prinzip „ L a s t /n, First Out" (kurz LIFO-Prinzip oder auch Stack-Prinzip genannt). Die Zugriffsfunktion POP! gibt das oberste Stack-Element, während die Funktion PUSH! das Objekt "kellert", d.h. in den Stack einspeichert. eval> eval>

eval>

eval> eval> eval>

(DEFINE (DEFINE

* S T A C K * '(MUELLER-OHG SCHULZE-GMBH) ==> * S T A C K * PUSH! (LAMBDA (OBJEKT) ( S E T ! * S T A C K * (CONS OBJEKT * S T A C K * ) ) " D u r c h g e f ü h r t ! " ) ) = = > PUSH! ( D E F I N E POP! (LAMBDA ( ) (BEGINO (CAR * S T A C K * ) ( S E T ! * S T A C K * (CDR * S T A C K * ) ) ) ) ) = = > POP! (PUSH! 'MEYER-AG) ==> "Durchgeführt!" (POP!) ==> MEYER-AG ( P O P ! ) ==> MUELLER-OHG

Wird beim BEGIN-Konstrukt eine Sequenz von symbolischen Ausdrücken notiert, die keine Nebeneffekte bewirken, dann ist nur die Auswertung des letzten symbolischen Ausdruckes notwendig. Die Auswertung aller vorhergehenden Ausdrücke ist einsparbar. Bei effizienten LISP-Implementationen wird diese Optimierungsmöglichkeit genutzt, so auch bei PC Scheme. eval>

(BEGIN

(CDR

*STACK*)

(CDR

(CDR (CDR

*STACK*)) (CDR (CDR

*STACK*))))

==>

()

Dieses BEGIN-Beispiel läßt sich auf den folgenden Ausdruck optimieren: eval>

(CDR

(CDR

(CDR

*STACK*)))

==>

()

2.2.2 Selektion Umfaßt ein Modul zwei oder mehr Teile, von denen im Anwendungsfall nur ein Teil zutrifft, dann ist eine Selektion (Auswahl) abzubilden. Das Bild 2.2.2-1 zeigt für den symbolischen Ausdruck GESAMT eine Selektion in Jackson-Notation (vgl. Jackson, 1979). Sein Wert ergibt sich entweder aus dem Modul ALTERNATIVE-1 oder ALTERNATIVE-2 oder ALTERNATIVE-3. Der Kreis in der rechten oberen Ecke unterscheidet die Selektion von der Sequenz. Für die Abbildung bietet sich das COND-Konstrukt an. Liegt nur eine Selektion zwischen zwei Strukturen vor, ist das IF-Konstrukt geeignet (vgl. Programmfragment 2.2.1-3). Anhand der Entscheidungstabelle (engl.: decision table), die Bild 2.2.2-2 darstellt, erörtern wir die Selektion. Eine Entscheidungstabelle (kurz ET) besteht aus einem Bedingungsteil und einem Aktionsteil. Die Bedingungen (im Beispiel B l , B2, B3 und B4) werden für den SelektionsVorgang der Reihe nach auf ihren Wahrheitswert hin geprüft. Die Regeln (im Beispiel R l , R2 bis R7) verknüpfen

2. Kombinieren von Konstrukten

59

den Bedingungsteil mit dem Aktionsteil. Sie dokumentieren, bei welchen Wahrheitswerten welche Aktionen (im Beispiel AI, A2 bis A5) durchzuführen sind. Trifft stets nur eine Regel nach Prüfung der Bedingungen zu, dann handelt es sich um eine Eintreffer-ET, andernfalls um eine Mehrtreffer-ET (vgl. z.B. Bild 11.3-1). Beschränken sich die Wahrheitswerte auf „Ja" (Abkürzung "J"), „Nein" (Abkürzung „N") und „Irrelevant" (Abkürzung „-"), dann handelt es sich um eine begrenzte ET; begrenzt, weil die Definition der Bedingungen sich nicht in den Regelanzeigerteil hineinzieht. Eine „ET Verkehrsampel" mit Zuständen wie „ROT", "GELB" und „GRÜN" als Angaben in den Regeln wäre nicht begrenzt.

Für eine begrenzte ET wird folgende Notation verwendet (vgl. DIN 66241): o im Entscheidungsteil: J

: : = Die Bedigung i s t

N

: : = Die Bedingung i s t

#

erfüllt. nicht

erfüllt.

: : = Die Anwendung der Regel i s t n i c h t davon a b h ä n g i g , ob d i e Bedingung e r f ü l l t oder n i c h t e r f ü l l t i s t . Man kann d i e s e s Z e i c h e n a l s Dokumentation der I r r e l e v a n z bet r a c h t e n . Die Bedingung kann g e p r ü f t werden, nur i s t das P r ü f u n g s e r g e b n i s u n e r h e b l i c h . ::= Ausschlußanzeiger, d.h. für die Entscheidung i s t die Bedingung n i c h t d e f i n i e r t ; i h r W a h r h e i t s w e r t kann n i c h t e r m i t t e l t werden. ( I s t h i e r wegen der V o l l s t ä n d i g k e i t angegeben und w i r d im B e i s p i e l n i c h t v e r wendet .)

o im Aktionsteil. X blank

: : = Die A k t i o n i s t

durchzuführen,

: : = Die A k t i o n i s t

nicht

durchzuführen.

60

I. Konstrukte (Bausteine zum Programmieren)

ET-Auszahlung-buchen

Rl

R2 R3

R4 R5

R6 R7

B1

Kontonummer

angegeben?

J

J

J

J

N

N

N

B2

Kontonummer

= 50.00

40000 DM

genannt? vorlegen

X X

Konto

Vorgang abgeben

an A b t e i l u n g

Buchung

vollziehen

Formale

X

X 2 X X

X

X

Vol1ständigkeitsüberprüfung:

2 e i n w e r t i g e R e g e l n (R2 u n d R3) 3 z w e i w e r t i g e R e g e l n (Rl, R6 u n d 2 v i e r w e r t i g e R e g e l n (R4 u n d R5)

R7)

— > — > — >

Summe: Bild

X

2.2.2-2.

Begrenzte

2 6 8 16

Fälle Fälle Fälle Fälle =

24-Regeln

Eintreffer-Entscheidungstabel1e

Bei einer begrenzten Eintreffer-Entscheidungstabelle ist feststellbar, ob für alle möglichen Bedingungskombinationen auch Regeln genannt sind (formale Vollständigkeit). Bei einer solchen ET mit 4 Bedingungen sind 24-Regeln notwendig, wenn nur die Wahrheitswerte „J" und „N" verwendet werden. Enthält die ET Regeln mit Irrelevanz-Zeichen („-"), dann können diese „mehrwertigen" Regeln leicht auf mehrere „einwertige" zurückgeführt werden (vgl. Bild 2.2.2-2). Die ET-Auszahlung-buchen im Bild 2.2.2-2 definiert, welche Aktionen in einem „aktuellen" Fall durchzuführen sind. Um die Daten eines „aktuellen" Falles zu erhalten, wird eine einfache Dialogschnittstelle konstruiert. Dazu verwenden wir das READ-Konstrukt und das WRITELN-Konstrukt. Bei einer Antwort „N" für die Bedingung B1 ist es nicht mehr entscheidungsrelevant, den „aktuellen" Wert der Bedingung B2 zu erfragen. Es sollten daher nicht die aktuellen Werte aller Bedingungen der Reihe nach abgefragt werden. Ist eine Bedingung nicht relevant für den weiteren Auswahlprozeß zur Bestim-

61

2. Kombinieren von Konstrukten

mung der zutreffenden Regel, dann ist sie zu übergehen. Anders formuliert: Um ungewollte Nebeneffekte (hier: Abfragen) zu vermeiden, dürfen irrelevante Bedingungen nicht evaluiert werden. ;;;; ;;;;

Begrenzte E i n t r e f f e r - E n t s c h e i d u n g s t a b e l 1 e ET-AUSZAHLUNG-BUCHEN

; ;;;

Bedingungen

e v a l > ( D E F I N E B1 (LAMBDA ( ) (WRITELN " I s t d i e Kontonummer a n g e g e b e n ? ( J / N ) " ) ( R E A D ) ) ) = = > B1 e v a l > ( D E F I N E B2 (LAMBDA ( ) (WRITELN " I s t d i e Kontonummer k l e i n e r g l e i c h 4 0 0 0 0 ? ( J / N ) " ) ( R E A D ) ) ) = = > B2 e v a l > ( D E F I N E B3 (LAMBDA ( ) (WRITELN " I s t d e r B e t r a g g r o e s s e r g l e i c h 5 0 . 0 0 DM ? ( J / N ) " ) ( R E A D ) ) ) = = > B3 e v a l > ( D E F I N E B4 (LAMBDA ( ) (WRITELN " I s t der Zweck a n g e g e b e n ? ( J / N ) " ) ( R E A D ) ) ) = = > B4 ;;;; eval> eval> eval> eval> eval> ;; ;; eval>

Aktionen ( D E F I N E A I (LAMBDA ( ) (WRITELN "Dem C h e f v o r l e g e n " ) ) ) = = > A I ( D E F I N E A2 (LAMBDA ( ) (WRITELN " Z u r u e c k an d i e F a c h a b t e i l u n g s c h i c k e n " ) ) ) = = > A2 ( D E F I N E A3 (LAMBDA ( ) (WRITELN " U m k o n t i e r e n a u f K o n t o S O N S T I G E S " ) ) ) = = > A3 ( D E F I N E A4 (LAMBDA ( ) (WRITELN " V o r g a n g an A b t e i l u n g 2 a b g e b e n " ) ) ) = = > A4 ( D E F I N E A5 (LAMBDA ( ) (WRITELN " B u c h u n g v o l l z i e h e n " ) ) ) = = > A5 Regeln (DEFINE ET-AUSZAHLUNG-BUCHEN (LAMBDA ( ) (COND ( ( E Q ? ( B l ) ' J ) (COND ( ( E Q ? ( B 2 ) ' J ) (COND ( ( E Q ? ( B 4 ) ' J ) ( A 5 ) ) (T (COND ( ( E Q ? ( B 3 ) ' J ) ( A D ) (T ( A 3 ) ( A 5 ) ) ) ) ) ) (T ( A 4 ) ) ) ) (T (COND ( ( E Q ? ( B 3 ) ' J ) ( A 2 ) ) (T (COND ( ( E Q ? ( B 4 ) ' J ) (A3) (A5)) (T ( A D ) ) ) ) ) ) ) ) = = > ET-AUSZAHLUNG-BUCHEN

; ; ; ; Zwei B e i s p i e l e ;;; Benutzerantworten

in

Fettdruck

e v a l > (ET-AUSZAHLUNG-BUCHEN) = = > I s t d i e Kontonummer a n g e g e b e n ? ( J / N ) J I s t d i e Kontonummer k l e i n e r g l e i c h 4 0 0 0 0 V o r g a n g an A b t e i l u n g 2 abgeben ()

?

(J/N)

N

62

I. Konstrukte (Bausteine zum Programmieren)

eval> (ET-AUSZAHLUNG-BUCHEN) ==> Ist d i e K o n t o n u m m e r a n g e g e b e n ? ( J / N ) N Ist d e r B e t r a g g r o e s s e r g l e i c h 5 0 . 0 0 DM ? ( J / N ) N Ist d e r Z w e c k a n g e g e b e n ? ( J / N ) N Dem Chef vorlegen () P r o g r a m m f r a g m e n t 2 . 2 . 2 - 1 . Abbildung der ET von Bild 2.2.2-2 - B e d i n g u n g e n und A k t i o n e n a u ß e r h a l b des K o n s t r u k t e s E T - A U S Z A H L U N G - B U C H E N als F u n k t i o n e n d e f i n i e r t -

Die obige Lösung wirft die Frage auf: Kann eine tiefe Schachtelung von CONDKonstrukten durch Nutzung der logischen Verknüpfungen AND und OR vermieden werden? Zunächst erläutern wir diese logischen Verknüpfungen, indem wir sie für zwei Argumente (engl.: binary predicates) mit dem COND-Konstrukt abbilden. eval>

(DEFINE MEIN-AND (LAMBDA (ARG_1 ARG_2) (COND (ARG_1 ARG_2) (T N I L ) ))) = = > M E I N - A N D

;1. ;2.

Klausel Klausel

Ist ARG_ 1 wahr, d.h. ist ARG_ 1 an einen Wert ungleich NIL gebunden, dann wird die 1. Klausel des COND-Konstruktes ausgeführt. Es wird der Wert von ARG_ 2 festgestellt und als Wert von MEIN-AND zurückgegeben. Da ARG_ 1 wahr ist, entscheidet ARG_ 2, ob die AND-Verknüpfung insgesamt wahr ist. Ist ARG_ 1 jedoch gleich NIL, d.h. nicht wahr, dann kann sofort (ohne den Wert von ARG_2 nachzufragen) das gesamte AND-Konstrukt den Wert NIL erhalten. Analog dazu ist das OR-Konstrukt für zwei Argumente formulierbar: eval>

(DEFINE MEIN-OR (LAMBDA (ARG_1 ARG_2) ( C O N D ( A R G _ 1 T) (T A R G _ 2 ) ) ) ) = = >

MEIN-OR

Wir können die Definition von MEIN-OR noch kürzer formulieren. eval>

(DEFINE MEIN-OR (LAMBDA (ARG_1 ARG_2) (COND (ARG_1) (ARG_2))))

==>MEIN-0R

Bei dieser Definition nutzen wir die Möglichkeit, eine Klausel nur mit dem symbolischen Ausdruck für das Prädikat zu definieren (vgl. Abschnitt 2.1). Ist sein Wert ungleich NIL hat das gesamte COND-Konstrukt diesen Wert. Solche Notationen können für „Denkübungen" formuliert werden. Wir sollten jedoch genau prüfen, wann sie im Praxiseinsatz zweckmäßig sind.

63

2. Kombinieren von Konstrukten

/Exkurs: AND (bzw. OR) und CAND (bzw. COR). Die obigen Definitionen verweisen auf die in der Informatik gebräuchliche Unterscheidung zwischen AND (bzw. OR) und CAND (bzw. COR). Bei AND bzw. OR sind beide Argumente auszuwerten, auch wenn der logische Wert sich aus dem ersten ergibt (TRUE bei OR bzw. FALSE bei AND). Grund: Mögliche Nebeneffekte der Operanden sollen ausgeführt werden. Bei CAND und COR will man diese möglichen Nebeneffekte vermeiden, z.B. damit folgende Formulierung zu keiner Division durch 0 führt: (COR ( = 0 X)

(>

(/ 1 X)

7))

; b e i X = 0 kommt der z w e i t e ; n i c h t zur Ausführung

Teil

Für die logische Verknüpfung von A mit B können wir definieren: CAND : : = AND ::= COR ::= OR ::=

(COND (COND (COND (COND

(A B) (T N I L ) ) ( A B ) (B N I L ) (T N I L ) ) (A T) (T B ) ) (A B T) (B T ) (T N I L ) )

]

Die in PC Scheme eingebauten AND- und OR-Konstrukte entsprechen CANDund COR-Konstrukten, die nicht auf zwei Argumente beschränkt sind; sie können beliebig viele Argumente haben. eval>

(AND 1 2 3 4 5 6) = = > 6

eval>

(AND T ( )

eval>

(OR (OR (OR 1 N I L )

(8 1 2 ) )

==>

;wahr, ()

da a l l e

Werte u n g l e i c h

NIL

obwohl d a s 3 . A r g u m e n t n i c h t a u s w e r t b a r i s t , da 8 k e i n e n Operator a b b i l d e n kann.

(AND 2 N I L ) )

3) ==> 1

Die Negation eines Wahrheitswertes, das NOT-Konstrukt, läßt sich ebenfalls auf das COND-Konstrukt zurückführen: eval> eval> eval> eval>

( D E F I N E MEIN-NOT (LAMBDA (ARG) (COND (ARG N I L ) (MEIN-AND ' J A ' ( ) ) ==> () ( M E I N - O R ' ( ) ' J A ) ) = = > JA ( M E I N - N O T 5) = = > ( )

(T T ) ) ) )

==>

MEIN-NOT

/Hinweis: NOT und NULL?. Da NIL die leere Liste und den Wahrheitswert „false" repräsentiert, haben die Funktionen NOT und NULL? stets den gleichen Wert. Im Sinne einer überschaubaren Konstrukte-Menge könnten wir auf ein Konstrukt verzichten. Zur besseren Lesbarkeit verwenden wir trotzdem beide: Das NULL?-Konstrukt zum Prüfen einer leeren Liste und das NOT-Konstrukt, wenn es um den Wahrheitswert „false" geht, eval>

(DEFINE

NULL?

(LAMBDA

(LISTE)

(EQ?

LISTE N I L ) ) )

= = > NULL?

]

Wie dargelegt, wird in Scheme die Auswertung von OR beim ersten Wert ungleich NIL beendet, das gesamte OR-Konstrukt hat diesen Wert. Die Aus-

64

I. Konstrukte (Bausteine zum Programmieren)

wertung von AND wird beim ersten Wert NIL beendet, das gesamte ANDKonstrukt hat NIL als Wert. Das AND- und das OR-Konstrukt sind damit noch nicht vollständig spezifiziert. AND und OR können in einigen LISP-Systemen, z.B. in Scheme, auch ohne Argument angewendet werden. AND ohne Argument gibt den Wert #T zurück, weil kein Argument als kein falsches Argument interpretiert wird. OR ohne Argument führt zu NIL, da kein Argument als kein wahres Argument interpretiert wird. eval> (AND) ==> #T eval> (OR) ==> () Man könnte spontan mit AND-Konstrukten die ET (Bild 2.2.2-2) nach der „Regel-für-Regel-Programmierung" folgendermaßen notieren: eval> (DEFINE ET-AUSZAHLUNG-BUCHEN (LAMBDA () (COND : Regel 1 (AND (Bl) ( B2 ) ( B4 ) ) ( A5 ) ) : Regel 2 (AND (Bl) ( B2 ) ( B3 ) (NOT ( B4 ) ) ) (AI) ) ; Regel 3 (AND (Bl) (B2) (NOT ( B3 ) ) (NOT (B4) )) (A3) (A5) ; Regel 4 (AND (Bl) (NOT (B2 ) ) ) (A4) ) ; Regel 5 (AND (NOT (Bl)) ( B3 ) ) (A2) ) ; Regel 6 (AND (NOT (Bl)) (NOT ( B3 ) ) ( B4) ) (A3) (A5)) ; Regel 7 (AND (NOT (Bl)) (NOT ( B3 ) ) (NOT (B4) ) ) (AI)))) ) ==> ET-AUSZAHLUNG-BUCHEN Die Mängel dieser „Regel-für-Regel-Programmierung" sind: o das Nichtberücksichtigen des aktuellen Wertes einer Bedingung für die Auswahl der nächsten Bedingung und o das wiederholte Abfragen von Bedingungen (Wiederholtes Erzeugen der Nebeneffekte!). Beispielsweise fragt das obige Konstrukt ET-AUSZAHLUNG-BUCHEN siebenmal nach der Kontonummer, wenn die Regel R7 zutrifft. Um zumindest nicht jeweils über die Benutzerschnittstelle erneut die Eingaben abzufordern, d.h. die Nebeneffekte der Bedingungen zu vollziehen, könnten die Bedingungen statt als LAMBDA-Konstrukte direkt als Wahrheitswert definiert werden: eval> (DEFINE B1 (BEGIN (WRITELN " I s t die Kontonnummer angegeben? (J/N)") (READ))) ==> B1 Damit wird die Eingabe allerdings schon zum Zeitpunkt der Definition der Be-

2. Kombinieren von Konstrukten

65

dingung gefordert. Eine Zeitpunktverschiebung der Auswertung wäre erforderlich (Näheres vgl. Abschnitt 2.3). Für komplexe Fallunterscheidungen gibt es im allgemeinen weitere eingebaute Konstrukte, die gegenüber geschachtelten COND-Konstrukten eine vereinfachte Notation ermöglichen. Ein Beispiel ist das CA5£-Konstrukt (auch in PC Scheme vorhanden). Es erlaubt die Angabe von „Treffern" in einer Liste. Definiert ist es, wie folgt: eval > (CASE

{(

{}

)}

) — >

Zunächst wird der Ausdruck ausgewertet. Sein Wert wird sukzessiv mit jedem verglichen, wobei nicht evaluiert wird! Das CASE-Konstrukt heißt deshalb konsequenterweise bei einigen LISP-Systemen SELECTQ (z.B. in TLC-LISP), wobei Q für QUOTE steht. Die Art des Vergleiches wird vom Typ des -Ausdruckes bestimmt. Ist eine Liste, dann wird jedes Element mit dem Wert von verglichen. Ist ein Symbol außer ELSE, dann wird Identität bzw. Wertgleichheit bei Zahlatomen, Strings etc. geprüft. Ist das Symbol ELSE, dann ist der Vergleich sofort erfolgreich. Bei einem erfolgreichen Vergleich stoppt der Vergleichsprozeß, und die zugehörende Sequenz der wird evaluiert. Der Wert des CASE-Konstruktes ist der Wert des zuletzt evaluierten Ausdrucks (entspricht der Definition des COND-Konstruktes). Beispiel: eval>

eval>

CASE- und

COND-Konstrukt

( D E F I N E ZUSTIMMUNG? (LAMBDA ( ) (CASE (READ) ( ( J J A JAWOHL JAWOLL Y Y E S KLAR Z U S T I M M U N G G E W I S S SICHER F R E I L I C H SELBSTREDEND SELBSTVERSTAENDLICH A L L E R D I N G S GERN X T TRUE O U I Q U I T S I ) # T ) ( E L S E N I L ) ) ) = = > ZUSTIMMUNG? ( D E F I N E ZUSTIMMUNG? (LAMBDA ( ) ( L E T ((ANWORT ( R E A D ) ) ) (COND ( ( O R ( E Q ? ANWORT ' J ) ( E Q ? ANWORT ' J A ) ( E Q ? ANWORT ' J A W O H L )

(EQ? (T eval>

(ZUSTIMMUNG?)

ANWORT

NIL)))))

==>

'SI)

#T)

ZUSTIMMUNG?

==>

JAWOHL

¡Eingabe

#T

¡Wert

/Hinweis: CASE-und COND-Implementation. Beide Konstrukte basieren in PC Scheme auf dem IF-Konstrukt. Sie sind eine syntaktische Vereinfachung. Die

66

I. Konstrukte (Bausteine zum Programmieren)

folgende EXPAND-MACRO-Anwendungen zeigen, wie CASE- und COND als Makros definiert sind (Näheres zu Makros vgl. Abschnitt 8.3) eval>

eval>

(EXPAND-MACRO ' ( C A S E (READ) ( ( J ((LAMBDA UOOOOO) ( I F (MEMV % 0 0 0 0 0 ' ( J J A ) ) (BEGIN 1 2 ) (BEGIN 3 4 ) ) ) (READ)) (EXPAND-MACRO (IF

'(COND

JA)

1 2)

(ELSE

3 4)))

==>

¡Das M E M V - K o n s t r u k t p r ü f t , ; ob d e r W e r t v o n % 0 0 0 0 0 ; Element der L i s t e (J JA) ; ist.

((EQ? 'J (READ)) ( T 3 4 ) ) ) ==>

1 2)

(EQ? ' J (READ)) (BEGIN 1 2) (COND

(T 3 4 ) ) )

7

2.2.3 Iteration Eine Iteration (auch Répétition genannt) ermöglicht das wiederholte Durchlaufen bzw. Anwenden eines Konstruktes. Bild 2.2.3-1 zeigt die graphische Darstellung einer Iteration in Jackson-Notation (vgl. Jackson, 1979). Der Modul GESAMT besteht aus einer beliebig langen Folge von Moduln WIEDERHOLUNGS-TEIL. Dabei ist zu beachten: o GESAMT ist die Iteration und o die Häufigkeit des Auftretens von WIEDERHOLUNGS-TEIL ist eine Eigenschaft von GESAMT und nicht von WIEDERHOLUNGS-TEIL. Der Stern in der rechten oberen Ecke dokumentiert das mehrfache Auftreten von WIEDERHOLUNGS-TEIL innerhalb von GESAMT. Eine Iteration wird beendet: o entweder durch Zutreffen einer Abbruchbedingung, wobei die Ereignisprüfung vor oder nach einem Durchlauf erfolgen kann, o oder nach Vollzug einer vor Beginn der Iteration festgelegten Anzahl von Durchläufen. In vielen Programmiersprachen werden zur Kennzeichnung einer Iteration Bezeichner wie DO, WHILE, REPEAT, UNTIL oder FOR benutzt. In LISP lassen sich entsprechende Konstrukte definieren, falls diese im jeweiligen LISP-System nicht als eingebaute Konstrukte zur Verfügung stehen. Charakteristisch für LISP ist die Konstruktion einer Iteration in Form einer rekursiven Definition. Iterationen können als Spezialfälle der Rekursion betrachtet werden. Rekursive Darstellungen sind für LISP prägend, z.B. sind sowohl die Syntax als auch die Semantik der symbolischen Ausdrücke rekursiv definiert (vgl. Abschnitte 1.1 und 1.2). Wegen ihrer großen Bedeutung ist der Rekursion in diesem Kapitel ein eigener Abschnitt gewidmet.

2. Kombinieren von Konstrukten

67

In L I S P unterscheiden wir im Zusammenhang mit Wiederholungsstrukturen drei Abbildungskonzepte: o die üblichen Iterationskonstrukte, z.B. das DO-Konstrukt, o die Anwendung von MAP-Konstrukten („mapping functions") und o die Iteration als Spezialfall der Rekursion. Zunächst behandeln wir als bedingte Wiederholung das DO-Konstrukt. Nach diesem vielfältig nutzbaren Iterationskonstrukt wird die „klassische" Iteration mit MAP-Konstrukten erläutert. MAP-Konstrukte realisieren die Iteration, indem sie eine Funktion wiederholt auf eine Liste von Argumenten anwenden. Das DO-Konstrukt gliedert sich in drei Definitionsbereiche: (DO ( Zuständsvariablen ( Endebehandlung ) Verarbeitungskörper

) )

Zustandsvariablen: Die Definition einer Zustandsvariablen gliedert sich in die folgenden drei Teile:

: : = Namen der

: : = S y m b o l i s c h e r A u s d r u c k , an d e s s e n Wert d i e < v a r i a b l e > zu B e g i n n der I t e r a t i o n gebunden w i r d . Es h a n d e l t s i c h um den I n i t i a l w e r t f ü r .

Variablen

die

: : = S y m b o l i s c h e r A u s d r u c k , der bei j e d e r W i e d e r h o l u n g e v a l u i e r t w i r d und an d e s s e n Wert < v a r i a b l e > gebunden w i r d . Es h a n d e l t s i c h um den I t e r a t i o n s w e r t ( I n k r e m e n t oder Dekrement) f ü r die .

Endebehandlung-.

Die Definition der Endebehandlung entspricht einer Klausel

des COND-Konstruktes: Zuerst wird die Abbruchbedingung evaluiert und, falls ihr Wert ungleich N I L ist, wird die Sequenz von symbolischen Aus-

68

I. Konstrukte (Bausteine zum Programmieren)

drücken ... der Reihe nach von links nach rechts evaluiert. Der zuletzt ermittelte Wert ist der Wert des gesamten DOKonstruktes. Verarbeitungskörper. Eine Sequenz von symbolischen Ausdrücken, ... , die der Reihe nach ausgewertet werden. Sie dienen auch zur Manipulation der Variablen und des Abbruchtestes. Der Rückgabewert des DO-Konstruktes wird nur durch die Endebehandlung definiert. Die Definitionsbereiche müssen nicht zwingend einen symbolischen Ausdruck aufweisen. Das DO-Konstrukt ist, wie folgt, definiert: eval>

(DO ( { ( < v a r i a b l e > { < i n i t _ s e x p r > { < i t e r _ s e x p r > } } ( {} ) {} ) ==>

)} )

Anhand von zwei Beispielen zeigen wir die Arbeitsweise und Wirkung des DOKonstruktes. Zunächst bilden wir eine Zählschleife ab, indem wir den Satz „LISP hat ein dia-logisches Konzept" siebenmal schreiben. Danach summieren wir alle Elemente einer Liste, vorausgesetzt, es handelt sich um Zahlen. Beispiel: Siebenmal dieselbe Zeichenkette ausgeben Lösung 1\ Zählschleife mit Verarbeitung im eval>

LISP LISP LISP LISP LISP LISP LISP #T

(DO

hat hat hat hat hat hat hat

( ( Z A E H L E R 7 (- Z A E H L E R 1 ) ) ) ((= 0 ZAEHLER)) (WRITELN "LISP hat ein d i a - l o g i s c h e s K o n z e p t ! " ) ) ein d i a - l o g i s c h e s Konzept! ein d i a - l o g i s c h e s Konzept! ein d i a - l o g i s c h e s Konzept! ein d i a - l o g i s c h e s Konzept! ein d i a - l o g i s c h e s Konzept! ein dia-logisches Konzept! ein dia-logisches Konzept! ; R ü c k g a b e w e r t = Wert des A u s d r u c k s ( = 0 ZAEHLER)

==>

Lösung 2: Zählschleife mit Verarbeitung im eval>

LISP

#T

(DO

((ZAEHLER

7 (BEGIN (WRITELN "LISP hat ein d i a - l o g i s c h e s (- Z A E H L E R 1)))) ((= 0 Z A E H L E R ) ) ) = = > hat ein d i a - l o g i s c h e s K o n z e p t !

Konzept!")

2. Kombinieren von Konstrukten

69

Lösung 3: Zählschleife mit Verarbeitung im -Ausdruck eval>

LISP

(DO

hat

((ZAEHLER 6 ( - ZAEHLER 1 ) ) ) ( ( B E G I N (WRITELN " L I S P hat ein d i a - 1 o g i s c h e s (= 0 ZAEHLER)))) ==> ein dia-logisches Konzept!

Konzept!")

#T Die Lösungen 2 und 3 stellen eine „trickreiche" Nutzung des DO-Konstruktes dar. Sie sind weniger transparent als die Lösung 1. Hier sind sie nur zum Verstehen des DO-Konstruktes formuliert. Unstrittig ist die Lösung 1 den beiden Lösungen 2 und 3 vorzuziehen. Sie hat die vom Leser (gewohnte) einfache DOStruktur und wird daher schneller verstanden.

Beispiel: Zahlen in einer Liste summieren Lösung 1: Aufaddieren der Zahlen im Verarbeitungskörper des DO-Konstruktes eval>

eval>

( D E F I N E SUMME-DER-ZAHLEN (LAMBDA ( L ) (DO ( ( L I S T E L ( C D R L I S T E ) ) (AKKUMULATOR 0 ) ) ¡ H i l f s v a r i a b l e f ü r d a s E r g e b n i s ( ( N U L L ? (CAR L I S T E ) ) AKKUMULATOR) ¡Endebedingung (COND ( ( N U M B E R ? ( C A R L I S T E ) ) ( S E T ! AKKUMULATOR ( + AKKUMULATOR ( C A R L I S T E ) ) ) ) (T " N a e c h s t e s Listenelement"))))) ==> SUMME-DER-ZAHLEN (SUMME-DER-ZAHLEN ' ( A 3 B 1 C 2 ) ) ==> 6

Lösung 2: Aufaddieren der Zahlen im Iterationsteil des DO-Konstruktes eval>

( D E F I N E SUMME-DER-ZAHLEN (LAMBDA (DO ( ( L I S T E L ( C D R L I S T E ) ) (AKKUMULATOR

(L)

0

(COND

eval>

((NUMBER? (CAR L I S T E ) ) ( + AKKUMULATOR ( C A R L I S T E ) ) ) (T " N a e c h s t e s Listenelement" AKKUMULATOR)))) ( ( N U L L ? (CAR L I S T E ) ) A K K U M U L A T O R ) ) ) ) ==> SUMME-DER-ZAHLEN ( S U M M E - D E R - Z A H L E N ' ( 1 2 3 4 A B C D ) ) = = > 10

/Hinweis: DO-Implementation. Anhand der DO-Implementation wird deutlich, daß die Iteration mit dem DO-Konstrukt sich auf die Rekursion mittels L E T R E C abstützt. Wie das LET-Konstrukt (vgl. Abschnitt 2.2.1), so ist auch das DOKonstrukt in PC Scheme als Makro-Konstrukt (vgl. Abschnitt 8.3) realisiert. Analog zum BEGINO-Makro (vgl. Abschnitt 2.2.1) wird auch hier eine lokale Variable generiert. Mit Hilfe des EXPAND-MACRO-Konstruktes ist das Ergebnis des Expandierens darstellbar. Dabei formulieren wir die der obigen DO-Definition als Zeichenketten:

70

I. Konstrukte (Bausteine zum Programmieren)

eval> (DEFINE F00 (EXPAND-MACRO '(DO ((V -1 "" "") C V-2 "" "")) ((OR (EQ? V-l 'ENDE) (EQ? V-2 'ENDE)) "" "") ""))) ==> FOO eval> FOO ==> ((LETREC ((%00000 (LAMBDA (V-l V-2) (IF (OR (EQ? V-l 'ENDE) (EQ? V-2 'ENDE)) (BEGIN "" "") (BEGIN "" (%00000 "" "")))))) %00000) "" "") Zum Verständnis-Training expandieren wir die Lösungen 1 und 3 des obigen Beispiels „Siebenmal eine konstante Zeichenkette ausgeben": eval> (EXPAND-MACRO '(DO ((ZAEHLER 7 (- ZAEHLER 1))) ((= 0 ZAEHLER)) (WRITELN "LISP hat ein dia -1ogisches Konzept!") )) ==> ((LETREC («00000 (LAMBDA (ZAEHLER) (LET ( « 0 0 0 0 1 (= 0 ZAEHLER))) (IF %00001 %00001 (BEGIN (WRITELN "LISP hat ein dia-1ogisches Konzept!") «00000 (- ZAEHLER 1 ) ) ) ) ) ) ) ) %00000) 7) eval> (EXPAND-MACRO (DO ((ZAEHLER 6 (- ZAEHLER 1))) ((BEGIN (WRITELN "LISP hat ein dia -1ogisches Konzept!") (= 0 ZAEHLER))) )) ==> ((LETREC («00000 (LAMBDA (ZAEHLER) (LET («00001 (BEGIN (WRITELN "LISP hat ein dia -1ogisches Konzept!") (= 0 ZAEHLER)))) (IF %00001 %00001

%00000)

6)

(BEGIN «00000 (- ZAEHLER 1 ) ) ) ) ) ) ) )

]

2. Kombinieren von Konstrukten

71

Im Rahmen des Entwurfes von linearen Kontrollstrukturen werden Iterationen oft in der von I. Nassi und B. Shneiderman 1973 vorgeschlagenen Form dargestellt (vgl. Bild 2.2.3-2). Die Iteration mit der Bedingungsprüfung vor jedem Wiederholungsdurchlauf wird auch abweisende Schleife oder salopp: „kopfgesteuerte" Schleife genannt. Sie ist zu unterscheiden von der Iteration mit der Bedingungsprüfung nach jedem Wiederholungsdurchlauf. Diese wird als nichtabweisende Schleife oder salopp: „fußgesteuerte" Schleife bezeichnet. Im ersten Fall, dem while-Konstrukt, wird so lange wiederholt, bis die Bedingung erfüllt ist. Im zweiten Fall, dem until-Konstrukt, wird der Wiederholungsvorgang beendet, wenn die Bedingung erfüllt ist.

GESAMT

GESAMT

Wiederholung mit vorausgehender Bedingungsprüfung (kurz: w h i l e - K o n s t r u k t )

Wiederholung mit nachfolgender Bedingungsprüfung (kurz: until-Konstrukt)

Notiert whi1 e p do Bild

B od

2.2.3-2.

in e i n e m

Pseudocode: do B until

q

od

Bedingte Schleifen - Graphische Darstellung n a c h DIN 6 6 2 6 1 (Struktogramm, vgl. N a s s i / S h n e i d e r m a n , 1973)

In den beiden folgenden Beispielen wird die Situationsänderung für die Bedingungsprüfung über Zufallszahlen bewirkt. Das RANDOM-Konstmkt gibt als Wert Pseudozufallszahlen zurück und zwar in dem Wertebereich von Null bis Wert des Argumentes minus 1. eval>

(RANDOM

5) = = >

3

Beispiele: Bedingte Schleifen eval> eval> eval>

;0 < = P s e u d o z u f a l 1 s z a h l

< 5

(while-/until-Konstrukte)

(DEFINE BLOCK ( L A M B D A () ( W R I T E L N " B l o c k v e r a r b e i t e t " ) ) ) = = > B L O C K (DEFINE WIEDERHOLUNGS-BEDINGUNG ( L A M B D A () (< ( R A N D O M 5) 3 ) ) ) = = > W I E D E R H O L U N G S - B E D I N G U N G (DEFINE ABBRUCH-BEDINGUNG ( L A M B D A () ( N O T ( W I E D E R H O L U N G S - B E D I N G U N G ) ) ) )

72

I. Konstrukte (Bausteine zum Programmieren)

e v a l > (DEFINE W H I L E - B E I S P I E L (LAMBDA ( ) (DO ((P (WIEDERHOLUNGS-BEDINGUNG) (WIEDERHOLUNGS-BEDINGUNG))) ((NOT P)) ( B L O C K ) ) ) ) ==> WHILE-BE I S P I EL

==> ABBRUCH-BEDINGUNG Bedi ngung D O - I n i t i a l i s i e rung D O - I t e r a t i onswert DO-Exit-Bedingung

e v a l > (DEFINE U N T I L - B E I S P I E L (LAMBDA ( ) (DO ((Q NIL ; Um BLOCK zumindest einmal (ABBRUCH-BEDINGUNG))) (Q) ; DO-Exit-Bedingung ( B L O C K ) ) ) ) ==>

abzuarbeiten.

e v a l > (WHILE-BEI S P I EL) ==> Block v e r a r b e i t e t Block v e r a r b e i t e t #T ¡Rückgabewert der Bedingung (NOT P) e v a l > (WH I LE - BEI S P I EL) ==>

#T

e v a l > ( U N T I L - B E I S P I EL) ==> Block v e r a r b e i t e t Block v e r a r b e i t e t Block v e r a r b e i t e t Block v e r a r b e i t e t #T ¡Rückgabewert der Bedingung

(Q)

e v a l > (SET! WI ED ERHOLUNGS-BED 1NGUNG (LAMBDA () N I L ) ) ==> NIL e v a l > (WHILE - BEI S P I EL) ==> #T e v a l > ( U N T I L - B E I SP I EL) ==> Block v e r a r b e i t e t #T

Das obige Konstrukt UNTIL-BEISPIEL entspricht einer Sequenz aus BLOCK und anschließendem while-Konstrukt. Die Beziehungen zwischen while- und until-Konstrukten zeigt Bild 2.2.3-3. Aufgrund der Listen-Dominanz bezieht sich in LISP die Wiederholung häufig auf die Abarbeitung aller Elemente einer Liste. Ist eine Funktion auf jedes Element einer Liste anzuwenden, dann bilden wir diese Iteration mit einem A/Af-Konstrukt („mapping function") ab. LISP-Systeme haben ein ganzes Bündel von „mapping functions". Einige sammeln die Werte der wiederholten Funktionsapplikation und geben diese als Wert zurück, andere führen die Funktionsapplikation nur zur Erzielung von Nebeneffekten durch; ihr Rückgabewert ist unerheblich. eval> (

) — >

2. Kombinieren von Konstrukten

73

mit

::= A b h ä n g i g v o n d e r j e w e i l i g e n < m a p p i n g function> entsteht ein Rückgabewert. Stets wird die A p p l i k a t i o n der < u s e r - f u n c t i o n > auf d i e e i n z e l n e n A r g u m e n t e von < a r g u m e n t s > durchgeführt : ( ) ==>

(

)

==>

G e g e b e n e n f a l l s w i r d a n s c h l i e ß e n d aus < v a l u e _ l > bis < v a l u e _ n > der R ü c k g a b e w e r t gebildet, z.B. eine Liste.

Fall

1: Unti 1 - K o n s t r u k t

ersetzt

durch

ein

whi1e-Konstrukt BLOCK-X

BLOCK-X

while

(NOT

q)

BLOCK-X until Fall

q

2: W h i 1 e - K o n s t r u k t

ersetzt

durch

ein

unti1 - K o n s t r u k t

whi le p Tr BLOCK-Y

—

F

BLOCK-Y until

(NOT

p)

Legende: Vgl. Bild 2.2.3-2 ./. ::= I d e n t i t ä t s f u n k t i o n ( z w e c k m ä ß i g daß e i n e B l o c k e i n t r a g u n g n i c h t Bild

2.2.3-3

Iterati

zur K e n n z e i c h n u n g , vergessen wurde).

onskonstrukte

Bei den MAP-Konstrukten besteht die eigentliche Iteration in der Wiederholung der Anwendung von auf die einzelnen Argumente. Dabei ist eine Funktion mit einer LAMBDA-Variablen, d.h. eine Funk-

74

I. Konstrukte (Bausteine zum Programmieren)

tion definiert für ein Argument (engl.: unary function). Da das MAP-Konstrukt diese als Argument hat, ist es selbst eine Funktion höherer Ordnung. Eine Funktion höherer Ordnung (engl.: higher-order function) ist eine Funktion, die entweder eine Funktion als Argument hat und/oder eine Funktion als (Rückgabe-)Wert. Der Vorteil dieser MAP-Iteration ist das Abstrahieren von den Details, wie die einzelnen Argumente der Reihe nach selektiert werden und die Abbruchbedingung geprüft wird. Das folgende Beispiel Sachmittelplanung einer Behörde demonstriert die beiden in PC Scheme eingebauten „mapping functions": Das MAP-Konstrukt und das FO/?-£AC//-Konstrukt. eval> eval>

(MAP L I S T (FOR-EACH

' ( 1 2 3 ) ) ==> ( ( 1 ) (2) L I S T ' ( 1 2 3 ) ) = = > #T

(3))

Beide wenden eine Funktion, die für ein Argument definiert ist, auf eine Liste von Argumenten an. Der Wert des MAP-Konstruktes ist eine Liste, die die Resultate der einzelnen Funktionsanwendung enthält. Der Wert des FOR-EACHKonstruktes ist #T. /Hinweis: Mapping functions. In Common LISP umfaßt das Repertoire an „mapping functions" auch Konstrukte, bei den sich die Funktionsapplikation auf die jeweilige Restliste bezieht, z.B. MAPLIST oder MAPCON. Die beiden hier verwendeten „mapping-functions" sind in Scheme-Notation, wie folgt, definierbar (Näheres zur Rekursion vgl. Abschnitt 3): eval>

eval>

( D E F I N E FOR-EACH (LAMBDA (FUNKTION (COND ( ( N U L L ? L I S T E ) N I L ) (T (FUNKTION (CAR L)

LISTE)

(FOR-EACH FUNKTION (CDR L ) ) ) ) ) ) = = > FOR-EACH ( D E F I N E MAP (LAMBDA (FUNKTION L I S T E ) (COND ( ( N U L L ? L I S T E N I L ) (T (CONS (FUNKTION (CAR L) (MAP FUNKTION (CDR L ) ) ) ) ) ) ) = = > MAP

Wir betrachten eine Behörde und deren Sachmittelbedarf. Für das Jahr 1990 hatte die Abteilung W einen Bedarf pro Quartal in folgender Höhe: eval>

(DEFINE SACHMITTEL-QUARTALSBEDARF-ABTEILUNG-W-1990 ' ( 1 5 0 0 0 0 100000 80000 1 2 0 0 0 0 ) ) ==> SACHMITTEL-QUARTALSBEDARF-ABTEILUNG-W-1990

Für das Jahr 1991 ist eine Steigerung von 2,45 Prozent vorzusehen. Jeder Quartalsbetrag ist mit 1.0245 zu multiplizieren, um die Werte für 1991 zu erhalten. Die Berechnung der neuen gerundeten Werte kann als wiederholte Anwendung der anonymen Funktion (LAMBDA (BETRAG) (ROUND (* 1.0245 BETRAG))) definiert werden.

]

2. Kombinieren von Konstrukten eval>

eval>

75

( D E F I N E SACHM I T T E L - Q U A R T A L S B E O A R F - A B T E I L U N G - W - 1 9 9 1 (MAP ( L A M B D A ( B E T R A G ) (ROUND ( * 1 . 0 2 4 5 B E T R A G ) ) ) SACHMITTEL-OUARTALSBEDARF-ABTEILUNG-W-1989)) ==> SACHMITTEL-QUARTALSBEDARF-ABTEILUNG-W-1991 SACHMITTEL-QUARTALSBEDARF-ABTEILUNG-W-1991 ==> (153675 102450 81960 122940)

Wir nehmen nun an, daß die Quartalswerte für 1990 für alle Abteilungen der Behörde in folgender Matrix-Struktur vorliegen: eval>

(DEFINE SACHMITTEL-QUARTALSBEDARF-BEH0ERDE-1990 '((LEITUNG ( 10000 10000 10000 10000)) ( A B T E I LUNG-E (450000 423000 411000 567230)) (ABTEILUNG-T (159000 156000 85000 121300)) (ABTEILUNG-W (150000 100000 80000 120000)) (AUSSENSTELLE-HAMBURG ( 34500 32900 25000 55000)))) ==> SACHMITTEL-QUARTALSBEDARF -BEH0ERDE-1990

Zur Berechnung der Werte für das Jahr 1991 sind zwei geschachtelte Iterationen notwendig. Es ist über die 5 Zeilen und die 4 Betragsspalten der Matrix-Struktur zu iterieren. eval>

(DEFINE SACHMITTEL-QUARTALSBEDARF-BEH0ERDE-1991 (MAP ( L A M B D A ( O R G A N I S A T I O N ) ( L I S T (CAR O R G A N I S A T I O N ) (MAP ( L A M B D A ( B E T R A G ) (ROUND ( * 1 . 0 2 4 5 B E T R A G ) ) ) (CAR (CDR O R G A N I S A T I O N ) ) ) ) ) SACHMITTEL-QUARTALSBEDARF-BEHOERDE-1990)) ==> SACHMITTEL-QUARTALSBEDARF-BEHOERDE-1991

eval>

SACHMITTEL-QUARTALSBEDARF-BEHOERDE-1991 ==> ((LEITUNG ( 10245 10245 10245 (ABTE I LUNG-E (461025 433364 421070 (ABTEILUNG-T (162896 159822 87083 (ABTEILUNG-W (153675 102450 81960 (AUSSENSTELLE-HAMBURG ( 35345 33706 25613

10245)) 581127)) 124272)) 122940)) 56348)))

Um den Gesamtbedarf an Sachmitteln für die Behörde für das Jahr 1991 zu berechnen, sind alle Beträge in der Matrix-Struktur zu summieren. Dazu ist in den geschachtelten Iterationen ein Akkumulator erforderlich. Dieser ist als lokale Variable mit Hilfe des LET-Konstruktes definierbar. Da der Endwert des Akkumulators die gesuchte Lösung darstellt, sind die Rückgabewerte der beiden MAP-Konstrukte nutzlos. Wir ersetzen daher die MAP-Konstrukte durch FOREACH-Konstrukte. Das FOR-EACH-Konstrukt unterscheidet sich von dem MAP-Konstrukt dadurch, daß die Iterationsergebnisse nicht den Rückgabewert bilden. eval>

(DEFINE GESAMTBEDARF-BEHOERDE-1991 (LET ((AKKUMULATOR 0 ) ) (F0R-EACH (LAMBDA ( O R G A N I S A T I O N )

76

I. Konstrukte (Bausteine zum Programmieren) (FOR-EACH (LAMBDA (BETRAG) (SET! AKKUMULATOR (+ AKKUMULATOR BETRAG))) (CAR (CDR ORGANISATION)))) SACHMITTEL-QUARTALSBEDARF-BEHOERDE-1991) AKKUMULATOR)) ==> GESAMTBEDARF-BEHOERDE-1991

eval> GESAMTBEDARF-BEHOERDE-1991 ==> 3083676

2.3 Zeitpunkt einer Wertberechnung Im Rahmen der Selektion (Abschnitt 2.2.2) wurde anhand einer Entscheidungstabelle (Bild 2.2.2-2) deutlich, daß bei Nebeneffekten der Zeitpunkt einer Wertberechnung bedeutsam ist. Wir wollen explizit den Zeitpunkt festlegen, wann die einzelnen Bedingungen ihren Wert berechnen. Zum Zeitpunkt der Definitionen von B l , B2, B3 und B4 dürfen die Abfragen, d.h. die Nebeneffekte durch die WRITELN- und READ-Konstrukte, noch nicht zur Ausführung kommen. Wir haben daher die Bedingungen als Funktionen definiert und ihren Berechnungszeitpunkt durch den Funktionsaufruf terminiert (vgl. Programmfragment 2.2.2-1). Die Wertberechnung, hier die Abfrage, wurde auf den Applikationszeitpunkt verschoben. Zur Verschiebung des Zeitpunktes der Wertberechnung eines beliebigen symbolischen Ausdrucks notieren wir diesen innerhalb eines LAMBDA-Konstruktes, das keine LAMBDA-Variablen besitzt. Mit dem Evaluieren dieses LAMBDA-Konstruktes entsteht eine Funktion, kurz „thunk" genannt. /Hinweis: Thunk. Eine Funktion, definiert für kein Argument, wird als „thunk" bezeichnet. Dieses Wort stammt aus der ALGOL-Welt. Welche ursprüngliche Bedeutung es hatte ist unbekannt. Es gibt nur scherzhafte Interpretationen, wie den Verweis auf „Registergeräusche". ] Zum gewünschten Zeitpunkt applizieren wir „thunk" (unsere Funktion) und veranlassen damit die Wertberechnung. Die Kombination von Funktions-Definition (LAMBDA-Konstrukt) und Funktions-Applikation (implizites oder explizites APPLY-Konstrukt) bewirkt die Zeitpunktverschiebung der Wertberechnung. eval> ;; , a l s o der Wert von , ;; wird j e t z t b e r e c h n e t . (DEFINE F00 ) ==> F00 eval> ;; Der berechnete Wert wird j e t z t ;; nur gesucht und ausgegeben F00 ==>

2. Kombinieren von Konstrukten

77

eval>

;; D e r W e r t d e s L A M B D A - K o n s t r u k t e s w i r d b e r e c h n e t . ;; < v a l u e > , a l s o d e r W e r t v o n < s e x p r > , ist n o c h ;; n i c h t b e r e c h n e t . ( D E F I N E F00 ( L A M B D A () < s e x p r > ) ) = = > F00

eval>

;; < v a l u e > w i r d b e r e c h n e t (F00) ==>

und

ausgegeben.

Potentiell besteht mit der Kombination QUOTE und EVAL eine Alternative zur Kombination LAMBDA und APPLY. Die Auswertung des symbolischen Ausdrucks wird durch das QUOTE-Konstrukt blockiert, so daß sich wie eine „Konstante" verhält, die mit dem EVAL-Konstrukt zum gewünschten Zeitpunkt „aktiviert" wird (vgl. Abschnitt 1.3). eval>

;; < v a l u e > , a l s o d e r W e r t v o n < s e x p r > , ;; w i r d n i c h t b e r e c h n e t . D i e A u s w e r t u n g ;; v o n < s e x p r > ist b l o c k i e r t . (DEFINE F00 ') ==> F00

eval>

;; D e r W e r t v o n F 0 0 , a l s o ;; w i r d a u s g e w e r t e t . (EVAL F00) = = > < v a l u e >

,

Im folgenden sind beide Möglichkeiten für die Entscheidungstabelle von Bild 2.2.2-2 dargestellt. Das erste Programmfragment (2.3-1) nutzt den funktionalen Ansatz. Das zweite Programmfragment (2.3-2) verwendet die Auswertungsblokkierung in Verbindung mit dem EVAL-Konstrukt. Die Benutzerschnittstelle ist in der ET-Abbildung des Abschnittes 2.2.2 (vgl. Programmfragment 2.2.2-2) außerhalb des ET-Konstruktes definiert. Hier sind in beiden Fällen die Bedingungen und Aktionen mit Hilfe des LET-Konstruktes als lokale Variable des Konstruktes ET-AUSZAHLUNG-BUCHEN formuliert, also innerhalb der ET definiert. Damit wird einerseits ein ungewolltes Überschreiben im Falle bestehender oder neuer namensgleicher Konstrukte vermieden und andererseits die Zugehörigkeit zum ET-Konstrukt unmittelbar sichtbar. Zusätzlich bewahren wir uns dadurch die leichtere Überschaubarkeit der „top level"-Umgebung, weil diese dann weniger Einträge hat. ;;;; ;;;;

Begrenzte Eintreffer-Entscheidungstabel1e ET-AUSZAHLUNG-BUCHEN mit lokalen Fuktionen

eval> (DEFINE (LET

ET-AUSZAHLUNG-BUCHEN

I. Konstrukte (Bausteine zum Programmieren)

78

;;;

Bedingungen ((Bl (B2

(B3

(B4

; ;;

Aktionen (AI (A2 (A3 (A4 (A5

;;;

( L A M B O A () (WRITELN "Ist die K o n t o n u m m e r a n g e g e b e n ? (J/N)") (READ))) ( L A M B D A () (WRITELN " I s t d i e K o n t o n u m m e r k l e i n e r g l e i c h 4 0 0 0 0 ? (J/N)"l (READ))) ( L A M B D A () (WRITELN " I s t d e r B e t r a g g r o e s s e r g l e i c h 5 0 . 0 0 DM ? ( J / N ) " ) (READ))) ( L A M B D A () (WRITELN "Ist der Zweck a n g e g e b e n ? (J/N)") (READ)))

( L A M B D A () ( L A M B D A () (WRITELN ( L A M B D A () (WRITELN ( L A M B D A () (WRITELN ( L A M B D A ()

(WRITELN

"Dem Chef

"Zurueck

an d i e

"Umkontieren "Vorgang (WRITELN

auf

vorlegen")))

Fachabteilung Konto

schicken")))

SONSTIGES")))

an A b t e i l u n g 2 a b g e b e n " ) ) ) "Buchung vollziehen"))))

Regeln

( LAMBDA (COND

( ) ( ( E Q ? (Bl) 'J) ( C O N D ( ( E Q ? (B2) 'J) ( C O N D ( ( E Q ? (B4) 'J) C A 5 ) ) (T ( C O N D ( ( E Q ? (B3) 'J) ( A D ) (T (A3) ( A 5 ) ) ) ) ) ) (T ( A 4 ) ) ) ) (T ( C O N D ( ( E Q ? (B3) 'J) ( A 2 ) ) (T ( C O N D ( ( E Q ? ( B 4 ) 'J) (A3) ( A 5 ) ) (T ( A I ) ) ) ) ) ) ) ) ) ) ==> ET-AUSZAHLUNG-BUCHEN

P r o g r a m m f r a g m e n t 2 . 3 - 1 . Abbildung der ET von Bild 2.2.2-2 - B e d i n g u n g e n und A k t i o n e n i n n e r h a l b des E T - K o n s t r u k t e s a l s lokale Funktionen definiert -

;;;; ;;;;

Begrenzte Eintreffer-Entscheidungstabel1e ET-AUSZAHLUNG-BUCHEN mit lokalen Konstanten

eval> (DEFINE (LET ;;;;

ET-AUSZAHLUNG-BUCHEN

Bedi n g u n g e n ((Bl

'(BEGIN "Ist die (B2 ' ( B E G I N

(WRITELN Kontonummer (WRITELN

angegeben?

(J/N)")

(READ)))

2. Kombinieren von Konstrukten "Ist die Kontonummer

79 kleiner gleich 40000 ? (J/N)") (READ)))

(B3 '(BEGIN (WRITELN "Ist der Betrag groesser gleich 50.00 DM ? (J/N)") (READ))) (B4 '(BEGIN (WRITELN "Ist der Zweck angegeben ? (J/N)") (READ))) Akti o nen (AI (A2 (A3 (A4 (A5

'(WRITELN '(WRITELN '(WRITELN '(WRITELN '(WRITELN

Regel n (LAMBDA () (COND ((EQ? (EVAL Bl) 'J) (COND ((EQ? (EVAL B2) 'J) (COND ((EQ? (EVAL B4) 'J) (EVAL A5)) (T (COND ((EQ? (EVAL B3) 'J) (EVAL A D ) (T (EVAL A3) (EVAL A5)))))) (T (EVAL A4)))) (T (COND ((EQ? (EVAL B3) 'J) (EVAL A2)) (T (COND ((EQ? (EVAL B4) 'J) (EVAL A3) (EVAL A5)) (T (EVAL A D ) ) ) ) ) ) ) ) ==> E T - A U S Z A H L U N G - B U C H E N P r o g r a m m f r a g m e n t 2 . 3 - 2 . A b b i l d u n g der ET von Bild 2.2.2-2 - Bedingungen und A k t i o n e n als lokale Konstanten definiert -

2.4 Typische Fehler Ob LISP-Anfanger oder LISP-Profi („LISP-wizard"), alle machen Fehler, der eine mehr, der andere weniger. Mißverständliche Vorgaben, Unkenntnis der Zusammenhänge, logische Fehlschlüsse und Flüchtigkeit sind häufige Ursachen. Nicht selten führt daher erst die Fehlersuche und Fehlerkorrektur zu einem tieferen Verständnis des Problems und seiner Lösung. Die folgenden fehlerhaften Konstrukte bieten daher die Möglichkeit, die bisher skizzierte LISP-Welt nochmals zu durchdenken. Es handelt sich um klassische Anfängerfehler, die gleichermaßen als Flüchtigkeitsfehler den LISP-Profis unterlaufen. In der Praxis wird jeder unter derartigen „Denkbeulen" selbst leiden müssen, ehe er die Souveränität gewinnt, um solche Fehler spontan zu erkennen und „lächelnd" beseitigen zu können.

80

I. Konstrukte (Bausteine zum Programmieren)

Fehler bei der Funktionsdefinition: Gewünschtes Konstrukt: eval>

( D E F I N E VERDOPPLUNG (LAMBDA ( Z A H L ) ( * ZAHL 2 ) ) )

==>

VERDOPPLUNG

Notierte Konstrukte: eval>

( D E F I N E M U R K S - 1 LAMBDA ( Z A H L ) ( * ZAHL 2 ) ) => ERROR Zu v i e l e s y m b o l i s c h e A u s d r ü c k e f ü r d a s D E F I N E - K o n s t r u k t , da d i e Klammern f ü r das LAMBDA-Konstrukt f e h l e n .

eval>

( D E F I N E MURKS-2 = = > ERROR . . .

eval>

( D E F I N E (MURKS= = > ERROR . . .

( * ZAHL 2 ) ) ) S y n t a k t i s e h e Kurzform des DEFINE-Kons t r u k t e s e r w a r t e t an d e r S t e l l e von ( * ZAHL 2) d a s Symbol ZAHL. Das Symbol ZAHL f e h l t und e i n e s c h l i e ß e n d e Klammer s t e h t an d e r falschen Stelle.

eval>

( D E F I N E MURKS-4 = = > ERROR . . .

(LAMBDA ( Z A H L ) ) ( * ZAHL 2 ) ) ;Zu v i el e s y m b o l i s e h e A u s d r ü c k e f ü r d a s ; D E F I N E - K o n s t r u k t , da d a s LAMBDA-Kon; s t r u k t s c h o n g e s c h l o s s e n wurde b e v o r ; der F u n k t i o n s k ö r p e r n o t i e r t i s t .

eval>

( D E F I N E MURKS-5 = = > ERROR . . .

(LAMBDA ( Z A H L ) ) ) ( * ZAHL 2) ;Zu w e n i g e s y m b o l i s c h e A u s d r ü c k e f ü r d a s L A M B D A - K o n s t r u k t . Da d a s D E F I N E - K o n s t r u k t schon beendet w i r d , bevor ( * ZAHL 2 ) g e l e s e n w i r d , f e h l t d e m LAMBDA-Konstrukt der F u n k t i o n s k ö r p e r .

eval>

( D E F I N E MURKS-6 (LAMBDA ( 1 ) ( * ZAHL 2 ) ) ) ;E i n Zahlatom, hier 1, i s t k e i n e = = > ERROR . . . g ü l t i g e V a r i a b l e . Zu b e a c h t e n i s t d e r U n t e r s c h i e d z w i s c h e n e i n e m Symbol ( L i t e r a l a t o m ) und e i n e m Z a h l a t o m .

(LAMBDA ( * ZAHL 2 ) ) ) ; D i e A n g a b e der LAMBDA-Variablen f e h l t . ; Daher h a t d a s L A M B D A - K o n s t r u k t zu w e n i g e ; symbolische Ausdrücke.

81

2. Kombinieren von Konstrukten Fehler beim Argument: Gewünschtes Konstrukt: eval>

(DEFINE NEUER-LISTENKOPF (LAMBDA ( L ) (CONS 'KONTO

eval>

(NEUER-LISTENKOPF

'(HUEL

(CDR L ) ) )

12 1 3 ) ) = = >

==>

NEUER-LISTENKOPF

(KONTO 12

13)

Notierte Konstrukte: eval>

( N E U E R - L I S T E N K O P F ' H U E L 12 13) = = > ERROR . . . Die F u n k t i o n i s t f ü r e i n Argument d e f i n i e r t . Si e w i r d aber mit d r e i Argumenten a u f g e r u f e n .

eval>

( N E U E R - L I S T E N K O P F "HUEL 12 13) ==> Warten ! . . . Der R E A D - P r o z e ß i s t n i c h t b e e n d e t , da d a s Ende e i n e r Z e i c h e n k e t t e , d a s d o p p e l t e Hochkomma, f e h l t .

eval>

(NEUER-LISTENKOPF = = > ERROR

eval>

(NEUER-LISTENKOPF) = = > ERROR . . K e i n A r g u m e n t a n g e g e b e n , obwohl d i e F u n k t i o n f ü r e i n Argument d e f i n i e r t wurde. B e a c h t e : H i e r i s t k e i n e Angabe ungleich NIL! e v a l > ( N E U E R - L I S T E N K O P F ( ) ) = = > (KONTO)

"HUEL 12 1 3 " ) F a l s c h e r Typ des A r g u m e n t s . Das CDR-Konstrukt i s t für eine Zeichenk e t t e n i c h t d e f i n i e r t . Es e r w a r t e t e i n e L i s t e bzw. e i n P u n k t - P a a r .

Fehler beim COND-Konstrukt: Gewünschtes Konstrukt: eval>

(DEFINE KLARE-ENTSCHEIDUNG? (LAMBDA (ANTWORT) (COND ( ( E Q ? ANTWORT ' N E I N ) ) ( ( E Q ? ANTWORT ' J A ) ) (T N I L ) ) ) ) = = > K L A R E - E N T S C H E I D U N G ?

eval> eval>

(KLARE-ENTSCHEIDUNG? (KLARE-ENTSCHEIDUNG?

Notiertes Konstrukt: eval>

( D E F I N E MURKS-7 (LAMBDA (ANTWORT)

'JEIN) 'NEIN)

==> () = = > #T

82

I. Konstrukte (Bausteine zum Programmieren) (COND ( E Q ? ANTWORT ' N E I N ) ( E Q ? ANTWORT ' J A ) (T N I L ) ) ) ) = = > MURKS-7 A n d e r S t e l l e des P r ä d i k a t e s e i n e r Klausel steht nicht eine Funktionsa n w e n d u n g , al s o e i n e L i s t e , s o n d e r n e i n S y m b o l , h i e r : E Q ? . Da d a s Symbol EQ? al s e i n g e b a u t e F u n k t i o n e i n e n Wert ungleich NIL hat, t r i f f t s t e t s die 1. K l a u s e l z u . D e r Wert i h r e s l e t z t e n symbolischen Ausdruckes i s t NEIN. Der Wert v o n MURKS-7 i s t d a h e r s t e t s NEIN.

e v a l > (MURKS-7

'JEIN)

e v a l > (MURKS-7

' J A ) ==>

==>

NEIN

NEIN

Gewünschtes Konstrukt: eval>

eval>

( D E F I N E GEWINN-PROGNOSE (LAMBDA ( S E X P R ) (COND ((NOT (NUMBER? S E X P R ) ) " K e i n e Z a h l " ) ((NUMBER? SEXPR) (WRITELN " D o p p e l t e r G e w i n n : " (* 2 (WRITELN " D r e i f a c h e r G e w i n n : " ( * 3 ) ) = = > GEWINN-PROGNOSE

SEXPR)) SEXPR))))

(GEWINN-PROGNOSE 1 0 0 0 ) = = > D o p p e l t e r Gewinn: 2000 D r e i f a c h e r G e w i n n : 3000 () ¡Wert d e s l e t z t e n W R I T E L N - K o n s t r u k t e s

Notiertes Konstrukt: eval>

( D E F I N E MURKS-8 (LAMBDA ( S E X P R ) (COND ((NOT (NUMBER? S E X P R ) ) " K e i n e Z a h l " ) ((NUMBER? S E X P R ) (WRITELN " D o p p e l t e r G e w i n n : " (* 2 SEXPR))) (WRITELN " D r e i f a c h e r G e w i n n : " ( * 3 S E X P R ) ) ) ) ) ==> MURKS-8 D i e Klammer nach dem K o n s t r u k t (WRITELN " D o p p e l t e r G e w i n n : " . . . ) s c h l i e ß t di e 2. K l a u s e l desCOND-Kons t r u k t e s . Das f o l g e n d e W R I T E L N - K o n s t r u k t i s t d a m i t d i e 3 . K l a u s e l m i t dem Symbol WRITELN an d e r S t e l l e d e s P r ä d i kates ( e r s t e Posi t i o n ) . ( U n ) g l ü c k l i cherweise wird die 3.Klausel nicht err e i c h t , da d i e b e i d e n v o r h e r g e h e n d e n Klauseln a l l e möglichen F ä l l e abfangen.

2. Kombinieren von Konstrukten

eval>

(MURKS-8

"1000")

eval>

(MURKS-8

1000)

Doppelter

83

==> " K e i n e

Zahl"

==>

Gewinn:

2000

()

Fehler mit dem QUOTE-Konstrukt: Gewünschtes Konstrukt: eval>

((LAMBDA

(X Y)

(LIST

X V))

'KONTO " S c h u l z e A G " ) = = > (KONTO " S c h u l z e

AG")

Notierte Konstrukte eval>

((LAMBDA (X Y) ( L I S T "X ' Y ) ) KONTO " S c h u l z e A G " ) = = > ERROR .. D i e V a r i a b l e KONTO i s t i n d e r a k t u e l l e n Umgebung n i c h t d e f i n i e r t . D i e A r g u m e n t e d e r anonymen F u n k t i on werden z u n ä c h s t e v a l u i e r t . Dabei i s t f ü r KONTO k e i n Wert ermi t t e l b a r .

eval>

((LAMBDA (X Y) ( L I S T ' X Y ) ) 'KONTO " S c h u l z e A G " ) = = > (X Y ) Die Argumente des L I S T - K o n s t r u k t e s s i n d aufgrund i h r e r Q u o t i e r u n g Konstanten. S i e e n t s p r e c h e n n i c h t den Werten an d i e d e f i n i e r t e n L A M B D A - V a r i a b l e n X und Y gebunden werden.

eval>

((LAMBDA ( ' X = = > ERROR

'Y) ...

( L I S T X Y ) ) 'KONTO " S c h u l z e A G " ) ; Es s i n d k e i n e S y m b o l e a l s LAMBDAV a r i a b l e n d e f i n i e r t . D u r c h d i e Quot i e r u n g von X u n d Y b e s t e h t d i e S c h n i t t s t e l l e des L A M B D A - K o n s t r u k t e s a u s K o n s t a n t e n . D i e s e können k e i n e Symbol-Wert-Assoziationen abbilden.

2.5 Zusammenfassung: LET, DO und MAP Wir definieren ein eigenes Konstrukt (Programm) indem wir eingebaute LISPKonstrukte und/oder selbstdefinierte Konstrukte miteinander kombinieren. Ob das Konstrukt „zweckmäßig" definiert ist, zeigt sich nicht nur in Bezug auf die spezifizierte Aufgabe, die es korrekt abzubilden gilt, sondern auch daran, ob das Konstrukt später einfach änderbar und ergänzbar ist. Der gesamte SoftwareLebenszyklus ist Bewertungsmaßstab. Für den symbolischen Ausdruck Liste verfügt ein LISP-System über den eingebauten Konstruktor CONS mit den zugehörenden Selektoren CAR und CDR sowie über ein Prädikat, das feststellt, ob die leere Liste vorliegt. Das Prädikat

84

I. Konstrukte (Bausteine zum Programmieren)

EQ? prüft die Identität zweier symbolischer Ausdrücke. Für den Test auf Gleichheit von zwei Listen gibt es das Prädikat EQUAL?. Konstrukte sind verknüpfbar als Sequenz, Selektion und Iteration. Zur Abbildung der Sequenz dienen die Komposition von Funktionen und Konstrukte wie BEGIN oder BEGINO. Das LAMBDA-Konstrukt hat in seinem Teil Rechenvorschrift eine implizit definierte Sequenz, da es dort eine Folge symbolischer Ausdrücke der Reihe nach auswertet. Das LET-Konstrukt als syntaktisch vereinfachte Anwendung einer anonymen Funktion (Applikation eines LAMBDA-Konstruktes) bindet seine lokalen Variablen nicht in einer Sequenz. Erst das LET*-Konstrukt vollzieht diese Bindung sequentiell. Die Selektion ist mit Konstrukten wie IF, COND oder CASE realisierbar. Die Iteration ist einerseits mit dem umfassenden DO-Konstrukt und andererseits mit MAP-Konstrukten („mapping functions") abbildbar. Die Iteration ist als Sonderfall der Rekursion betrachtbar. Sie wird daher auch als rekursive Formulierung notiert. Charakteristische

Beispiele für Abschnitt

2:

eval> eval> eval> eval>

(COND (1 2 3) (4 5 6)) ==> 3 (CADDR '(LAMBDA (X Y) (- Y X))) ==> (- Y X) (CONS 23.45 67.89) ==> (23.45 . 67.89) (EQ? (CONS 'MEYER-AG '(MUELLER-OHG)) '(MEYER-AG MUELLER-OHG)) ==> () eval> (EQUAL? (CONS 'MEYER-AG '(MUELLER-OHG)) '(MEYER-AG MUELLER-OHG)) ==> #T eval> (1+ 12) ==> 13 eval> (DEFINE *3 (LAMBDA (WERT) (LET ((DREIFACH (LAMBDA (X) (* 3 X))) (DREIFACH WERT)))) ==> *3 eval> (*3 5) ==> 15 eval> (LET* ((X 2) (Y (+ X 1))) (* X Y)) ==> 6 eval> (AND (NOT (AND (NOT 3 ) ) ) ) ==> #T eval> (CASE 'M ((MEIN DEIN SEIN) #T) (ELSE "Nicht d a b e i ! " ) ) ==> "Nicht dabei!" eval> (DO ( ( I 2 (- I 1))) ((BEGIN (WRITELN "Ja") (= 0 I ) ) ) ) ==> Ja Ja Ja #T eval> (MAP LIST '(A B C D)) ==> ((A) (B) (C) (D)) eval> (FOR-EACH WRITELN '("Gestern" "Heute" "Morgen")) ==> Gestern Heute Morgen #T ¡Rückgabewert von FOR-EACH

85

3. Rekursion als Problemlösungsmethode

3. Rekursion als Problemlösungsmethode Nimmt eine Definition auf sich selbst Bezug, dann liegt direkte Rekursion vor. Ist der Selbstbezug über eine Aufruffolge von Definitionen gegeben, dann spricht man von indirekter oder gegenseitiger Rekursion. Problemlösungen über rekursive Definitionen sind für LISP-Programme kennzeichnend. Schon bei der Definition von Syntax und Semantik zeigte sich die Einfachheit und Kürze rekursiver Definitionen. Eines der oft erwähnten Beispiele für die Erläuterung der Rekursion ist die Definition der Funktion LAENGE (vgl. z.B. Tanimoto, 1987, S.27ff oder Müller, 1985, S.63ff). Sie bestimmt die Länge einer Liste, d.h. die Anzahl der Elemente. eval>

eval> eval>

( D E F I N E LAENGE (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) 0 ) (T ( + 1 (LAENGE (CDR L I S T E ) ) ) ) ) ) (LAENGE (LAENGE

==>

' ( M E Y E R - A G MUELLER-OHG SCHULZE-GMBH)) ' ( ( A ) (B (C ( D ) ) ) ) = = > 2

P r o g r a m m f r a g m e n t 3 - 1 . Beispiel einer rekursiven - B e s t i m m u n g der Länge e i n e r L i s t e , d . h . Anzahl i h r e r Elemente -

LAENGE ==> 3

Definition E r m i t t l u n g der

Das JV£/ZZ?-Prädikat im LAENGE-Konstrukt (Programmfragment 3-1) stellt fest, ob eine leere Liste vorliegt. Es entspricht folgender Definition: eval>

(DEFINE

NULL?

(LAMBDA

(X)

(EQ?

X NIL)))

==>

NULL?

Die rekursive Methode ist immer dann nützlich, wenn eine Familie "verwandter" Probleme vorliegt, von denen eines so einfach ist, daß sich die Lösung direkt angeben läßt. Diesen trivialen Fall bezeichnet Douglas R. Hofstadter treffend mit „Embryonal-Fall" (vgl. Hofstadter, 1983), da sich die Lösung des Gesamtproblems aus ihm „entwickelt". So läßt sich die Länge der leeren Liste sofort mit 0 angeben. Die Länge einer Liste mit z.B. 3 Elementen ist zurückführbar auf das einfachere Problem der Ermittlung der Länge einer Liste mit 2 Elementen, da die 3-elementige Liste um 1 Element länger ist. Generell stellen sich die beiden Kernprobleme für das Auffinden einer ,Jtekursions-Route":

86

I. Konstrukte (Bausteine zum Programmieren)

o Definition von trivialen Lösungen und o Definition der Verknüpfung von Lösungsschritten. 1. Definition von trivialen Lösungen. Welches ist der einfache Fall (bzw. welches sind die einfachen Fälle), bei dem (denen) die Lösung(en) direkt angebbar ist (sind)? o Woran erkennt man einen einfachen Fall? o Wie lautet die zugehörende Lösung? 2. Definition der Verknüpfung von Lösungsschritten. Welches ist die Verknüpfung zwischen einem typischen und dem nächst einfacheren Fall? o Wie kommt man von einem typischen Fall genau einen Schritt näher zu einem einfachen Fall? o Wie konstruiert man die Lösung für den vorliegenden Fall aus der „unterstellten" Lösung für den einfacheren Fall? Beim Problem LAENGE lauten die Antworten auf diese Fragen: o Der einfache Fall ist gegeben, wenn die Liste leer ist, d.h. das NULL?-Konstruk liefert den Wert #T. o Bei der leeren Liste ist die Länge gleich 0. o Verkürze die gegebene Liste um ein Element, o Addiere 1 zur Lösung der um ein Element verkürzten Liste. Entscheidend ist, daß die Rekursions-Route tatsächlich zu trivialen Fällen führt. Anhand eines rekursiven Akronyms soll der umgekehrte, in der Regel der ungewollte Weg aufgezeigt werden. Man nehme zum Spaß an, LAMBDA stehe für folgendes rekursive Akronym: LAMBDA ::= ¿AMBDA Auch Mein ßestens Definierbares Arbeitsmittel Ersetzt man das LAMBDA der rechten Seite durch die Definition, dann erhält man nach zweimaliger Anwendung folgendes Ungetüm: (((LAMBDA Auch Mein Bestens Definierbares Arbeitsmittel) Auch Mein Bestens Definerbares Arbeitsmittel) Auch Mein Bestens Definierbares Arbeitsmittel). Bei der Anwendung einer rekursiven Definition sind zunächst Zwischenlösungen für die Teilprobleme zu vermerken, bis eine triviale Lösung erreicht wird. Von dieser können dann „rückwärts" die vermerkten Teilprobleme gelöst werden. Im allgemeinen Rekursionsfall wächst daher der Speicherbedarf mit der Zahl der erforderlichen Zwischenschritte. Die Anzahl der geschachtelten Aufrufe wird als Rekursionstiefe der Funktion bezeichnet. Im speziellen Fall der sogenannten Restrekursion (engl.: tail-recursion) ist der Speicherbedarf konstant. Er ist unabhängig vom Wert des Argumentes und damit unabhängig von der Rekursionstiefe. Bei der Restrekursion ist das Teilproblem-Ergebnis der größten Rekursionstiefe das Problem-Gesamtergebnis (vgl. Hinweis Restrekursion).

87

3. Rekursion als Problemlösungsmethode

Effiziente LISP-Systeme erkennen, ob eine Definition eine Restrekursion darstellt, und arbeiten diese dann mit konstantem Speicherbedarf entsprechend einer Iteration ab. Für Scheme-Systeme wird diese Eigenschaft gefordert (vgl. Rees/Clinger, 1986). Der Benutzer kann sich somit auf rekursive Formulierungen konzentrieren, ohne ein unnötiges Wachsen des Speicherbedarfs im Restrekursions-Fall in Kauf nehmen zu müssen. Ein Beispiel ist die Funktion SÄGEZAHN (vgl. Programmfragment 3-3). /Hinweis: Restrekursion. Das obige LAENGE-Konstrukt (vgl. Programmfragment 3-1) ist nicht restrekursiv definiert. Mit Hilfe eines Akkumulators ist eine restrekursive Lösung leicht definierbar, wie das folgende Beispiel zeigt: eval> eval>

eval>

( D E F I N E RR-LAENGE (LAMBDA ( L I S T E ) (ZAEHLUNG L I S T E 0 ) ) ) = = > RR-LAENGE ( D E F I N E ZAEHLUNG (LAMBDA ( L AKKUMULATOR) (COND ( ( N U L L ? L ) A K K U M U L A T O R ) (T ( Z A E H L U N G ( C D R L) ( + 1 A K K U M U L A T O R ) ) ) ) ) ) (RR-LAENGE ' ( A B C D)) ==> 4

]

Zum Verständnis einer rekursiven Definition ist es hilfreich, die Aufruffolgen mit ihren Argumenten und den zugehörenden Rückgabewert darzustellen. Das 77?AC£-Konstrukt ermöglicht eine entsprechende Ausgabe bei der Applikation. (PC SCHEME: TRACE-ENTRY protokolliert jeden Aufruf und TRACE-EXIT jedes Verlassen der Funktion. TRACE-BOTH dokumentiert beides; den Aufruf und das Verlassen der Funktion.7 Bezogen auf das LAENGE-Konstrukt erhält man folgende Unterstützung: e v a l > ( T R A C E - B O T H L A E N G E ) = = > OK e v a l > (LAENGE ' ( M E Y E R - A G MUELLER-OHG SCHULZE-GMBH)) A r g u m e n t 1: (MEYER-AG MUELLER-OHG SCHULZE-GMBH) > > > E n t e r i n g # A r g u m e n t 1: (MUELLER-OHG SCHULZE-GMBH) >>> E n t e r i n g #

88

I. Konstrukte (Bausteine zum Programmieren)

> > > E n t e r i n g # < P R O C E D U R E LAENGE> A r g u m e n t 1: ( ) < < < L e a v i n g # < P R O C E D U R E LAENGE> w i t h v a l u e 0 A r g u m e n t 1: ( ) < < < L e a v i n g # < P R O C E D U R E LAENGE> w i t h v a l u e 1 A r g u m e n t 1: ( S C H U L Z E - G M B H ) < < < L e a v i n g # < P R O C E D U R E LAENGE> w i t h v a l u e 2 Argument 1: (MUELLER-OHG SCHULZE-GMBH) < < < L e a v i n g # < P R O C E D U R E LAENGE> w i t h v a l u e 3 A r g u m e n t 1: ( M E Y E R - A G M U E L L E R - O H G S C H U L Z E - G M B H ) Programmfragment

3-2.

Protokoll der Funktionsaufrufe beim Anwenden des rekursiv definierten LAENGEKonstruktes ( v g l . Programmfragment 3 - 1 )

Rekursive Definitionen sind in der Mathematik gebräuchlich. Man notiert z.B. eine Sägezahn-Kurve wie folgt: 0 X SÄGEZAHN

falls falls

0

(DEFINE

BGB-§7-l

'(WER

SICH

AN

EINEM

ORTE

STÄNDIG

N I E D E R L Ä ß T B E G R Ü N D E T AN D I E S E M ORTE S E I N E N W O H N S I T Z ) ) ==> BGB-§7-l eval> eval>

(WORTZÄHLUNG (WORTZÄHLUNG

' O R T E B G B - § 7 - l ) ==> 'WOHNSITZ B G B - § 7 - l )

2 ==>

1

Entsprechend der rekursiven Problemlösungs-Methode suchen wir zunächst triviale Fälle und ihre Lösungen. Danach ermitteln wir eine Konstruktionsvorschrift, die das Problem in Richtung auf trivale Fälle vereinfacht (Bestimmung der Rekursions-Route). Der triviale Fall ist gegeben, wenn der Text kein Wort enthält. Dann ist die

90

I. Konstrukte (Bausteine zum Programmieren)

Lösung der Wert 0. Enthält der Text Wörter, dann soll zunächst das erste Wort des Textes mit dem vorgegebenen Wort verglichen werden. Liegt Übereinstimmung vor, dann ist die gesuchte Lösung um 1 größer als das Ergebnis der Wortzählung im Resttext. (Die bisherige Definition entspricht dem erläuterten LAENGE-Konstrukt). Ist keine Übereinstimmung gegeben, dann ist die gesuchte Lösung gleich dem Ergebnis der Wortzählung im Resttext. Der Resttext ist die Restliste, d.h. der Text ohne das erste Wort.

WORTZÄHLUNG

[

]

Enthält kein W o r t ? _

True

— E r s t e WORTZÄHLUNG :- 0

True

W o r t in = ?

W O R T Z Ä H L U N G := 1 + W O R T Z Ä H L U N G [ ] RETURN

Legende:

WORTZÄHLUNG

WORTZÄHLUNG

False

W O R T Z Ä H L U N G [ ]

WORTZÄHLUNG

:= 0::= Der Wert der Funktion ist 0.

[ ]

RETURN W O R T Z Ä H L U N G Bild 3.1-1.

False

::= Die Funktion w i r d angewendet auf die A r g u m e n t e und . ::= Der F u n k t i o n s w e r t wird gegeben .

aus-

Graphisehe Darstel1ung einer Rekursion als Struktogramm (Notation vgl. N a s s i / S h n e i d e r m a n , 1973)

Das Bild 3.1-1 stellt diese Lösung als Struktogramm dar. Die Beschriftung orientiert sich dabei an der von I. Nassi und B. Shneiderman für ihr Fakultätsbeispiel gewählten Notation (vgl. Nassi/Shneiderman, 1973). Diese Notation läßt allerdings die wesentliche Unterscheidung zwischen der Applikation einer Funktion und der Darstellung des Funktionswertes nur schwer erkennen, wie auch die Legende in Bild 3.1-1 zeigt. Entsprechend dem Struktogramm ist die Funktion, wie folgt, zu definieren:

3. Rekursion als Rroblemlösungsmethode eval>

91

(DEFINE W O R T Z Ä H L U N G (LAMBDA (WORT TEXT) (COND ((NULL? TEXT) 0) ((EQ? WORT (CAR TEXT)) (+ 1 (WORTZÄHLUNG WORT (CDR TEXT)))) (T (WORTZÄHLUNG WORT (CDR T E X T ) ) ) ) ) ) ==> W O R T Z Ä H L U N G

Die Lösung kann auch durch eine Entscheidungstabelle (ET) mit einer Aktion „Wiederhole ET" dargestellt werden (Bild 3.1-2). Eine solche Notation verdeutlicht jedoch nicht die rekursive Definition. Diese zeigt Bild 3.1-3. Hier ist allerdings wie beim Struktogramm das Problem, die Applikation der Funktion vom Rückgabewert der Funktion deutlich zu unterscheiden. AKKUMULATOR

:= 0

ET-Wortzählung

R1 R2 R3

B1

Enthält kein

B2

Erste Wort im =

AI

AKKUMULATOR

A2

< t e x t > : = reduziert um erstes

A3

Wiederhole

A4

Gebe A K K U M U L A T O R

:= 1 +

Wort? ?

J

N

N

-

J

N

X

AKKUMULATOR Wort

ET-Wortzählung

X

X

X

X

aus

Legende: ET-Symbole vgl. A b s c h n i t t

X

2.2.2

Bild 3 . 1 - 2 . I t e r a t i o n dargestellt in - Funktion W O R T Z Ä H L U N G -

ET-Technik

Daß die Iteration als Sonderfall von selbstbezüglichen Funktionen betrachtbar ist, verdeutlicht die Rekursion mit der Funktionsanwendung auf die Restliste. Wir können mit dieser Notation die Konstrukte für das klassische „Mapping" (vgl. Abschnitt 2.2.3) definieren. eval>

;; Das e i n g e b a u t e F O R - E A C H - K o n s t r u k t hat den Wert „wahr" (DEFINE FOR-EACH (LAMBDA (FUNKTION LISTE) (COND ((NULL? LISTE) T) (T (FUNKTION (CAR LISTE)) (FOR-EACH FUNKTION (CDR LISTE)))))) ==> FOR-EACH

eval>

(FOR-EACH W R I T E L N '("Zeile 1" "Zeile 2" "Zeile 3") ==> Zeile 1 Zeile 2 Zeile 3 #T ¡Rückgabewert von FOR-EACH

92

I. Konstrukte (Bausteine zum Programmieren)

ET-Wortzählung

[

R2

R3

Wort?

J

N

N

-

J

N

Enthält

B2

Erste Wort

AI

Wortzählung

A2

W o r t z ä h l u n g := 1 + CALL ET-Wortzählung [ ]

A4

CALL

kein

R1

B1

A3

]

im < t e x t > = := 0

X

ET-Wortzählung ]

Wortzählung

X

Legende: E T - S y m b o l e vgl. A b s c h n i t t C A L L ::= V e r w e i s t a u f d i e

2.2.2 Funktionsapplikation

B i l d 3 . 1 - 3 . R e k u r s i o n dargestellt in - Funktion WORTZÄHLUNG -

X

X

ET-Technik

Das MAP-Konstrukt sammelt die Ergebnisse der Funktionsanwendung und gibt sie als Liste zurück. Dieses Sammeln bilden wir mit dem CONS-Konstrukt ab. eval>

eval>

(DEFINE MAP (LAMBDA (FUNKTION LISTE) (COND ((NULL? LISTE) NIL) (T ( C O N S ( F U N K T I O N ( C A R L I S T E ) ) (MAP FUNKTION (CDR L I S T E ) ) ) ) ) ) ) ==> (MAP W R I T E L N ' ( " Z e i l e 1" " Z e i l e 2" " Z e i l e 3 " ) = = > Zeile 1 Zeile 2 Zeile 3 (() () ()) ; R ü c k g a b e w e r t v o n M A P

eval>

(MAP

(LAMBDA

(X)

(* X X))

'(1 2 3 4 ) ) = = >

(14

9

MAP

16)

Die rekursive Definition des MAP-Konstruktes zeigt eine häufig vorkommende Lösungsstruktur. Salopp „LISP-isch" formuliert: "CDRing down the list and CONSing up the answer".

3.2 Verknüpfung von Teilproblem-Lösungen Beispiel: Änderung eines Textes, der als Baumstruktur vorliegt Wir definieren eine Funktion ERSETZUNG, die in einem Text ein bestimmtes

3. Rekursion als Problemlösungsmethode

93

Wort durch ein neues Wort ersetzt. Der Text ist als Baum strukturiert, d.h. als eine Liste, die wiederum Listen als Elemente enthält. Als Textbeispiel dient wie in Abschnit 3.1 wieder §7 BGB. eval > ( D E F I N E BGB-§7 ' ( ( ( 1 ) WER S I C H AN EINEM ORTE STÄNDIG N I E D E R L Ä ß T BEGRÜNDET AN D I E S E M ORTE S E I N E N WOHNPLATZ) ( ( 2 ) DER WOHNPLATZ KANN G L E I C H Z E I T I G AN MEHREREN ORTEN BESTEHEN) ( ( 3 ) DER WOHNPLATZ WIRD AUFGEHOBEN WENN D I E N I E D E R L A S S U N G MIT DEM WILLEN AUFGEHOBEN WIRD S I E A U F Z U G E B E N ) ) ) = = > B G B - § 7

In diesem Text ist das Wort WOHNPLATZ falsch; es ist durch WOHNSITZ zu ersetzen. Für das zu definierende Konstrukt wird offensichtlich eine Schnittstelle mit drei Parametern benötigt, die wir, wie folgt, benennen: OBJEKT ERSATZ STRUKTUR

: a a s zu e r s e t z e n d e : : = d a s neue Wort : : = der s t r u k t u r i e r t e

alte

Text,

Wort

i n dem e r s e t z t

wird

Entsprechend der rekursiven Problemlösungs-Methode suchen wir zunächst nach trivialen Fällen, bei denen die Lösung bekannt und damit direkt angebbar ist. Wenn die STRUKTUR nur aus dem zu ersetzenden Wort O B J E K T besteht, dann ist die Lösung bekannt und wir brauchen nur ERSATZ zurückzugeben. Ist die STRUKTUR keine Liste, sondern ein elementares Element z.B. eine Zahl oder ein Symbol und ist dieses Element nicht gleich dem OBJEKT, dann ist die STRUKTUR selbst die Lösung. Anders formuliert: Ist die STRUKTUR ein Atom (vgl. Tab. 2.2-1) und trifft nicht der erste triviale Fall zu, dann ist die STRUKTUR der Rückgabewert. Betrachten wir das erste Element von STRUKTUR, dann kann es ein Atom oder wieder eine Liste sein. Für den Fall eines Atomes haben wir die Lösung mit der Definition der trivialen Fälle abgedeckt. Für eine Liste ist der Ersetzungsvorgang sowohl für ihr erstes Element als auch für ihre Restliste zu vollziehen. Das Ergebnis ist die Verknüpfung der Ersetzung im ersten Element mit der Ersetzung in der Restliste. Diese Verknüpfung ist mit dem Konstruktor CONS abbildbar. Wir können die Ersetzung in einer komplexen STRUKTUR auf zwei einfachere Probleme zurückführen: 1. auf die Ersetzung im ersten Element von STRUKTUR und 2. auf die Ersetzung im Rest von STRUKTUR. Die Gesamtlösung ist die Verknüpfung der beiden Teillösungen. Wir definieren daher:

94

I. Konstrukte (Bausteine zum Programmieren)

eval>

(DEFINE ERSETZUNG (LAMBDA (OBJEKT ERSATZ STRUKTUR) (COND ((EQ? OBJEKT STRUKTUR) ERSATZ) ((ATOM? STRUKTUR) STRUKTUR) (T (CONS (ERSETZUNG OBJEKT ERSATZ (CAR STRUKTUR)) (ERSETZUNG OBJEKT ERSATZ (CDR S T R U K T U R ) ) ) ) ) ) ) ==> ERSETZUNG eval> (ERSETZUNG 'WOHNPLATZ 'WOHNSITZ BGB-§7) = = > (((1) WER SICH AN EINEM ORTE S T Ä N D I G N I E D E R L Ä ß T B E G R Ü N D E T AN DIESEM O R T E SEINEN W O H N S I T Z ) ...

3.3 Rekursive Konstrukte für rekursive Strukturen Die Rekursion ist die „geborene" Lösungsmethode für die Handhabung von Baumstrukturen. Im allgemeinen sind Operationen, die sich auf einen Baum beziehen, wiederum auf dessen Teilbäume anzuwenden und zwar so lange, bis die Baumblätter erreicht werden. Anhand eines simplen Beratungssystems wird deutlich, daß die rekursive Lösungsmethode zweckmäßig für Baumstrukturen ist. Beispiel: Ja-Nein-Navigation

entlang einer

Baumstruktur

Zu definieren sei ein Beratungssystem, das auf seine Fragen als Dialogeingabe „Ja" oder „Nein" erwartet. Die Fragen sind hierarchisch strukturiert, wie die folgende Skizze (Bild 3.2-1) zeigt. Das Beratungssystem basiert auf der rekursiven Struktur: ( () ()) Der und der haben beide wieder diese Struktur. Beim Abarbeiten des Baumes wird eine Systemantwort erkannt, wenn der Baum nur noch aus einem Element besteht; d.h. (LENGTH ) ist gleich 1. [Hinweis: LENGTH ist eine eingebaute LISPFunktion. Sie entspricht dem Konstrukt LAENGE, vgl. Abschnitt 3] Das Durchlaufen dieses Binärbaums steuert die rekursive Funktion NAVIGATION. Nach der rekursiven Problemlösungsmethode konstruieren wir die Lösung auf der Basis trivialer Fälle. Hier ist der triviale Fall gegeben, wenn der Binärbaum so weit abgearbeitet ist, daß ein Baumblatt erreicht ist, d.h. eine Systemantwort auszugeben ist. Wir definieren daher ein Prädikat, das feststellt, ob ein Baumblatt gegeben ist. eval>

(DEFINE BAUMBLATT?

(LAMBDA

(BAUM) (EQ? 1 (LENGTH ==>

BAUM)))) BAUMBLATT?

Abhängig von der Dialogantwort ist entweder im oder im cneinbaum> das „Navigieren" fortzusetzen. Wäre der weiter zu verfolgen, dann ist ein Selektor erforderlich, der aus dem ursprünglichen Baum den ermittelt. Bezogen auf die Liste, die den Baum abbildet, ist das zweite Element zu selektieren. Für den ist ein analoger Selektor erfor-

3. Rekursion als Problemlösungsmethode

Ja

Ja

--

5ild

3.2-1.

... ... Skizze

Nei n

--

Ja

Mei n

~lo Ja

... — < F 3 > — Legende: FO, Fl. F2 SO, Sl, S2

95

Nein --

Nei n --

l2

:= :=

--

Fragen Systemantworten eines

Binärbaumes

derlich. Wir definieren eine Funktion VERZWEIGUNG, die abhängig von der Dialogantwort die entsprechende Selektorfunktion ermittelt. Der Wert der Funktion VERZWEIGUNG ist selbst eine Funktion, nämlich die jeweilige Selektorfunktion. VERZWEIGUNG ist daher eine Funktion höherer Ordnung. eval>

( D E F I N E V E R Z W E I G U N G ( L A M B D A () (COND ( ( Z U S T I M M U N G ? ) S E L E K T O R - J A - B A U M ) (T S E L E K T O R - N E I N - B A U M ) ) ) ) = = > V E R Z W E I G U N G

Die Funktion ZUSTIMMUNG? wurde in Abschnitt 2.2.2 mit dem CASE-Konstrukt definiert. Entsprechend der gewählten Datenstruktur für die Abbildung des Binärbaums sind die Selektorfunktionen, wie folgt, zu definieren: eval> eval>

(DEFINE

SELEKTOR-JA-BAUM (LAMBDA (BAUM) (CAR (CDR B A U M ) ) ) ) = = > S E L E K T O R - J A - B A U M (DEFINE S E L E K T O R - N E I N - B A U M (LAMBDA (BAUM) (CAR(CDR(CDR BAUM)))))==> SELEKTOR-NEIN-BAUM

Mit VERZWEIGUNG als Funktion höherer Ordnung ist das Konstrukt NAVIGATION, wie folgt, formulierbar: eval>

(DEFINE NAVIGATION (LAMBDA (BAUM) (COND ( ( B A U M B L A T T ? B A U M ) ( S Y S T E M - A N T W O R T B A U M ) ) (T ( S Y S T E M - F R A G E B A U M ) (NAVIGATION ((VERZWEIGUNG) BAUM)))))) ==> NAVIGATION

Die Konstrukte SYSTEM-FRAGE und SYSTEM-ANTWORT definieren wir mit den entsprechenden Selektoren, wie folgt: eval>

(DEFINE

SELEKTOR-FRAGE

(LAMBDA

(BAUM)

(CAR B A U M ) ) ) ==> SELEKTOR-FRAGE

96

I. Konstrukte (Bausteine zum Programmieren)

eval>

(DEFINE S Y S T E M - F R A G E (LAMBDA (BAUM) (WRITELN ( S E L E K T O R - F R A G E BAUM)))) ==>

eva1>

(DEFINE S E L E K T O R - B A U M B L A T T

eval>

(DEFINE S Y S T E M - A N T W O R T (LAMBDA (WRITELN " S y s t e m a n t w o r t : " ( S E L E K T O R - B A U M B L A T T BAUM)))) ===>

SYSTEM-FRAGE

(LAMBDA

(BAUM) (CAR BAUM))) ==> S E L E K T O R - B A U M B L A T T (BAUM) SYSTEM-ANTWORT

In der Definition von NAVIGATION führt die Applikation von (VERZWEIGUNG) zur Rückgabe der anzuwendenden Selektorfunktion, so daß ((VERZWEIGUNG) BAUM) den zutreffenden „Restbaum" ermittelt. Wir wenden auf diesen „Restbaum" die Funktion NAVIGATION erneut an. Diese Vorgehensweise entspricht der schon erörterten Technik der Funktionsanwendung auf die Restliste (vgl. Abschnitt 3.1). Der Unterschied besteht in der Ermittlung des „Restes"; d.h. des einfacheren Problems im Sinne der Rekursionsroute. Der skizzierte Lösungsansatz führt zu einer Anzahl von Funktionen, die im Zusammenhang mit dem BERATUNGSSYSTEM-Konstrukt zu definieren sind. Außerhalb dieses Konstruktes sind diese Funktionen nicht erforderlich. Mit Hilfe einer LET-Formulierung (vgl. Abschnitt 2.2.1) können die Funktionen wie SELEKTOR-JA-BAUM, SELEKTOR-NEIN-BAUM, BAUMBLATT?, VERZWEIGUNG, NAVIGATION etc. als lokale Variablen definiert werden. Wir vermeiden damit, daß diese Konstrukte auf der LISP-System-Ebene („top level") bekannt sind und z.B. versehentlich durch namensgleiche Symbole überschrieben werden. Mit der LET-Notation sind ihre Wert-Assoziationen nicht in der USER-INITIAL-ENVIRONMENT eingetragen, sondern in der Umgebung, die durch die LET-Konstruktion aufgebaut wird. Da das Konstrukt NAVIGATION rekursiv ist, wird das LETREC-Konstrukt benötigt. Das Programmfragment 3.3-1 zeigt die Lösung mit dem LETREC-Konstrukt. Sie weist darüber hinaus einige kleine Verbesserungen auf z.B. steht statt der Schachtelung von (CAR (CDR (CDR BAUM))) der Selektor (LIST-REF BAUM 2). Um den Rückgabewert NIL des WRITELN-Konstruktes nicht als letzten Wert auf dem Bildschirm zu zeigen, ist die Variable *THE-NON-PRINTING-OBJECT* (ein vordefiniertes Scheme-Symbol) als letztes Element der Sequenz genannt. /Hinweis: LIST-REF-Konstrukt. In Scheme ermittel das LIST-REF-Konstrukt das n-te Element einer Liste, wobei n < j a - b a u m > < n e i n - b a u m > ) eval> (DEFINE BERATUNGSSYSTEM (LAMBDA (BAUM) (LETREC ( ( S E L E K T O R - J A - B A U M ( L A M B D A (X) ( L I S T - R E F X 1 ) ) ) ( S E L E K T O R - N E I N - B A U M ( L A M B D A (X) ( L I S T - R E F X 2 ) ) ) ( S E L E K T O R - F R A G E ( L A M B D A (X) ( C A R X ) ) ) ( S E L E K T O R - B A U M B L A T T ( L A M B D A (X) ( C A R X ) ) ) ( B A U M B L A T T ? ( L A M B D A (X) (EQ? 1 ( L E N G T H X ) ) ) ) ( Z U S T I M M U N G ? ( L A M B D A () (CASE (READ) ((J JA Y Y E S T) # T ) ( E L S E N I L ) ) ) ) ( V E R Z W E I G U N G ( L A M B D A () (COND ((ZUSTIMMUNG?) S E L E K T O R - J A - B A U M ) (T S E L E K T O R - N E I N - B A U M ) ) ) ) ( S Y S T E M - F R A G E ( L A M B D A (X) (WRITELN (SELEKTOR-FRAGE X)))) ( S Y S T E M - A N T W O R T ( L A M B D A (X) (WRITELN "Systemantwort: " (SELEKTOR-BAUMBLATT X)))) ( N A V I G A T I O N ( L A M B D A (X) ( C O N D ( ( B A U M B L A T T ? X) ( S Y S T E M - A N T W O R T X)) (T ( S Y S T E M - F R A G E X) (NAVIGATION ((VERZWEIGUNG) X))))))) (NAVIGATION BAUM) *THE-NON-PRINTING-OBJECT*))) ==> BERATUNGSSYSTEM eval>

eval>

(DEFINE FAHRRAD-ANALYSE ' ( " H a t es e i n e n D i a m a n t r a h m e n ? " ( " I s t d e r R a h m e n h o e h e r a l s 56 c m ? " ( " U n g e e i g n e t fuer ein Kind!") ("Notfalls fuer ein Kind v e r w e n d b a r ! " ) ) ( " B e d i n g t g e e i g n e t - nur fuer kleine P e r s o n e n ! " ) ) ) ==> FAHRRAD-ANALYSE (BERATUNGSSYSTEM FAHRRAD-ANALYSE) ==> H a t es e i n e n D i a m a n t r a h m e n ? n ¡Benutzereingabe B e d i n g t g e e i g n e t - nur fuer kleine P e r s o n e n !

Programmfragment

3.3-1.

Beratungssystem konstruiert einem Binärbaum

mit

3.4 Geschachtelte Rekursion Beispiel: Umdrehen der Reihenfolge der Elemente in einer Liste Die Funktion REVERSE hat als Wert eine Liste, die die Elemente ihres Argumentes in umgekehrter Reihenfolge aufweist.

I. Konstrukte (Bausteine zum Programmieren)

98 eval > (REVERSE

'(A

(B C)

D))

==>

(D

(B C)

A)

Wir definieren diese Funktion selbst, und zwar rekursiv. Um die eingebaute Funktion nicht zu überschreiben, nennen wir unsere Funktion UMDREHEN. Im Sinne der rekursiven Problemsicht halten wir zunächst fest, daß das Konstrukt UMDREHEN bei einer Liste ohne Elemente den Wert NIL hat. Dann unterstellen wir, daß für eine Liste eine Teillösung vorliegt, nämlich ihre umgedrehte Restliste. Mit dieser Teillösung ist dann die gesamte Problemlösung bekannt. Sie ist gleich das erste Element der Liste, an das Ende der unterstellten Teillösung angehängt. Benötigt wird eine Funktion, die ein solches „Anhängen" an eine Liste ermöglicht. Das entsprechende Konstrukt heißt APPEND (deutsch: hinzufügen). Es verknüpft zwei Listen miteinander. eval>

(APPEND

'(1

2 3)

'(4

5))

==>

(12

3 4

5)

Damit ist die Definition von UMDREHEN, wie folgt, formulierbar: eval>

(DEFINE

UMDREHEN (LAMBDA ( X ) (COND ( ( N U L L ? X) N I L ) (T (APPEND (UMDERHEN (CDR X ) ) ( L I S T (CAR X ) ) ) ) ) ) )

==>

UMDREHEN

Das APPEND-Konstrukt ist ebenfalls rekursiv definierbar. Wir nennen es (um ein Überschreiben zu vermeiden) ANHAENGEN. Ein trivialer Fall ist gegeben, wenn der Wert eines Argumentes von ANHAENGEN die leere Liste ist. Die zugehörige Lösung ist dann die jeweils andere Liste. Da mit dem CONS-Konstrukt ein Mittel vorhanden ist, an den Anfang einer Liste ein Element einzufügen, nehmen wir die Liste des zweiten Argumentes von ANHAENGEN als Ausgangsbasis und betrachten das Problem als Einfügen der Liste des ersten Argumentes. Wir unterstellen wieder die Existenz einer Teillösung, nämlich das Verknüpfen der Restliste des ersten Argumentes mit der Liste des zweiten Argumentes. Die Lösung für das Gesamtproblem ist dann das Einfügen des ersten Elementes der ersten Liste in diese Teillösung. Das Einfügen übernimmt das CONSKonstrukt. Damit ist ANHAENGEN, wie folgt, definierbar: eval>

( D E F I N E ANHAENGEN (LAMBDA ( L I S T E _ 1 L I S T E _ 2 ) (COND ( ( N U L L ? L I S T E . l ) LISTE_2) ( T (CONS (CAR L I S T E _ 1 ) (ANHAENGEN (CDR L I S T E _ 1 ) LISTE_2)))))) ==> A N H A E N G E N

Bisher wurde die Rekursion sowohl als eine iterativ geprägte Formulierung („tail recursion") als auch im Zusammenhang mit Verknüpfungsfunktionen wie CONS oder APPEND erörtert. Jetzt diskutieren wir die Rekursion im Hinblick auf geschachtelte Aufrufe (Komposition). Der rekursive Bezug wird als Argument eines schon rekursiven Funktionsaufrufes formuliert. Dazu dient wieder

3. Rekursion als Problemlösungsmethode

99

die Funktion UMDREHEN; jedoch wird diese nicht mehr mittels APPEND definiert. Der Lösungsansatz geht von folgenden Überlegungen aus: o Enhält die umzudrehende Liste kein Element, dann ist NIL die Lösung. o Enthält die umzudrehende Liste nur ein Element, dann ist sie selbst die Lösung. o Ist die Liste X, z.B. ( A B C D), umzudrehen, dann ist das letzte Element der Liste, hier D, an den Anfang einer Liste zu setzen, deren weitere Elemente die umgedrehte Restliste, hier das Umdrehen von (A B C), ist. o Das letzte Element einer Liste X ist selektierbar durch e v a l > (CAR

(UMDREHEN

(CDR

X))

==>

D ¡letzte

Element

von X

o Gesucht ist die rekursive Definition, welche die Liste X ohne ihr letztes Element, hier D, als Wert hat. Die folgende rekursive Definition in LISP-Notation verdeutlicht den skizzierten Lösungsansatz:

(UMDREHEN

X)

NIL

falls

(NULL?

X)

X

falls

(NULL?

(CDR

::= - I -

X))

- (CONS < 1 e t z t e - e l e m e n t > falls sonst (UMDREHEN ))

Die Formulierung für den Sonst-Fall erarbeiten wir durch folgende Schritte, wobei für die Erläuterung angenommen wird, daß X an die Liste (A B C D) gebunden ist: 1. Restliste umdrehen: eval>

(UMDREHEN

(CDR

X))

==>

(D C B )

2. Von Schritt 1 das erste Element entfernen: eval>

(CDR

(UMDREHEN

(CDR

X)))

==>

(C

B)

3. Ergebnis von Schritt 2 umdrehen eval>

(UMDREHEN

(CDR

(UMDREHEN

(CDR

X))))

==>

(B

C)

4. Erste Element von X, also A, in Ergebnis von Schritt 3 einfügen: eval>

(CONS

(CAR

X)

(UMDREHEN

(CDR

(UMDREHEN

(CDR

X)))))

==>

(ABC)

Die Definition von Schritt 4 ermittelt aus der Liste (A B C D) die Liste (A B C).

100

I. Konstrukte (Bausteine zum Programmieren)

Damit ist entsprechend dem skizzierten Lösungsansatzes das UMDREHENKonstrukt, wie folgt, notierbar: eval>

(DEFINE (COND

UMDREHEN (LAMBDA ( X ) ( ( N U L L ? X) N I L ) ( ( N U L L ? (CDR X ) ) X) (T (CONS (CAR (UMDREHEN (CDR X ) ) ) (UMDREHEN (CONS (CAR X) (UMDREHEN (CDR (UMDREHEN (CDR

X))))))))))) ==> UMDREHEN

Diese Definition des Konstruktes UMDREHEN zeigt geschachtelte rekursive Bezüge. Nur durch Rekursion und Abstützung auf die Basiskonstrukte LAMBDA, COND, CONS, CAR, CDR und NULL? ist das Umdrehen abgebildet. Mit Hilfe der Rekursion lassen sich viele eingebaute Konstrukte auf wenige Basiskonstrukte, d.h auf das sogenannte „Pure LISP", zurückführen (vgl. z.B. das DO-Konstrukt in Abschnitt 2.2.3).

3.5 Zusammenfassung: Rekursion Nimmt eine Definition auf sich selbst Bezug, so bezeichnet man diesen Selbstbezug als Rekursion. Die Lösung eines Problems durch Rekursion ist angebracht, wenn das Problem als eine Familie „verwandter" Probleme betrachtbar ist, von denen eines (oder mehrere) so einfach ist (sind), daß sich die Lösung(en) direkt angeben läßt (lassen). Neben diesen trivialen Lösungen ist eine RekursionsRoute zu definieren, so daß die Lösung für das gesamte Problem nach endlich vielen Schritten auf die trivialen Lösungen zurückgeführt wird. Dabei geht es um die Kernfrage: Wie kommt man von einem typischen Fall genau einen Schritt näher zu einem trivialen Fall und wie konstruiert man für den typischen Fall die Lösung aus der „unterstellten" Lösung für den nächst einfacheren Fall? Besteht das Problem in der Abarbeitung einer Liste, z.B. im Prüfen, ob jedes Element ein bestimmtes Prädikat erfüllt, dann ist die Lösung als eine rekursive Anwendung der Funktion auf die Restliste definierbar. Ein Beispiel ist das MEMBER?-Konstrukt, das feststellt, ob ein vorgegebenes Element in einer Liste enthalten ist (vgl. charakteristische Beispiele). Ist eine Baumstruktur gegeben, d.h. eine Liste, die wieder selbst Listen als Elemente enthält, dann sind die rekursiv definierten Teilproblem-Lösungen mit-

101

3. Rekursion als Problemlösungsmethode

einander zu verknüpfen. Dafür bieten sich die Konstruktoren CONS und APPEND an. Ein Beispiel ist das folgende Konstrukt TURN. Es kehrt die Reihenfolge der Elemente einer Liste um, wobei auch die Elemente in den Sublisten umgedreht werden. eval>

eval>

( O E F I N E TURN (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) N I L ) ((ATOM? (CAR L I S T E ) ) (APPEND (TURN (CDR

(TURN

LISTE)) (CONS (CAR L I S T E ) N I L ) ) ) (T (APPEND (TURN (CDR L I S T E ) ) (CONS (TURN (CAR L I S T E ) ) N I L ) ) ) ) ) ) = = > TURN ' ( A B (C D) E ) ) = = > (E (D C) B A)

Die Definition lokaler rekursiver Funktionen ermöglicht das LETREC-Konstrukt. Im Gegensatz zum LET-Konstrukt, das erst die Werte für alle lokalen Variable ermittelt und dann mit diesen in der Umgebung eine Assoziation aufbaut, vermerkt das LETREC-Konstrukt zunächst die lokale Variable in der Umgebung und ermittelt dann ihren Wert. eval>

(LETREC ((F00

(F00

Charakteristische

(LAMBDA ( L ) (COND ( ( N U L L ? L) N I L ) ( ( = (CAR L) 0) (CONS " U n d e f i n i e r t ! " (T (CONS (/ 1 (CAR L ) ) ( F 0 0 (CDR L ) ) ) ) ) ) ) ) ' ( 2 0 4 0 1 ) ) ) ==> (0.5 " U n d e f i n i e r t ! " 0.25

(F00

(CDR

L))))

"Undefiniert!"

1)

Beispiele für Abschnitt 3:

eval>

( D E F I N E MEMBER? (LAMBDA (ELEMENT L I S T E ) (COND ( ( N U L L ? L I S T E ) N I L ) ( ( E Q U A L ? ELEMENT (CAR L I S T E ) ) L I S T E ) (T (MEMBER? ELEMENT (CDR L I S T E ) ) ) ) ) ) = = > MEMBER? e v a l > (MEMBER? ' B (A B C D ) ) = = > (B C D) ;Wahr, da u n g l e i c h N I L e v a l > (MEMBER? ' ( A B) ' ( A B C D ) ) = = > ( ) e v a l > (MEMBER? ' ( A B) ' ( A (A B) ( C ) ) ) = = > ( ( A B) ( O ) eval>

( D E F I N E UNION-SEQUENZ (LAMBDA ( L I S T E _ 1 L I S T E _ 2 ) (COND ( ( N U L L ? L I S T E . l ) L I S T E _ 2 ) ( ( M E M B E R ? (CAR L I S T E _ 1 ) L I S T E _ 2 ) ( U N I O N - S E Q U E N Z (CDR L I S T E . l ) L I S T E _ 2 ) ) (T (CONS (CAR L I S T E _ 1 ) ( U N I O N - S E Q U E N Z (CDR L I S T E _ 1 ) L I S T E _ 2 ) ) ) ) ) ) = = > UNION-SEQUENZ ; R e k u r s i v e D e f i n i t i o n

eval>

(UNION-SEQUENZ

' ( A A B B C)

'(B

D D E)) ==>

(A A C B D D E)

102

I. Konstrukte (Bausteine zum Programmieren)

e v a l > ( D E F I N E UNION (LAMBDA ( L I S T E _ 1 L I S T E _ 2 ) (COND ( ( N U L L ? L I S T E . l ) L I S T E _ 2 ) ( ( M E M B E R ? (CAR L I S T E _ 1 ) L I S T E _ 2 ) (UNION (CDR L I ST E _ 1 ) L I S T E _ 2 ) ) (T (UNION (CDR L I S T E _ 1 ) (CONS (CAR L I S T E _ 1 ) L I S T E _ 2 ) ) ) ) ) ) = = > UNION ;Endrekursive Definition! e v a l > (UNION " ( A A B B C) ' ( B D D E ) ) = = > (C A B D D E) ¡ R e i h e n f o l g e !

In der endrekursiv-definierten UNION-Lösung arbeitet das Prädikat MEMBER? stets das erzeugte Zwischenresultat ab und nicht nur den Wert des ursprünglichen Argumentes LISTE_2. Die folgende Lösung UNION-MENGE verfügt über eine lokale rekursive Funktion mit einer Lambda-Variable AKKUMULATOR. Sie ist als eine Mengenoperation definiert, d.h. ihr Wert enthält keine doppelten Elemente und die Reihenfolge der Elemente ist unerheblich. eval>

eval> ;;;;

( D E F I N E UNION-MENGE (LAMBDA ( L I S T E _ 1 L I S T E . 2 ) (LETREC ( ( V E R E I N I G U N G (LAMBDA ( L _ l L_2 AKKUMULATOR) (COND ( ( A N D ( N U L L ? L _ l ) ( N U L L ? L _ 2 ) ) AKKUMULATOR) ( ( N U L L ? L_1) ( V E R E I N I G U N G L_2 L_1 AKKUMULATOR)) ( ( M E M B E R ? (CAR L _ l ) AKKUMULATOR) ( V E R E I N I G U N G (CDR L _ l ) L_2 AKKUMULATOR)) (T ( V E R E I N I G U N G (CDR L _ l ) L_2 (CONS (CAR L _ 1 ) A K K U M U L A T O R ) ) ) ) ) ) ) (VEREINIGUNG L I S T E _ 1 LISTE_2 N I L ) ) ) ) = = > UNION-MENGE (UNION-MENGE ' ( A A B B C) ' ( B D D E ) ) ) = = > (E D C B A) Expontential-Funktion r1 Xn

(DEFINE

g a n z a h l i g e Exponenten falls n = 0

(Xn/2)2

:= -

eval>

für

X *

(X

( l v l )

)

(BASIS

(LETREC

n

gradzahlig

falls

n

ungradzahlig

INTEGER.ZAHL)

((EVEN?

(LAMBDA

(SQUARE (EXPT

(N)

(LAMBDA

(LAMBDA

(X

(COND ( ( = O N) ((EVEN? (T (EXPT B A S I S (**

falls

Null

**

(LAMBDA

eval>

größer

3 2) = = > 9

(*

(Y)

( = 0 (REMAINDER N 2 ) ) ) ) (*

Y Y)))

N) 1) N)

(SQUARE

X (EXPT X ( -

INTEGER_ZAHL))))

(EXPT X (/ N 2 ) ) ) ) N

1))))))))

==>

**

103

3. Rekursion als Problemlösungsmethode

Vergleich zweier Listen, wobei das Element mit dem numerischen Maximalwert der ersten Liste ermittelt wird. Rückgabewert ist das Element der zweiten Liste, das an der gleichen Position steht. ; ; ; ; V e r g l e i c h zweier L i s t e n e v a l > ;; I t e r a t i v e Lösung ( D E F I N E MAXIMUM-PARALLEL-WERT (LAMBDA ( Z A H L E N _ L I S T E S U C H _ L I S T E ) (DO ( ( Z L Z A H L E N _ L I S T E (CDR Z L ) ) ( S L S U C H _ L I S T E (CDR S L ) ) (ZL-MAX 0) (SL-MAX N I L ) ) ((NULL? ZL) SL-MAX) (COND ( ( < ZL-MAX (CAR Z L ) ) ( S E T ! ZL-MAX (CAR Z L ) ) ( S E T ! SL-MAX (CAR S L ) ) ) (T N I L ) ) ) ) ) = = > MAXIMUM-PARALLEL-WERT eval>

;; R e k u r s i v e Lösung ( D E F I N E MAXIMUM-PARALLEL-WERT (LAMBDA ( Z A H L E N . L I S T E S U C H _ L I S T E ) (LETREC ((MAX-PARALLEL (LAMBDA ( Z L SL ZL-MAX S L - M A X ) (COND ( ( N U L L ? Z L ) S L - M A X ) ( ( < ZL-MAX (CAR Z L ) ) (MAX-PARALLEL (CDR Z L ) (CDR S L ) (CAR Z L ) (CAR S L ) ) ) (T ( M A X - P A R A L L E L (CDR Z L ) (CDR S L ) ZL-MAX S L - M A X ) ) ) ) ) ) (MAX-PARALLEL ZAHLEN.LISTE SUCH_LISTE 0 N I L ) ) ) ) = = > MAXIMUM-PARALLEL-WERT

e v a l X MAXIMUM-PARALLEL-WERT ' ( 2 4 1 2 6) ' ( L I SP I S T MANCHMAL SEHR N U E T Z L I C H ) ) eval>

==>

NUETZLICH

;; Ergänzung e i n e r bestehenden A s s o z i a t i o n s l i s t e (DEFINE ERGAENZUNG-A-LISTE (LAMBDA ( L I S T E _ K E Y S L I S T E _ W E R T E A _ L I S T E ) (COND ( ( A N D ( N U L L ? L I S T E _ K E Y S ) ( N U L L ? L I S T E _ W E R T E ) ) A_ L I S T E) ((NULL? LISTE_KEYS) (ERGAENZUNG-A-LISTE ( L I S T ' ? ) LISTE_WERTE A _ L I S T E ) ) ((NULL? LISTE_WERTE) (ERGAENZUNG-A-LISTE LISTE_KEYS (LIST ' ? ) A_LISTE)) (T (CONS ( L I S T (CAR L I S T E _ K E Y S ) (CAR L I S T E _ W E R T E ) ) (ERGAENZUNG-A-LISTE (CDR L I S T E . K E Y S ) (CDR L I S T E _ W E R T E ) A _ L I S T E ) ) ) ) ) ) ==> ERGAENZUNG-A-LISTE

I. Konstrukte (Bausteine zum Programmieren)

104

eval> (ERGAENZUNG-A-LISTE '(EMMA HANS KARL) '(VERHEIRATET '((OTTO VERWITWET) (HANNA L E D I G ) ) )

LEDIG)

((EMMA VERHEIRATET) (HANS LEDIG) (KARL ?) (OTTO VERWITWET) (HANNA LEDIG)) eval> ; ; Bestimmung der Schachtelungstiefe (DEFINE S T R U K T U R - T I E F E (LAMBDA ( L ) (COND ((NULL? L) 1) ((ATOM? L) 0) ( T (+ (APPLY MAX (MAP S T R U K T U R - T I E F E L ) ) 1 ) ) ) ) ) ==> S T R U K T U R - T I E F E eval> ( S T R U K T U R - T I E F E

' ( ( A B) C ( ( ( D (E F ) ) ) ) ) ) ==> 5

IL Konstruktionen (Analyse und Synthese)

Im Rahmen des zweiten Kapitels analysieren wir Programmierbeispiele und erweitern die Menge der im ersten Kapitel erläuterten Konstrukte („Bausteine"). Wir skizzieren charakteristische Konstruktionen („Bauarten") und vertiefen diese im Zusammenhang mit (Programmier)-„Paradigmen", d.h. mit Vorstellungen des Konstrukteurs über die Abarbeitung durch einen (möglicherweise auch fiktiven) Rechner. Im Mittelpunkt stehen die konstruktiven („handwerklichen") Aspekte des Programmierens und weniger die ästhetischen, wie sie etwa im Leitmotto „The Art of Programming" zum Ausdruck kommen. /Hinweis: Konstruktion. Der Begriff Konstruktion (lateinisch: Zusammenschichtung) bezeichnet in der Technik die „Bauart" eines Produktes oder Erzeugnisses. In der Mathematik bezeichnet man damit die Herleitung oder Ermittlung eines mathematischen „Objektes" mit Hilfe genau beschriebener Operationen (Konstruktionsvorschriften) aus bestimmten Ausgangsobjekten. Beispielsweise ist in der Geometrie eine gesuchte Figur aus den vorgegebenen Elementen: Geraden, Winkeln und Kreisen herzuleiten. Die konstruktive (formale) Logik ist eine wissenschaftliche Disziplin (Theorie) des Argumentierens, Beweisens und Schließens. In der Linguistik ist konstruieren das Zusammenfügen von Satzgliedern, Wortgruppen und Wörtern nach Regeln der Grammatik. Die Konstruktion ist eine in Konstituenten zerlegbar, komplexe sprachliche Einheit.7 Als Einstieg dient ein klassisches LISP-Beispiel: „Symbolisches Differenzieren". Dabei zeigt sich der Vorteil, ein Programm als einen Verbund von Konstruktor, Selektor, Prädikat und Mutator zu konzipieren (Abschnitt 4). Die Wahl der zweckmäßigen Abbildung von Daten, die sogenannte Datenrepräsentation, ist eine Kompromißentscheidung zwischen diversen, zum Teil konkurrierenden Anforderungen z.B.: Effizienter Datenzugriff, Datenmodifizierbarkeit, Speicherplatzbedarf oder Lebensdauer. LISP verfügt daher, wie andere Programmiersprachen auch, nicht nur über eine Darstellungsmöglichkeit. Neben der Liste gibt es Vektoren, Zeichenketten, Ports, Ströme etc. Wegen der in LISP bestehenden Ambivalenz zwischen „Daten" und „Programm" (vgl. Abschnitt 1.3) sprechen wir hier allgemein von Abbildungsoption. Zunächst vertiefen wir die Abbildungsoption Liste als Grundlage einer Konstruktion (Abschnitt 5). Durch Modifikation der CONS-Zelle konstruieren wir eine zirkuläre Liste (Abschnitt 5.1). Darauf aufbauend werden die Konstrukte für die Assoziationsliste (Abschnitt 5.2) und die Eigenschaftsliste (Abschnitt 5.3) erörtert. Anhand des relativ ,größeren' Beispiels „Aktenverwaltung" diskutieren wir

106

II. Konstruktionen (Analyse und Synthese)

Konstrukte für die Abbildungsoption Vektor (Abschnitt 6). Die Option Zeichenkette erörtern wir im Rahmen der Aufgabe eines Mustervergleichs (Abschnitte 7.1 und 7.2). Wir befassen uns mit dem PRINT-Namen eines Symbols als eine weitere Abbildungsoption (Abschnitt 7.3). Erklärt wird die Notwendigkeit ein neues Symbol als Unikat zu generieren (Abschnitt 7.4). Die Nützlichkeit des Mustervergleichs demonstiert ein kleiner Vorübersetzer für eine PseudocodeNotation. Ausführlich wird die Funktion und ihre Umgebung als Abbildungsoption behandelt (Abschnitt 8). Das Konstruieren von Funktionen höherer Ordnung erörtern wir anhand der drei Beispiele: Abbildung der CONS-Zelle als Funktion (Abschnitt 8.1.1), Rekursion mit dem Fixpunktoperator Y (Abschnitt 8.1.2) und Simulation der wechselseitigen Abarbeitung zweier Prozesse (Abschnitt 8.1.3). Wir können in Scheme nicht nur die Funktion selbst an ihre eigene LAMBDA-Variable binden, sondern mit dem CALL/CC-Konstrukt auch die noch nicht vollzogene Abarbeitung. Mit dieser sogenannten Continuation („Fortsetzung") konstruieren wir Kontrollstrukturen, die als Sprünge in die „Zukunft" und in die „Vergangenheit" einer Berechnung erklärbar sind (Abschnitt 8.2). Die Möglichkeiten der Syntaxverbesserung durch Makros zeigen wir am Beispiel DEFINE-P, einem Konstrukt, das mehrere Symbole binden kann (Abschnitt 8.3). Die in Kapitel I skizzierte Kontenverwaltung realisieren wir als eine Hierarchie von Umgebungen im Sinne von eigenständigen Paketen (Abschnitt 8.4). Zur Effizienzverbesserung wird das Compilieren von Funktionen kurz erwähnt (Abschnitt 8.5). Die Kontenverwaltung verwenden wir auch, um Schritt für Schritt die „Objektprägung" von Konstruktionen zu steigern. Zur Abschirmung von Wertebeschreibungen (Abschnitt 9.1) dient zunächst das DEFINE-STRUCTUREKonstrukt (Abschnitt 9.2). Aufbauend auf die damit realisierbare einfache statische Vererbung (Abschnitt 9.3) wird die Abbildungsoption „Klasse-Instanz" erklärt (Abschnitt 10). Eine „Klasse-Instanz"-Kontenverwaltung zeigen wir mit dem „Scheme Object-Oriented Programming System" (Abschnitt 10.1). Es erlaubt eine multiple dynamische Vererbung (Abschnitt 10.2) und umfaßt das Konzept aktiver Slots (Abschnitt 10.3). Die Möglichkeiten Knoten, Kanten und Knoteninhalte bei einem Vererbungsgraphen zu modifizieren, sind ein wesentlicher Maßstab für die Bewertung von objektgeprägten Entwicklungsumgebungen. Wir befassen uns daher eingehend mit solchen Modifikationen (Abschnitt 10.4).

4. Verstehen einer Konstruktion Wollen wir Konstruktionen (Programme) verstehen, dann sind die einzelnen Konstrukte und ihre Verknüpfungen (Wechselwirkungen) untereinander zu an-

4. Verstehen einer Konstruktion

107

alysieren. Da die verfolgten Analysezwecke vielfältig sind, müssen Konstrukte im Hinblick auf unterschiedliche Aspekte hinreichend verstanden werden. Die Konstrukte können z.B. nach ihrer Aufgabe, ihrem Leistungsumfang oder ihrer Abarbeitung durch das LISP-System untersucht werden (Abschnitt 4.1). Eine derartige Klassifikation zeigt Tabelle 4-1. So gehört z.B. das DOKonstrukt (vgl. Abschnitt 2.2.3) in PC Scheme zur Klasse der „eingebauten Konstrukte". Als Benutzer können wir es der Klasse „spezielle Konstrukte" zuordnen, weil es seine Argumente nach einer speziellen Vorschrift evaluiert. Aus der Aufgabensicht fällt es in die Klasse „Steuerungskonstrukte", weil es einen Wiederholungsprozeß (Iteration) steuert. Aus der Implementationssicht ist es ein Makro, das zu einem LETREC-Konstrukt expandiert. Jede Konstruktion ist geprägt von den Vorstellungen, die der (Chef-)Konstrukteur hat, wenn er über die Ausführung durch einen Rechner nachdenkt. Für sein Ausführungsmodell sind spezifische Konstrukte, Verknüpfung, Lösungsansätze und Vorgehensweisen charakteristisch. Ein Modell orientiert sich an beispielhaften, besonders gelungenen Konstruktionen. Sie bilden den Rahmen in dem der Konstrukteur seine Lösungen sucht, notiert und bewertet. Ein derartiger „Denkrahmen" wird als Programmierparadigma oder kurz als Paradigma bezeichnet. Man könnte weniger anspruchsvoll auch von einem (Programmier-)Stil reden, wenn wir dabei die jeweils bestimmenden Stilelemente in den Mittelpunkt rücken (vgl. Stoyan, 1986). Allgemein ist ein Paradigma ein von der wissenschaftlichen Fachwelt als Grundlage der weiteren Arbeiten anerkanntes Erklärungsmodell, eine forschungsleitende Theorie. Unerheblich ist, ob das Modell direkt von einem „real existierenden" Rechner abgearbeitet werden kann, oder ob es auf einem fiktiven Rechner (einer angenommenen Maschine) basiert. Im letzteren Fall läßt sich der Konstrukteur nicht davon leiten, wie die Umsetzung seines Modells auf einen verfügbaren Rechner vollzogen wird. Er unterstellt nur, daß seine paradigma-spezifische Kombination von Eigenschaften, Merkmalen und Besonderheiten für seine Konstruktions-Aufgabe zweckmäßig und prinzipiell auch effizient ist. Praxisrelevant ist für ihn die Frage: Existiert eine paradigma-konforme Entwicklungsumgebung, welche die spezifischen Konstrukte direkt bereitstellt und ihre Verknüpfung unterstützt? Angenommen, es sei eine Konstruktion zu analysieren, bei der sich der Konstrukteur einen Rechner vorgestellt hat, der Objekte generieren und modifizieren kann, die miteinander Nachrichten austauschen. In diesem objektgeprägten Modell werden Abstraktionen durch Klassen- und Instanz-Definitionen kombiniert mit Vererbungsmechanismen abgebildet. Es dominieren daher Konstrukte zur Definition und Modifikation von anwendungsspezifischen Klassen und Instanzen (Näheres vgl. Abschnitt 10). Wäre das gleiche Problem mit einem funktionsgeprägten Modell gelöst, dann dominieren anwendungsspezifische Funktionen, wobei Abstraktionen durch Funktionen höherer Ordnung abgebildet wären (Nä-

II. Konstruktionen ( A n a l y s e und S y n t h e s e )

108

Analyseaspekt

Konstruktmerkmal

Beispiele/Erläuterung

E r s t e l 1 er des Konstruktes

ei ngebaut

CONS, CAR,CDR, NULL, E Q ? , ATOM? KONTO.ABBUCHEN! , EINZAHLEN!

Aba r b e i t u n g d u r c h das LISP-System

normal s p e z i el 1

EQUAL?, + , I F , QUOTE, DEFINE

Lei s t u n g s u m f a n g

primitiv komplex

NULL? DO, C A S E ,

Verwendungs fehlerri siko

problemlos destrukti v

CONS, L I S T APPEND!,SET-CAR!, S ET -CDR !

Rei chwei t e

global

lokal

D e f i n i e r t in USER-GLOBALENVIRONMENT bzw. USER-INITIALENVIRONMENT DO, LAMBDA, LET

Aufgabe

Konstruktor Seiektor P r ä d i kat Mutator

CONS, MAKE-KONTO CAR, SUMME-EINZAHLUNGEN N U L L ? , ZERO?, KONTO? S E T ! , EINZAHLEN!

Ablauf

Steuerung (transfer control)

Sequenz, S e l e k t i o n , I t e r a t i o n , " g o t o " , EXIT

seibstdefiniert

of

Umgebungso p e r a t i o n im System

- , ASSQ LAMBDA,

LETREC

B i n d u n g von l o k a l e n Vari ablen, THE-ENVIRONMENT

Kommuni k a t i on READ, WRITE, mit der Umwelt Tab. 4 - 1 .

Klassifikation

für

LOAD

Konstrukte

heres v g l . Abschnitt 8). O f f e n s i c h t l i c h erleichtern Kenntnisse über den a n g e w e n deten D e n k r a h m e n das Verstehen einer v o r g e g e b e n e n Konstruktion. D e r Denkrahmen, in w e l c h e m w i r ein P r o b l e m analysieren und unsere Ideen f ü r seine L ö s u n g g e w i n n e n und notieren, u m f a ß t zumindest: o elementare Konstrukte D i e s e Basiskonstrukte (engl.: primitives) stellen die elementaren „ E i n h e i t e n " dar, mit denen der Konstrukteur umgehen kann.

4. Verstehen einer Konstruktion

109

m >

S o Verknüpfungsmittel Sie ermöglichen das Konstruieren von komplexen Konstrukten aus weniger komplexen. o Abstraktionsmittel Sie benennen komplexe Konstrukte, um diese dann als „Einheiten" handhaben (manipulieren) zu können. Moderne LISP-Systeme unterstützen verschiedene Denkrahmen („Paradigmen"). Sie stellen zumindest derartige Mittel bereit für: o imperativgeprägte Programme (z.B. SET!), Kennzeichnend sind die Erklärungen von Variablen und die schrittweise Änderung ihrer Werte durch Zuweisungsbefehle (engl.: assign statements). Diese Prägung unterstützen z.B. die Programmiersprachen COBOL, FORTRAN oder Pascal. o funktionsgeprägte Programme (z.B. LAMBDA, APPLY) und Kennzeichnend sind Kompositionen von Funktionen höherer Ordnung. Diese Prägung unterstützt z.B. die Programmiersprache ML (vgl. Gordon u.a., 1984). o objektgeprägte Programme (z.B. DEFINE-CLASS, MAKE-INSTANCE). Kennzeichnend sind Objekte (lokale Speicher), deren Eigenschaften durch einen Vererbungsmechanismus bestimmt werden und die Nachrichten untereinander austauschen. Diese Prägung unterstützen z.B. die Programmiersprachen SmallTalk, C++ und Flavor (vgl. Abschnitt 10). /Hinweis: "Orientiert", "basiert" oder "geprägt". In der Literatur werden in diesem Zusammenhang Beiworte wie „orientiert" oder "basiert" verwendet. Stets verdeutlichen solche Beiworte, daß der Denkrahmen nicht auf die reine Lehre beschränkt ist. Wir bezeichnen eine Konstruktion als funktionsgeprägt, selbst wenn sie z.B. das WRITELN-Konstrukt enthält, das wegen des Nebeneffektes eingesetzt wird und nicht zur Erzielung eines Funktionswertes. Entschei-

110

II. Konstruktionen (Analyse und Synthese)

dend ist das „Sich-leiten-lassen" vom funktionalen Modell. Kompositionen anwendungsspezifischer Funktionen, die (weitgehend) frei von Nebeneffekten definiert sind, geben der Konstruktion ihr Beiwort „funktionsprägt"./ Die Folge dieser LISP-„Potenz" ist eine Konstruktevielfalt. Um sich in dieser großen Menge zurechtzufinden, bedarf es eines pragmatischen Leitfadens (Abschnitt 4.2). Wir wählen dazu eine aufgabenbezogene Klassifikation in die vier Typen: o Konstruktor, o Selektor (incl. Präsentator), o Prädikat und o Mutator, auch Modifikator genannt (incl. Destruktor). Ein Konstruktor erzeugt und kombiniert „Einheiten" zu neuen „Einheiten". Dabei ist eine „Einheit" z.B. ein Objekt, eine Funktion, Menge, Liste oder ein Vektor. Ein Selektor ermöglicht den Zugriff auf eine solche „Einheit". Prädikate vergleichen „Einheiten". Sie prüfen z.B. auf Gleichheit oder Identität und stellen damit den „Typ" fest. Mutatoren ändern existierende „Einheiten". In dieses pragmatische, enge Klassifikationsschema integrieren wir auch Vorgänge, wie das Zerstören von „Einheiten" (Destruktor hier als Mutator klassifiziert) oder das Präsentieren von „Einheiten" (Präsentator hier als Selektor klassifiziert). Der zeitliche Aspekt z.B. das Aktivieren, Terminieren und Suspendieren von „Einheiten" ist damit kaum erfaßbar. Wir decken diesen Aspekt daher durch Graphiken (z.B. Vererbungsgraphen) und zusätzliche Erläuterungen ab. Gezeigt wurde, daß eine strikte begriffliche Trennung in Programm (= Algorithmus) und Daten(struktur) die Ambivalenz zwischen beiden verdeckt (vgl. Abschnitt 1.3). Zum Verstehen von LISP-„Programmen" erscheint es sinnvoll, diese Trennlinie nicht permanent zu betonen. Wir sprechen daher im folgenden weniger von Programm- und Datenstrukturen sondern von Optionen zur Abbildung von „Einheiten".

4.1 Analyseaspekte Der Zweck einer Analyse bestimmt die Suche nach den bedeutsamen (relevanten) Konstrukten und ihrem Zerlegungsgrad. Dabei ist ein Konstrukt entweder ein „bekanntes" Konstrukt, oder es setzt sich wiederum aus zu analysierenden Konstrukten zusammen. Wir unterstellen, daß der Leser des Quellcodetextes zumindest eingebaute LISP-Konstrukte erkennen und ihre Wirkung (gegebenenfalls durch Nachschlagen im jeweiligen Referenzmanual) ihm hinreichend bekannt ist.

111

4. Verstehen einer Konstruktion

Von den mannigfaltigen Analysezwecken sind z.B. zu nennen: o Das Nachvollziehen von Ergebnissen (Output) bei vorgegebener Ausgangssituation (Input), o das Prüfen der Übereinstimmung mit der Spezifikation, o die Erweiterung des Leistungsumfangs, o die Korrektur von Fehlern, o die Veränderung des Ressourcen-Bedarfs („Tunen") und o die Portierung auf ein anderes LISP-System. Das Herausfinden und Verstehen der Konstrukte, die für den jeweiligen Analysezweck relevant sind, ist keine triviale Aufgabe. Zu beantworten sind die beiden Fragen: o Aus welchen bekannten Konstrukten besteht die Konstruktion? o Welche Wechselwirkungen (Interaktionen) bestehen zwischen diesen Konstrukten? ;;;;

T L C - L I SP

T-eval>

(LET

Lösung

zum F e s t s t e l l e n ,

ob e i n e

Zahl

N gerade

((GERADE? (LAMBDA (COND

(N) ( ( Z E R O P N) T ) (T ( U N G E R A D E ? ( S U B 1 N ) ) ) ) ) ) (UNGERADE? (LAMBDA (N) (COND ( ( Z E R O P N) N I L ) (T (GERADE? ( S U B 1 N ) ) ) ) ) ) ) (GERADE? 4 4 ) ) ==> T

;;;;

Lösung

portiert ZEROP

nach

PC

ZERO?)

Scheme

S-eval>

(DEFINE

¡einfache

Namensangleichung

S-eval>

;; Protierungsproblem: ;; - T L C - L I S P : dynamische Bindung ;; - SCHEME: s t a t i s c h e B i n d u n g (LETREC ¡ H i e r L E T R E C n i c h t LET ((GERADE? (LAMBDA (N) (COND ( ( Z E R O P N) T ) (T ( U N G E R A D E ? ( S U B 1 N ) ) ) ) ) )

!!!

ist.

112

II. Konstruktionen (Analyse und Synthese) (UNGERADE? (LAMBDA (N) (COND ((ZEROP N) NIL) (T (GERADE? (SUB1 (GERADE? 44)) ==> T P r o g r a m m f r a g m e n t 4.1-1.

Portierung

von

N))))))) TLC-LISP

nach

SCHEME

Als Beispiele analysieren wir zwei Programmfragmente (4.1-1 und 4.1-2) im Hinblick auf eine Portierung nach Scheme. Beim ersten Programmfragment ist die Beseitigung der Namensunterschiede von eingebauten Konstrukten (hier: ZEROP bzw. ZERO?) nicht ausreichend. Zu berücksichtigen sind die unterschiedliche Bindungsstrategien des namensgleichen Konstruktes LET. Etwas salopp formuliert: „Kein Verlaß auf Namen!". Im zweiten Programmfragment ist die Iteration auf direkte Weise durch einen expliziten Rücksprung mit dem GOKonstrukt und der Sprungmarke LOOP realisiert. Das Verlassen der Iteration geschieht über das RETURN-Konstrukt. Diese Aufgabe kann in Scheme entweder ein DO-Konstrukt oder eine rekursive lokale Funktion übernehmen. ;;;; Iteration mittels "go to"- Konstrukt ::;; (vgl. T a n i m o t o , 1987 , S. 32.) Tanimoto-eval>

(PROG (X Y) (SETQ X 10) (SETQ y 0) LOOP (PRINT (TIMES Y Y)) (SETQ X (SUB1 X)) (SETQ Y (ADD1 Y)) (COND ((ZEROP X) (RETURN Y))

0 1 4 9 16 25 36 49 64

81 10

;PR0G d e f i n i e r t X und Y ; als lokale Variablen

¡Verlassen der ; Iteration (T (GO LOOP)))) ==>

; jede Zahl

auf neuer

Zeile

;;;; Lösung portiert nach PC Scheme ;;; Portierungsproblem: ;;; Das Erkennen und Verstehen der "go t o " - K o n s t r u k t i o n die Auswahl der z w e c k m ä ß i g e n Lösung in Scheme. S-eva1>

und

;; Lösung mit D O - K o n s t r u k t (DO ((X 10 ( - 1 + X)) (Y 0 (1+ Y))) ((= X 0) Y) (PRINT (* Y Y))) ==> 0 1 ... S - e v a l > ;; A l t e r n a t i v e Lösung mit lokaler ;; e n d - r e k u r s i v e r Funktion (LETREC ((F00 (LAMBDA (X Y) (COND ((= X 0) Y) (T (PRINT (* Y Y)) (F00 ( - 1 + X) (1+ Y)))))))

4. Verstehen einer Konstruktion

113

(F00 10 0)) ==> 0 1 . . . Programmfragment 4 . 1 - 2 .

Portierung von einem tem nach PC Scheme

kleinem

LISP-Sys-

Für das Verstehen zum Zweck der Portierung mag das Durcharbeiten der Ouellcodetexte, beginnend von der ersten Zeile bis zum Schluß, erfolgreich sein. Handelt es sich jedoch um ein komplexes (Programm)System, dann ist für das Verstehen die sequentielle Betrachtung „Von-Anfang-bis-Ende-des-Textes" selten hilfreich. Zumindest sind in der alltäglichen Programmierpraxis schon aus Zeitgründen nicht alle Konstrukte in Notationsreihenfolge analysierbar. Das Verfolgen aller möglichen „Pfade", die sich aufgrund der Steuerungskonstrukte ergeben, scheidet wegen ihrer großen Zahl aus. Die Bewältigung der Komplexität bedingt, daß wir uns an Abstraktionsebenen orientieren.

4.2 Verbund von Konstruktor, Selektor, Prädikat und Mutator Ein komplexes Konstrukt setzt sich aus einfacheren Konstrukten zusammen. In Bild 4.2-1 besteht das Konstrukt K-l° aus den Konstrukten K-21 und K-31, wobei der Exponent hier zur Kennzeichnung des Zerlegungsgrades dient. Die analytische Betrachtung ist durch eine an der Synthese orientierten Betrachtung zu ergänzen. Das Konstrukt K-l° ist dann ein Konstruktor, der die Konstrukte K-21 und K-31 zusammenfügt. Damit ein Konstruktor die richtigen „Einheiten" zusammenfügen kann, müssen die einzelnen „Einheiten" erkannt werden. Benötigt werden daher passende Erkennungskonstrukte (engl.: recognizer). Erforderlich ist in unserem Beispiel ein Konstrukt, das feststellt, ob es sich bei einer gegebenen „Einheit" um K-2 handelt oder nicht. Ein solches Erkennungskonstrukt verhält sich wie ein Prädikat wie z.B. das NUMBER?-Konstrukt, das prüft, ob ein numerischer Wert vorliegt. Zu einem Konstruktor, der n-verschiedene „Einheiten" zusammenfügt, benötigen wir n-verschiedene Prädikate zum Erkennen der einzelnen „Einheit". Wir definieren daher für unseren Konstruktor K-l die korrespondierenden Prädikate K-2? und K-3?. Auf der nächst tieferen Abstraktionsebene, hier Ebene 1, wären z.B. für den Konstruktor K-3 die Prädikate K-6?, K-7? und K-8? zu definieren. Zusätzlich benötigen wir korrespondierende Selektoren, um bei einem zusammengesetzten Konstrukt auf seine einzelnen „Einheiten" zugreifen zu können. Die Selektoren haben die Aufgabe der Umkehrung der Konstruktor-Wirkung. Für den Konstruktor K-l im Bild 4.2-1 wären folgende Selektoren zu definieren: eval> (SELEKTOR-K-2 K-l) ==> K-2 eval> (SELEKTOR-K-3 K-l) ==> K-3

114

II. Konstruktionen (Analyse und Synthese)

Abstrakti ons ebene bzw. Zerlegungsgrad

Legende:

K-i J —>

::= Konstrukt mit der Identifizierungsnummer i auf der Abstrakionsebene j o ::= "Setzt-sich-zusammen", z.B. s e t z t sich K-5^ aus 5 J K-9- und K- 10 zusammen

Bild 4 . 2 - 1 .

Skizze

einer

Konstrukte-Hierarchie

(Modul-Hierarchie)

Die Analyse und damit das Verstehen werden erleichtert, wenn wir von folgenden Eigenschaften bei unserem Verbund aus Konstruktoren, Selektoren und Prädikaten ausgehen können: eva1> (SELETOR-K-2 (KONSTRUKTOR-K-1 K-2 K-3)) eval> (SELETOR-K-3 (KONSTRUKTOR-K-1 K-2 K-3)) eval> (K-2? (SELETOR-K-2 (KONSTRUKTOR-K-1 K-2 K-3))) ==> eval> (K-3? (SELETOR-K-3 (KONSTRUKTOR-K-1 K-2 K-3))) ==>

==> K-2 ==> K-3 #T #T

Wir streben daher für alle Abstraktionsebenen diese Verbundeigenschaften an. Sie sind allgemein, wie folgt, beschreibbar:

4. Verstehen einer Konstruktion

115

Der Verbund von Konstruktoren, Selektoren und Prädikaten ermöglicht Neukonstruktionen. Soll eine bestehende Konstruktion geändert, also nicht von Anfang an neu zusammengesetzt werden, dann sind Modifikations-Konstrukte, sogenannte Mutatoren, erforderlich. Betrachten wir z.B. ein Konto, von dem ein Geldbetrag abzubuchen ist, dann wollen wir (wahrscheinlich) mit einem Konstrukt ABBUCHEN! das bestehende Konto im Saldo ändern, d.h. modifizieren und nicht ein ganz neues Konto anlegen und alle alten Buchungen rekonstruieren und dann die neue Buchung zusätzlich vollziehen (vgl. Beispiel in Abschnitt 1.4.2). In den folgenden Ausführungen dient dieser Verbund als pragmatischer Leitfaden. Er ist kein Patentrezept („Allheilmittel"). Er ersetzt keinesfalls intensives Durchdenken einer Konstruktion. Er hilft jedoch eine komplexe Aufgabe zweckmäßig in weniger komplexe Teile zu gliedern.

4.3 LISP-Klassiker: „Symbolisches Differenzieren" Als Analysebeispiel betrachten wir das Differenzieren einer mathematischen Funktion anhand des Programms 4.3-1. Diese Aufgabenstellung ist ein LISPKlassiker. Sie war das „Markenzeichen" beim Start der LISP-Entwicklung. Sie ist noch heute für Erläuterungszwecke aktuell (vgl. z.B. Abelson/Sussman/Sussman, 1985, p. 104; Müller, 1985, S.13ff, Wagner, 1987, S. B-lff, Weissman, 1967, p. 16 , oder Winston/Horn, 1987, dt.Ausgabe S.276 ff). Wir nutzen den Vorzug, daß sie einerseits in LISP einfach (rekursiv) lösbar ist und andererseits keiner langen Erläuterung bedarf (Schulmathematik, vgl. z.B. Scheid, 1985).

116

II. Konstruktionen (Analyse und Synthese)

Das Programm ABLEITUNGSFUNKTION (4.3-1) faßt die lokal definierten Konstruktoren, Selektoren und Prädikate zusammen. Es hat folgende Struktur: eval> (DEFINE ABLEITUNGSFUNKTION ( L A M B D A ( M A T H E M A T I S C H E R _ A U S D R U C K DX) (LETREC ;;;; P r ä d i k a t e f ü r K o n s t a n t e u n d V a r i a b l e ( ( K O N S T A N T E ? ... ) (VARIABLE? ... ) ( G L E I C H E - V A R I A B L E ? ... ) ;;;; P r ä d i k a t e , S e l e k t o r e n und K o n s t r u k t o r e n ( S U M M E ? ... ) ( E R S T E R - S U M M A N D ... ) ( Z W E I T E R - S U M M A N D ...) ( B I L D E - S U M M E ...) ( V E R E I N F A C H E - S U M M E ... ) ;;;; P r ä d i k a t e , S e l e k t o r e n u n d K o n s t r u k t o r e n ( P R O D U K T ? ... ) ( M U L T I P L I K A N D ... ) ( M U L T I P L I K A T O R ... ) ( B I L D E - P R O D U K T ... ) ( V E R E I N F A C H E - P R O D U K T ... ) ;;;; Abi ei t u n g s r e g e l n (ABLEITEN (LAMBDA (COND ...)))

(FORMEL

für

die

Summenregel

für

die

Produktregel

VARIABLE) ; F a l 1 u n t e r s c h e i d u n g für die ; anzuwendende Ableitungsregel

;; A n w e n d u n g d e r l o k a l e n F u n k t i o n (ABLEITEN MATHEMATISCHER.AUSDRUCK DX)))) ==>

ABLEITUNGSFUNKTION

Beim Aufruf des Konstruktes ABLEITEN ist die LAMBDA-Variable FORMEL an den abzuleitenden mathematische Ausdruck gebunden. Mit Hilfe der Prädikate SUMME? und PRODUKT? wird erkannt, ob es sich um eine Summe oder ein Produkt handelt. In diesen Fällen ist der Wert von FORMEL ein zusammengesetzes Konstrukt, dessen einzelne Teile zur Anwendung der entsprechenden Ableitungsregel benötigt werden. Im Fall der Summe sind deshalb die Selektoren ERSTER-SUMMAND und ZWEITER-SUMMAND definiert. Für das Produkt sind es die Selektoren MULTIPLIKAND und MULTIPLIKATOR. Die Benennung der lokalen Funktionen und Kommentierung entsprechen den Empfehlungen von Abschnitt 11. In dem kurzen Programmvorspann verweist daher die Abkürzung A auf eine Anforderung und die Abkürzung T auf Testfälle. Dokument 4.3-1 Titel: Programm ABLEITUNGSFUNKTION Erstellt: 05.09.89 ¡letzte Ä n d e r u n g :

18.10.90

AI

A B L E I T U N G S F U N K T I O N e r m i t t e l t die A b l e i t u n g einer m a t h e m a t i s c h e n Formel n a c h e i n e r v o r g e g e b e n V a r i a b l e n .

A2

Für d i e s e s s y m b o l i s c h e D i f f e r e n z i e r e n folgenden Ableitungsregeln:

gelten

die

4. Verstehen einer Konstruktion A2.1 A2.2

Ableiten einer Ableiten einer du/dx

A2.3 A2.4

Summenregel: Produktregel:

A3

Die a b z u l e i t e n d e anzugeben.

T1

Beispiel:

117

K o n s t a n t e n : dc/dx ==> 0 Variablen: = = > 1 f a l l s u=x ;x n a c h x a b g e l e i t e t 0 sonst d ( u + v ) / d x = = > du/dx + d v / d x d ( u * v ) / d x ==> (du/dx)*v + u * ( d v / d x ) Formel

ist

in

d(ax2

+ bx + c ) / d x = = > 2ax + b

eval>

(ableitungsfunktion ' ( + (+ ( * a (* x x ) )

Wert d e r Bei s p i e l s f u n k t i o n m i t a : = 3 und b := 5 eval>

(ableitungswert ' ( + (+ (* a ( *

Präfixnotation

( * b x ) ) c) ' x ) = = > ( + ( * a (* 2 x))

an d e r S t e l l e

x x))

(*

b x))

c)

x

:= 1

'x

1) = = >

( D E F I N E A B L E I T U N G S F U N K T I O N (LAMBDA (MATHEMATISCHER_AUSDRUCK (LETREC ( ( K O N S T A N T E ? (LAMBDA ( X ) (NUMBER? X ) ) ) ( V A R I A B L E ? (LAMBDA ( X ) (SYMBOL? X ) ) ) (GLEICHE-VARIABLE? (LAMBDA ( V A R _ 1 VAR_2) (AND ( V A R I A B L E ? VAR_1) ( V A R I A B L E ? VAR_2) ( E Q ? VAR_1 V A R _ 2 ) ) ) ) ; ; ; ; K o n s t r u k t o r , S e l e k t o r e n und P r ä d i k a t f ü r d i e Summe ;;; ;;;

E r k e n n e n e i n e r a b z u l e i t e n d e n Summe: und S e l e k t i e r e n i h r e r Summanden. (SUMME? (LAMBDA ( X ) (AND ( P A I R ? X) (OR ( E Q ? (CAR X) ( E Q ? (CAR X)

(+ u v)

bzw.

Konstruktoren

für

die

'+) 'PLUS)))))

"rechte"

(BILDE-SUMME (LAMBDA ( S _ l S _ 2 ) ( L I S T ' + S_1 S _ 2 ) ) )

Seite

der

11 DX)

(PLUS u v)

(ERSTER-SUMMAND (LAMBDA (SUMME) ( L I S T - R E F SUMME 1 ) ) ) (ZWEITER-SUMMAND (LAMBDA (SUMME) ( L I S T - R E F SUMME 2 ) ) ) ;;;

b)

Summenregel

118

II. Konstruktionen (Analyse und Synthese) ( V E R E I N FACHE-SUMME (LAMBDA (SUMME) ( L E T ( ( S - l ( E R S T E R - S U M M A N D SUMME) ( S - 2 (ZWEITER-SUMMAND SUMME))) (COND ( ( A N D ( N U M B E R ? S - l ) ( N U M B E R ? S - 2 ) ) ( + S - l ((AND (NUMBER? S - l ) (ZERO? S - l ) ) S - 2 ) ((AND (NUMBER? S - 2 ) (ZERO? S - 2 ) ) S - l ) ((GLEICHE-VARIABLE? S - l S-2) (BILDE-PRODUKT 2 S - l ) ) (T S U M M E ) ) ) ) ) ; Konstruktor,

Selektoren

und

Prädikat

für

Erkennen eines abzuleitenden Produktes: (* (MUL u v ) u n d S e l e k t i e r e n v o n M u l t i p l i k a n d (PRODUKT? (LAMBDA ( X ) (AND ( P A I R ? X ) (OR ( E Q ? ( C A R (EQ? (CAR

X) X)

das

S-2))

Produkt

u v ) bzw. und M u l t i p l i k a t o r .

'*) 'MUL)))))

( M U L T I P L I K A N D ( L A M B D A ( P R O D U K T ) ( L I S T - R E F PRODUKT 1 ) ) ) ( M U L T I P L I K A T O R ( L A M B D A ( P R O D U K T ) ( L I S T - R E F PRODUKT 2 ) ) ) K o n s t r u k t o r e n für die " r e c h t e " S e i t e der Produktregel (BILDE-PRODUKT (LAMBDA ( M _ l M_2) ( L I S T ' * M _ 1 M_ 2 ) ) ) ( V E R E I N F A C H E - PRODUKT (LAMBDA (PRODUKT) (LET ( ( M - 1 (MULTIPLIKAND PRODUKT)) (M-2 (MULTIPLIKATOR PRODUKT))) (COND ( ( O R ( A N D ( N U M B E R ? M - l ) ( Z E R O ? M - l ) ) (AND ( N U M B E R ? M - 2 ) ( Z E R O ? M - 2 ) ) ) ( ( E Q ? M - l 1) M - 2 ) ( ( E Q ? M-2 1) M - l ) ((AND (NUMBER? M - l ) (NUMBER? M - 2 ) ) ( * (T P R O D U K T ) ) ) ) ) ;

0) M-l

M-2))

Ableitungsregeln ( A B L E I T E N (LAMBDA (FORMEL V A R I A B L E ) (COND ( ( K O N S T A N T E ? F O R M E L ) 0 ) ;dc/dx ==> 0 ( ( V A R I A B L E ? FORMEL) (COND ( ( G L E I C H E - V A R I A B L E ? ;dx/dx ==> 1 FORMEL V A R I A B L E ) 1 ) (T 0 ) ) ) ( ( S U M M E ? FORMEL) ;Summenregel ( V E R E I N FACHE-SUMME (BILDE-SUMME ( A B L E I T E N (ERSTER-SUMMAND FORMEL) V A R I A B L E ) ( A B L E I T E N (ZWEITER-SUMMAND FORMEL) VARIABLE))))

4. Verstehen einer Konstruktion

119

((PRODUKT? FORMEL) ;Produktregel (VEREINFACHE-SUMME (BILDE-SUMME (VEREIN FACHE-PRODUKT (BILDE-PRODUKT (ABLEITEN (MULTIPLIKAND FORMEL) VARIABLE) (MULTIPLIKATOR FORMEL))) (VEREIN FACHE-PRODUKT (BILDE-PRODUKT (MULTIPLIKAND FORMEL) (ABLEITEN (MULTIPLIKATOR FORMEL) VARIABLE)))))) (T ( W R I T E L N ¡sonst "Keine Ableitung fuer: " FORMEL " definiert")))))) ; ; Startfunktion (ABLEITEN MATHEMATISCHER_AUSDRUCK DX)))) ;;;;

Berechnung

eines

Wertes

der

Ableitungsfunktion

(DEFINE ABLEITUNGSWERT ( L A M B D A ( M A T H E M A T I S C H E R _ A U S D R U C K DX A N _ D E R _ S T E L L E ) ((EVAL (LIST 'LAMBDA ( L I S T DX) (ABLEITUNGSFUNKTION MATHEMATISCHER_AUSDRUCK AN_DER_STELLE))) Programm 4.3-1.

Symbolisches

DX)))

Differenzieren

Die Ableitungsregel für eine Summe (kurz: Summenregel) lautet: d(u+v)/dx

==>

du/dx +

dv/dx

Das Ergebnis, die rechte Seite der Summenregel, ist ein zusammengesetzter Ausdruck, der wieder eine Summe darstellt. Das Zusammenfügen von du/dx mit dv/dx übernimmt der Konstruktor BILDE-SUMME. Entsprechendes gilt für die Produktregel: d(u*v) ==>

(du/dx)*v

+

u*(dv/dx)

Hier setzt der Konstruktor BILDE-PRODUKT in Kombination mit BILDESUMME das Ergebnis zusammen. Nehmen wir als Beispiel an, daß S_ 1 an den Wert 5 und S_ 2 an den Wert 7 gebunden sind, so daß gilt: eval>

(BILDE-SUMME

S_1

S_2) ==>

(+ 5 7)

Um dieses Ergebnis zu vereinfachen, können wir statt (+ 5 7) den Wert 12 zurückgeben. Die Vereinfachung der gebildeten Summe übernimmt das Konstrukt VEREINFACHE-SUMME, das dazu auf Teile der gebildeten Summe zugreifen muß. Für den Konstruktor BILDE-SUMME benötigen wir korrespondierende Selektoren, damit VEREINFACHE-SUMME auf seine Teile zugreifen kann. Das Konstrukt BILDE-SUMME gibt eine Liste mit dem Additionsoperator

120

II. Konstruktionen (Analyse und Synthese)

als erstes Element (Präfixnotation) zurück. Damit erzeugt BILDE-SUMME die gleiche Struktur wie bei einer eingegebenen Summe, die es abzuleiten gilt, d.h. der Wert an den FORMEL gebunden ist. Wir können daher für VEREINFACHE-SUMME auf dieselben Selektoren zurückgreifen. ERSTER-SUMMAND und ZWEITER-SUMMAND sind damit (auch) die korrespondierenden Selektoren zu BILDE-SUMME. Entsprechendes gilt für den Konstruktor BILDE-PRODUKT mit seinen Selektoren MULTIPLIKAND und MULTIPLIKATOR in Verbindung mit VEREINFACHE-PRODUKT (vgl. Bild 4.3-1.). /Hinweis: Selektoraufgabe. Die Doppelaufgabe der Selektoren ERSTER-SUMMAND und ZWEITER-SUMMAND, d.h. einerseits den Wert von FORMEL und andererseits den von BILDE-SUMME erzeugten zu „zerlegen", macht sich bei einer Programmänderung erschwerend bemerkbar. Dies gilt entsprechend auch für die Selektoren MULTIPLIKAND und MULTIPLIKATOR. Wollen wir z.B. auf Infix-Notation bei der Eingabe (Wert für FORMEL) übergehen und die Präfix-Notation für BILDE-SUMME beibehalten, dann muß die Doppelfunktion erkannt werden. Jeweils passende Selektoren sind dann neu zu programmieren.7 Im Sinne unserer angestrebten Verbundeigenschaft (vgl. Abschnitt 4.2) gilt in dem Konstrukt ABLEITEN z.B.: eval> eval> eval> eval>

(ERSTER-SUMMAND (BILDE-SUMME 5 7 ) ) ==> 5 (ZWEITER-SUMMAND (BILDE-SUMME 5 7 ) ) ==> 7 (MULTIPLIKAND (BILDE-PRODUKT 2 3)) ==> 2 (MULTIPLIKATOR (BILDE-PRODUKT 2 3 ) ) ==> 3

In der Programmier(alltags)praxis wird diese Eigenschaft einer Konstruktion kaum beachtet und selten realisiert (vgl. z.B. die Lösungen zur Ableitungsaufgabe in der oben genannten Literatur). Bezogen auf das Programm ABLEITEN wäre z.B. die folgende Lösung weniger zweckmäßig, wenn als korrespondierende Selektoren ERSTER-SUMMAND und ZWEITER-SUMMAND beibehalten werden. Sie faßt die Konstruktoren VEREINFACHE-SUMME mit BILDESUMME zu einem Konstrukt MAKE-SUMME zusammen: eval>

( D E F I N E MAKE-SUMME (LAMBDA ( S _ l (COND ( ( A N D ( N U M B E R ? S _ l ) ((AND (NUMBER? S _ l ) ((AND (NUMBER? S _ 2 ) ((GLEICHE-VARIABLE? (LIST ' * 2 S_1)) (T ( L I S T ' + S _ 1 S _ 2 )

S_2) (NUMBER? S _ 2 ) ) ( + S _ 1 (ZERO? S _ l ) ) S_2) (ZERO? S _ 2 ) ) S _ l ) S_1 S_2) ) ) ))

==>

S_2))

MAKE-SUMME

Die Selektion eines Summanden wäre bei diesem Konstruktor nicht in jedem Fall mehr möglich. eval>

(ERSTER-SUMMAND = = > ERROR . . .

(MAKE-SUMME 5 7 ) ) ¡Grund: ( L I S T - R E F

12

1)

!

4. Verstehen einer Konstruktion

121

ABLEITEN

Ableiten einer Konstanten dc/dx = >

Ableiten einer Variablen du/dx ==> 1; u=x 0; sonst

Linke Seite: Linke Seite: P: KONSTANTE? P: VARIABLE? —>SYMB0L? -> NUMBE GLEICHEVARIABLE? -> EQ?

Ableiten einer Summe diu + i ) l dx = > du/dx + dv/dx

Ableiten eines Produktes d(u*v)/dx = > (du/dx)*v + u*(dv/dx)

Linke Seite: Linke Seite: P: SUMME? - > PAIR?, EQ? - > PAIR?.EQ?, CAR CAR S: ERSTER-SÜMMAND S: MULTIPLKAND ZUEITER-SUMMAND MULTIPLIKATOR -> CAR, CDR -> CAR, CDR Rechte Seite: K: BILDE-SUMME -> LIST, + VEREINFACHESUMME -> +, BILDE-f S: siehe Linke Seite

Rechte Seite: K: BILDE-PRODUKT, BILDE-SUMME -> LIST, *, + VEREIN FACHE S: siehe Linke Seite

Legende

= = = = = =

Linke Seite der entsprechenden Ableitungsregel Rechte Seite der entsprechenden Ableitungsregel Prädikat (Erkennungskonstrukt) Selektor Konstruktor basiert auf; z.B. basiert KONSTANTE? auf dem eingebauten NUMBER?-Konstrukt = Kennzeichnung einer Selektion (vgl. Abschnitt I I I ) B i l d 4 . 3 - 1 . Strukturskine

d e s Programs

4.3-1.

4.4 Zusammenfassung: Abstraktionsebene Der „Denkrahmen" des Konstrukteurs, allgemein als Paradigma bezeichnet, wird bestimmt von charakteristischen Konstruktionen, die z.B. imperativ-, funktions- oder objektgeprägt sind. Ein Paradigma umfaßt elementare Konstrukte, Verknüpfungs- und Abstraktionsmittel.

122

II. Konstruktionen (Analyse und Synthese)

Wir betrachten eine Konstruktion auf den verschiedenen Abstraktionsebenen als einen Verbund von: o Konstruktor, o Selektor (incl. Präsentator), o Prädikat und o Mutator (incl. Destruktor). Von diesem Verbund fordern wir: Die Bausteine, die ein Konstruktor zusammenfügt, müssen von Prädikaten erkannt und durch Selektoren ohne Verlust wiedergewonnen werden können. Charakteristisches

Beispiel für Abschnitt 4\

;;;; Abbildung eines Formulars ;;; Untere A b s t r a k t i o n s e b e n e : e v a l > ;; K o n s t r u k t o r (DEFINE BILDE-LEERES-FORMULAR (LAMBDA ( ) ( L I S T ' * K 0 P F * ' * T E X T * ;;; Prädikate e v a l > ( D E F I N E KOPF? (LAMBDA ( X ) e v a l > ( D E F I N E T E X T ? (LAMBDA ( X ) e v a l > ( D E F I N E F U S S ? (LAMBDA ( X ) e v a l > (DEFINE LEERES-FORMULAR? (LAMBDA ( X ) (AND ( P A I R ? X ) (EQ? ( L I S T - R E F X (EQ? ( L I S T - R E F X (EQ? ( L I S T - R E F X (EQ? ( L I S T - R E F X

(STRING? (STRING? (STRING?

0) 1) 2) 3)

'*FUSS* '*F0RM*))) ==> BILDE-LEERES-FORMULAR X))) X))) X)))

==> ==> ==>

KOPF? TEXT? FUSS?

'*K0PF*) '*TEXT*) '*FUSS*) '*F0RM)))) ==> LEERES-FORMULAR?

; ; ; Nächst höhere A b s t r a k t i o n s e b e n e : e v a l > ;; K o n s t r u k t o r (DEFINE BILDE-FORMULAR (LAMBDA (KOPF TEXT FUSS) ( I F (AND ( K O P F ? K O P F ) ( T E X T ? T E X T ) ( F U S S ? F U S S ) ) ( C O N S KOPF (CONS TEXT (CONS FUSS (CDDDR (BILDE-LEERES-FORMULAR)))))))) ==> BILDE-FORMULAR e v a l > ;; P r ä d i k a t ( D E F I N E FORMULAR? (LAMBDA ( X ) (OR ( L E E R E S - F O R M U L A R ? X ) (AND ( P A I R ? X ) ( E Q ? ( L I S T - R E F X 3 ) ' * F 0 R M * ) ) ) ) ) = = > FORMULAR? ;;; Seiektoren e v a l > ( D E F I N E GET-KOPF (LAMBDA ( X ) (COND ( ( F O R M U L A R ? X ) ( L I S T - R E F X 0 ) ) (T (ERROR " K e i n F o r m u l a r : " X ) ) ) ) ) e v a l > (DEFINE GET-TEXT (LAMBDA ( X ) (COND ( ( F O R M U L A R ? X ) ( L I S T - R E F X 1 ) ) (T (ERROR " K e i n F o r m u l a r : " X ) ) ) ) )

==>

GET-KOPF

==>

GET-TEXT

5. Abbildungsoption: Liste

123

eval>

(DEFINE GET-FUSS (LAMBDA ( X ) (COND ( ( F O R M U L A R ? X ) ( L I S T - R E F X 2 ) ) (T ( E R R O R " K e i n F o r m u l a r : " X ) ) ) ) . ) :;; Mutatoren ; ; ; H i n w e i s : D a s S E T - C A R ! - K o n s t r u k t w i r d e r s t im A b s c h n i t t 5 ; ; ; e r l ä u t e r t . E s i s t h i e r e r f o r d e r l i c h , um e i n e x i s t i e r e n d e s : ; ; F o r m u l a r , das durch e i n e L i s t e a b g e b i l d e t ist, ; ; ; m o d i f i z i e r e n zu können, eval> (DEFINE SET-KOPF! (LAMBDA (IF

(KOPF

(AND

FORM)

(KOPF?

KOPF)

(FORMULAR?

FORM))

(BEGIN (SET-CAR! FORM)))) eval>

(DEFINE

KOPF)

SET-KOPF!

SET-TEXT!

(LAMBDA (IF

FORM ==>

(TEXT

(AND

FORM)

(TEXT?

TEXT)

(FORMULAR?

FORM))

(BEGIN (SET-CAR! FORM)))) eval>

(DEFINE

FORM)

TEXT)

SET-TEXT!

SET-FUSS!

(LAMBDA (IF

(CDR ==>

(FUSS

(AND

FORM)

(FUSS?

FUSS)

(FORMULAR?

FORM))

(BEGIN (SET-CAR! FORM)))) ;;;; eval>

(CDDR ==>

FORM)

FUSS)

SET-FUSS!

Bei s p i e l (DEFINE

F-l

(BILDE-FORMULAR

"Baw"

"Bescheid"

"Stand:

Alt")) ==>

eval>

(GET-TEXT

F-l)

==>

eval>

(GET-FUSS

(SET-FUSS!

F-l

"Bescheid" "Stand:

Neu"

F-l))

==>

"Stand:

Neu"

5. Abbildungsoption: Liste Für die Abbildungsoption „Liste" haben wir bisher den Konstruktor CONS, die Selektoren CAR und CDR sowie die Prädikate NULL? und ATOM? in unterschiedlichen Zusammenhängen genutzt. Es wurden z.B. neue Listen erzeugt, Elemente am Anfang einer Liste eingefügt, Listen aneinander gekoppelt, die Reihenfolge der Elemente umgedreht oder die Länge einer Liste bestimmt. Wir können die Liste im Sinne einer Signatur (vgl. Abschnitt 1.4) mit diesen Opera-

124

II. Konstruktionen (Analyse und Synthese)

tionen definieren (vgl. Bild 5-1). Dabei unterstellen wir eine endliche, nicht zirkuläre Liste.

Legende: CD -•-

::= Wertebereich ::= Operation

Bild 5-1. Signatur einer endlichen, nicht zirkulären Liste

Vergleicht man das Konzept der Liste mit dem der Menge, dann sind zwei Aspekte bedeutsam: o die Berücksichtigung der Reihenfolge und o das mehrfache Vorkommen gleicher Elemente (Multiplizität). Die Liste ist ein Konzept mit Reihenfolge und Multiplizität. Die Menge (engl.: set) ist ein Konzept ohne Reihenfolge und ohne Multiplizität. Konzepte ohne Reihenfolge, aber mit Multiplizität werden „bags" oder „multisets" genannt (z.B. in Smalltalk, vgl. Goldberg/Robson, 1983). Für den Selektor läßt sich Multiplizität auch mit Hilfe einer zirkulären Liste simulieren. Bei ihr ist der Nachfolger des (quasi) letzten Elementes das erste Element der Liste („Die Katze beißt sich in den Schwanz!"). Wir nutzen die zirkulären Liste im Beispiel „Verwalten von Arbeitsvorgängen" (Abschnitt 5.1). Dabei unterstellen wir einen Manager, der für größere Arbeiten eine Bearbeitsungsreihenfolge festlegt. Zur Wiederholung der bisher verwendeten ListenKonstrukte zeigen wir die Lösung zunächst ohne Listen-Mutatoren. Mit destruktiven Listenveränderungen definieren wir anschließend die Lösung abgebildet als zirkuläre Liste. Zur Konstruktion einer zirkulären Listen wird eine schon existierende Liste modifiziert. Zum leichteren Verstehen dieser Listen-Mutatoren befassen wir uns

5. Abbildungsoption: Liste

125

mit CONS-Zellen-Skizzen (vgl. Abschnitt 2.1, Bild 2.1-2). Mit diesen CONSZellen-Strukturen sind keinesfalls alle realisierten Implementationen einer Liste beschrieben (vgl. z.B. LISP-Maschinen; Anhang B). Eine übliche Abweichung ist die Reihenfolge von CAR- und CDR-Teil. Weil die Applikation des CDRKonstruktes häufiger vorkommt als die des CAR-Konstruktes, stellen z.B. in einer CONS-Zelle von 8 Byte Länge die ersten vier Bytes den CDR-Teil dar. Die Assoziationsliste (kurz A-Liste) behandeln wir anhand der Definition eines Kontos (Abschnitt 5.2). Die Eigenschaftliste (engl.: property list; kurz PListe) wird mit dem Beispiel „Laufmappen-Transportsteuerung" erläutert. In einem Bürogebäude ist für die Steuerung eines mechanischen Fließbandsystems ein Weg zwischen Start- und Ziel-Schreibtisch zu ermitteln. Dazu programmieren wir die beiden Suchalgorithmen „Depth First" und „A*" (Abschnitt 5.3). Beispiel:

Verwalten von

Arbeitsvorgängen

Ein Manager bearbeitet seine größeren Aufgaben nach einem Zyklusverfahren. Abhängig vom aktuellen Tagesgeschehen widmet er sich eine Zeit lang einem Vorgang, dann geht er zum nächsten Vorgang über. Hat er alle Vorgänge bearbeitet, fängt er wieder von vorn an. Fertige Vorgänge werden aus diesem Bearbeitungszyklus entfernt. Neue Vorgänge werden fallabhängig in den Zyklus eingeordnet. Zu einem Zeitpunkt t hat er z.B.folgende Vorgänge zu bearbeiten: 1. „Über die Investition Lagerhalle West entscheiden", 2. „Zeugnis für den Abteilungsleiter Meier diktieren" und 3. „Budgetplanung für die Zentralabteilung aufstellen". Die globale Variable *ARBEITSPLAN* stellt diese Vorgänge und ihre Reihenfolge durch eine Liste dar: eval >

(DEFINE_.^ARBEITSPLAN* ( L I S T " Ü b e r d i e I n v e s t i t i o n L a g e r h a l l e West e n t s c h e i d e n " " Z e u g n i s f ü r den A b t e i l u n g s l e i t e r M e i e r d i k t i e r e n " "Budgetplanung für die Zentralabtei1ung aufstellen")) ==> *ARBEITSPLAN*

Der Bearbeitungszyklus könnte auf der Grundlage dieser einfach strukturierten Liste, wie folgt, realisiert werden: eval>

( D E F I N E VORGANGSVERWALTUNG ( L A M B D A ( ) (LETREC ((ANFORDERUNG (LAMBDA ( ) ( B E G I N (WRITELN " Z e i g e n a e c h s t e n (ZYKLUS (LET

(NEWLINE) Vorgang? J/N:")) (READ)))

(LAMBDA ( L I S T E ) ((ANTWORT ( A N F O R D E R U N G ) ) ) (COND ( ( E Q ? ANTWORT * J )

126

II. Konstruktionen (Analyse und Synthese) (COND ;; U m s c h a l t e n ; ; der ((NULL?

auf den

Anfang

Li s t e LISTE)

(PRINT (CAR * A R B E I T S P L A N * ) ) (ZYKLUS (CDR * A R B E I T S P L A N * ) ) ) ;; Ü b e r g a n g a u f d a s n ä c h s t e ;; E l e m e n t (T

(PRINT

(CAR

(ZYKLUS (T (COND

((NULL? (T

LISTE)))))

"Ende"))))))

*ARBEITSPLAN*)

(ZYKLUS

LISTE)) (CDR

"Keine

Aufgaben")

^ARBEITSPLAN*))))) ==>

VORGANGSVERWALTUNG

Das Hinzufügen eines neuen Vorganges oder das Herausnehmen eines fertigen Vorganges ermöglicht der Mutator SET! in Verbindung mit dem Konstruktor CONS und dem Selektor CDR. Wir können als entsprechende Beispiele definieren: eval>

;; V o r g a n g h i n z u f ü g e n (SET! * A R B E I T S P L A N * (CONS ==>

eval>

("Urlaubstermin

"Urlaub festlegen" *ARBEITSPLAN*)) f e s t l e g e n " "Über die

..."

... )

;; E r s t e n V o r g a n g l ö s c h e n (SET! * A R B E I T S P L A N * (CDR * A R B E I T S P L A N * ) ) = = > ( " Ü b e r d i e ... " ... )

Die Veränderung des Symbolwertes leistet das SET!-Konstrukt, weil es in der jeweiligen Umgebung, hier USER-INITIAL-ENVIRONMENT, das Symbol an den neuen Wert bindet (vgl. Abschnitt 1.4.2). Wir können das SET!-Konstrukt auch als Mutator des Zeigers *ARBEITSPLAN* auffassen, der auf die erste CONS-Zelle der Liste zeigt (vgl. Bild 5.-1). Mit dem SET!-Konstrukt kann ein Zeiger, der auf eine CONS-Zelle zeigt, auf eine andere vorhandene CONS-Zelle gesetzt werden. Die Zeiger des CAR-Parts bzw. des CDR-Parts einer CONS-Zelle bleiben davon unberührt. Für ihre Änderung gibt es eigene Mutatoren, die Konstrukte SET-CAR! und und SET-CDR!. Mutatoren für die

CONS-Zelle:

eval> eval>



(SET-CAR! (SET-CDR!

) — > ) — >



mit:

::= S y m b o l i s c h e r A u s d r u c k , d e r e i n e C O N S Zelle als Wert hat. C m o d i f i z i e r t e - z e l 1 e > : : = C O N S - Z e l l e mit d e m W e r t von < s e x p r > im C A R - o d e r C D R - T e i l

5. Abbildungsoption: Liste

127

Die beiden Mutatoren SET-CAR! und SET-CDR! haben die Aufgabe, dem CAR- bzw. CDR-Teil einer existierenden CONS-Zelle einen neuen Wert zu geben. Dazu werten sie ihre Argumente aus. Da wir sie nur für diesen Nebeneffekt verwenden (sollten!), ist ihr eigener Wert prinzipiell nicht spezifiziert. /Hinweis: RPLACA und RPLACD. In vielen LISP-Implementationen, so z.B. in Common LISP, haben diese Mutatoren die klassischen Namen: RPLACA (Akronym für RePLAce the CAr of ...) und RPLACD (Akronym für RePLAce the CDt of...).] Beispiele:

evaf> eval> eval> eval> eval>

(DEFINE F00 '(A B C D)) ==> (A B C D) (SET-CAR! F00 (* 2 3)) ==> (6 B C D) (SET-CDR! F00 '(X Y)) ==> (6 X Y) (SET-CDR! F00 (* 3 3)) ==> (6 . 9) F00 ==> (6 . 9)

Die Mutatoren SET-CAR! und SET-CDR! können Tansparenz-Probleme bewirken. Nicht leicht durchschaubare Nebeneffekte sind formulierbar, wie das folgende Beispiel zeigt: eval> (DEFINE F00 (CONS (CONS T T) (CONS T T ) ) ) ==> ((#T . #T) #T . #1) eval> (DEFINE BAR (LET ((X (CONS T T))) (CONS X X))) ==> ((#T . #T) #T . #T) eval> (EQUAL? F00 BAR) ==> #T eval> (SET-CDR! (CDR F00) 'NEU) ==> (#T . NEU) eval> (SET-CDR! (CDR BAR) 'NEU) ==> (#T . NEU) Nachdem sowohl auf FOO wie auf BAR die gleiche SET-CDR .'-Formulierung angewendet wurde, erwartet man spontan, daß „Gleiches" weiterhin gleich ist, d.h. (EQUAL? FOO BAR) weiterhin den Wert #T hat. Dies ist jedoch nicht der Fall! eval> (EQUAL? FOO BAR) ==> () eval> FOO ==> ((#T . #T) #T . NEU) eval> BAR ==> ((#T . NEU) #T . NEU) Dieser Nebeneffekt leuchtet unmittelbar ein, wenn man das CONS-Zellen-Modell für FOO und BAR betrachtet. Das Bild 5-3 zeigt diese vor der Applikation des Mutators SET-CDR!. Problematisch sind Mutatoren immer dann, wenn ihre „Zerstörung" sich auf mehrfach genutzte „Objekte" bezieht. Als Merksatz formuliert: Sind Mutatoren dabei, dann ist „Gleiches durch Gleiches" nicht einfach ersetzbar. (Näheres zur Semantik destruktiver Konstrukte, vgl. z.B. Mason, 1986).

128

II. Konstruktionen (Analyse und Synthese)

Ausgangssituation: (DEFINE *ABEITSPLAN* (LIST " E l e m e n t 1" " E l e m e n t *ARBEITSPLAN*-

2" " E l e m e n t

3")) ==> *ARBEITSPLAN* NIL

->n v "Element

(SET! * A R B E I T S P L A N * ^ARBEITSPLAN*—i

(CDR

1"

v "Element

2"

*ARBEITSPLAN*)) ==> ("Element o-

• "Element

1"

"Element

3"

2" " E l e m e n t

o-

->ül

v " E l e m e n t 2"

3")

NIL

v "Element

3"

(SET! * A R B E I T S P L A N * (CONS " N e u e E l e m e n t " * A R B E I T S P L A N * ) ) = = > ( " N e u e E l e m e n t " " E l e m e n t 2" " E l e m e n t 3") *ARBEITSPLAN*—i

G

" Element

0-

1"

o-

"Element

• > u

2"

"Element

- D v "Neue

Element"

Legende: CAR- CDRPart Part

::=

o

::=

>

CONS-Zelle Zeiger

(Adresse)

::= N I L - Z e i g e r , Bild 5.-2.

entspricht:

o—>

NIL

NIL

SET!-Konstrukt - Ä n d e r u n g des Z e i g e r s auf e i n e e x i s t i e r e n d e C O N S - Z e l l e -

3"

5. Abbildungsoption: Liste

129

F00

BAR

crm

HCT] v #T Legende: Bild

v #T Vgl.

5-3.

V #T Bild

(EQUAL?

— >

V #T

ran V

V

V #T

V #T

tun

5-2. FOO

BAR)

==>

#T

5.1 Zirkuläre Liste Im obigen Beispiel „Verwalten von Arbeitsvorgängen" können wir mit dem SET-CDR!-Konstrukt den Bearbeitungszyklus einfach dadurch abbilden, daß der Zeiger des CDR-Parts der letzten CONS-Zelle von * ARBEITSPLAN* auf die erste CONS-ZELLE zeigt. Nehmen wir an, daß die Liste * ARBEITSPLAN* drei Elemente enthält, dann wäre formulierbar: eval>

;; A c h t u n g e n d l o s e B i 1 d s c h i r m a u s g a b e ! (SET-CDR! (CDDR *ARBEITSPLAN*) *ARBEITSPLAN*)

==>

...

Aufgrund des READ-EVAL-PRINT-Zyklus wird versucht die Liste * ARBEITSPLAN* auf dem Bildschirm auszugeben. * ARBEITSPLAN* stellt jetzt jedoch eine zirkuläre Liste (infinite Sequenz) dar, weil der letzte CDR-Part-Zeiger wieder auf die Anfangs-CONS-Zelle zeigt. Wir definieren daher zur Vermeidung der endlosen Ausgabe, wie folgt: eval>

(BEGIN

(SET-CDR! (CDDR *ARBEITSPLAN*) ^ARBEITSPLAN*) # T ) = = > # T ; R ü c k g a b e w e r t ist l e t z t e r B E G I N - A u s d r u c k

Daß *ARBEITSPLAN* an eine zirkuläre Liste gebunden ist, zeigt die Anwendung des EQ?-Konstruktes. eval>

(EQ? * A R B E I T S P L A N *

(CDDDR *ARBEITSPLAN*))

==>

#T

Das EQ?-Konstrukt stellt fest, ob die ihm übergebenen Zeiger auf dieselbe CONS-Zelle zeigen, d.h. denselben Wert haben. Die Identitätsentscheidung des EQ?-Konstruktes (vgl. Abschnitt 2.1) ist das Prüfen von Zeigern. Um die Elemente einer zirkulären Liste ausgeben zu können, ist ein eigenes

130

II. Konstruktionen (Analyse und Synthese)

PRINT-Konstrukt zu definieren, da das eingebaute PRINT-Konstrukt für zirkuläre Listen keine Terminierung enthält. Wir definieren z.B.: eval>

(DEFINE PRINT-ELEMENT (LAMBDA ( Z I R K U L A E R E _ L I S T E ) ( P R I N T (CAR Z I R K U L A E R E _ L I S T E ) ) ( L E T ((ANFORDERUNG (BEGIN (NEWLINE) (WRITELN " N a e c h s t e s E l e m e n t ? J/N : " ) (READ)))) (COND ( ( E Q ? ANFORDERUNG ' J ) ( P R I N T - E L E M E N T (CDR Z I R K U L A E R E _ L I S T E ) ) ) (T " E n d e ! " ) ) ) ) ==> PRINT-ELEMENT

Mit Hilfe der Mutatoren SET!, SET-CAR! und SET-CDR! ist die Verwaltung der Arbeitsvorgänge auf der Grundlage des Konzepts der zirkulären Liste im Programm 5.1-1. abgebildet. Dieses Programm hat folgende Struktur: e v a l > ( D E F I N E VERWALTEN - VON -ARBEITSVORGAENGEN (LAMBDA (Z_ L I S T E ) (LETREC ((ANFORDERUNG . . . ( R E A D ) ) (VORGANGSVERWALTUNG ; H a u p t f u n k t i on (LAMBDA ( Z I R K U L A E R E _ L I S T E ) ( L E T ((ANTWORT (ANFORDERUNG))) ;Steuerungscode; abfrage (COND ( ( E Q ? ANTWORT ' J A ) Nächster Vorgang ( ( E Q ? ANTWORT ' N E U ) Neuer V o r g a n g vgl. Bild 5.1-1/2 Lösche Vorgang ( ( E Q ? ANTWORT ' O K ) vgl. Bild 5.1-3/4 Programm beenden ( ( E Q ? ANTWORT ' S T O P ) Vorgang anzeigen (T ...)))))) A u f r u f der l o k a l e n (VORGANGSVERWALTUNG Z . L I S T E ) ) ) ) e n d - r e k u r s i ven H a u p t f u n k t i on = = > VERWALTEN-VON-ARBEITSVORGAENGEN!

Dokument 5 . 1 - 1 T i t e l : Programm VERWALTEN-VON-ARBEITSVORGAENGEN! E r s t e l l t : 09.09.89 ¡ l e t z t e Aenderung: 3.11.90 AI

VERWALTEN-VON-ARBEITSVORGAENGEN! s p e i c h e r t V o r g ä n g e in einer z i r k u l a e r e n L i s t e . A I . 1 D i e V o r g ä n g e können i n d e r g e s p e i c h e r t e n R e i h e n f o l g e nacheinander a n g e z e i g t werden. A I . 2 Der a n g e z e i g t e V o r g a n g i s t a u s d e r L i s t e e n t f e r n b a r . A2 E i n neuer Vorgang i s t i n d i e L i s t e A 2 . 1 Vor dem g e z e i g t e n V o r g a n g o d e r A 2 . 2 h i n t e r dem g e z e i g t e n V o r g a n g .

einfügbar:

5. Abbildungsoption: Liste

131

T1

Beispiel

Tl.l

Arbeitsplan: eval > (DEFINE * A R B E I T S P L A N * (LIST "Lieber die Investition Lagerhalle West e n t s c h e i d e n " "Zeugnis fuer den A b t e i l u n g s l e i t e r Meier d i k t i e r e n " "Budgetplanung fuer die Z e n t r a l a b t e i 1 u n g a u f s t e l l e n " ) ) ==> * A R B E I T S P L A N *

;;; T1.2 Applikati on: ;;; eval> ( V E R W A L T E N - V O N - A R B EI T S V O R G A E N G E N ! * A R B E I T S P L A N * ) ;;; ==> ... ¡Geführte B e n u t z e r e i n g a b e n (DEFINE VERWALTEN - VON-ARB EI T S V O R G A E N G E N ! (LAMBDA (Z_LISTE) (LETREC ((ANFORDERUNG (LAMBDA () (BEGIN (WRITELN " Naechster Vorgang? JA") (WRITELN " Neuen Vorgang e i n f u e g e n ? NEU") (WRITELN " Vorgang fertig b e a r b e i t e t ? OK") (WRITELN " Ende? STOP") (WRITELN " Zeige Vorgang? sonst") (NEWLINE) (READ)))) ;; H a u p t f u n k t i o n (VORGANGSVERWALTUNG (LAMBDA ( Z I R K U L A E R E _ L I S T E ) (LET ((ANTWORT (ANFORDERUNG))) ; S t e u e r u n g s c o d e a b f r a g e (COND ;;; Zum nächsten Vorgang ü b e r g e h e n ((EQ? ANTWORT 'JA) (VORGANGSVERWALTUNG ;;; Neuen Vorgang in die z i r k u l a e r e

(CDR Z I R K U L A E R E . L I S T E ) ) ) Liste einbauen (vgl. A2)

((EQ? ANTWORT 'NEU) (LET ( ( N E U E R - V O R G A N G (BEGIN (WRITELN "Bitte geben Sie Ihren " "Vorgang ein! (Zeichenkette) :") (NEWLINE) (READ))) ( N E U E - C O N S - Z E L L E (LIST " P L A T Z H A L T E R " ) ) ) (COND ;; Wenn die z i r k u l a e r e Liste nur aus ;; einer C O N S - Z e l l e besteht, dann kann :; d i e s e mit ihrem C A R - Z e i g e r auf den ;; neuen Vorgang zeigen. ((EQ? (CAR Z I R K U L A E R E _ L I S T E ) NIL) (SET-CAR! Z I R K U L A E R E _ L I S T E NEUER-VORGANG) (VORGANGSVERWALTUNG ZIRKULAERE_LISTE))

132

;;;

II. Konstruktionen (Analyse und Synthese)

Vorgang

; ; Vor dem a k t u e l l e n V o r g a n g den neuen ;; Vorgang e i n b a u e n ? ; v g l . A 2 . 1 ((EQ? 'JA (BEGIN (WRITELN " S o l l I h r neuer Vorgang " " v o r h e r e i n g f u e g t werden? J A " ) (NEWLINE) (READ))) ;; E r l ä u t e r u n g s i e h e B i l d 5 . 1 - 1 . (SET-CDR! NEUE-CONS-ZELLE (CDR Z I R K U L A E R E _ L I S T E ) ) (SET-CAR! NEUE-CONS-ZELLE (CAR Z I R K U L A E R E _ L I S T E ) ) (SET-CAR! ZIRKULAERE_LISTE NEUER-VORGANG) (SET-CDR! ZIRKULAERE_LISTE NEUE-CONS-ZELLE) (VORGANGSVERWALTUNG Z I R K U L A E R E _ L I S T E ) ) ;; E r l ä u t e r u n g s i e h e B i l d 5 . 1 - 2 . ;; v g l . A2.2 (T ( S E T - C D R ! NEUE-CONS-ZELLE (CDR Z I R K U L A E R E _ L I S T E ) ) (SET-CAR! NEUE-CONS-ZELLE NEUER-VORGANG) (SET-CDR! ZIRKULAERE_LISTE NEUE-CONS-ZELLE) (VORGANGSVERWALTUNG ZIRKULAERE_LISTE))))) a u s der z i r k u l ä r e n L i s t e e n t f e r n e n ( v g l . A I . 2 ) ( ( E Q ? ANTWORT ' O K ) ;; E r l ä u t e r u n g s i e h e B i l d 5 . 1 - 3 . (LETREC ((QUASI -LETZTE-ELEMENT (LAMBDA ( L I S T E N _ Z E I G E R A K T U E L L E _ Z E I G E R VORHERGEHENDE_POSITION) (COND ( ( E Q ? L I S T E N _ Z E I G E R AKTUELLE_ZEIGER) VORHERGEHENDE_POSITION) (T ( Q U A S I - LETZTE - ELEMENT LISTEN_ ZEIGER (CDR A K T U E L L E _ Z E I G E R ) (CDR V O R H E R G E H E N D E _ P O S I T I O N ) ) ) )))) ;; E r l ä u t e r u n g s i e h e B i l d 5 . 1 - 4 . (SET-CDR! (QUASI-LETZTE-ELEMENT ZIRKULAERE_LISTE (CDDR Z I R K U L A E R E _ L I S T E ) (CDR Z I R K U L A E R E _ L I S T E ) ) (CDR Z I R K U L A E R E _ L I S T E ) ) (SET-CAR! ZIRKULAERE_LISTE NIL) (SET! ZIRKULAERE_LISTE (CDR Z I R K U L A E R E . L I S T E ) ) (VORGANGSVERWALTUNG Z I R K U L A E R E _ L I S T E ) ) )

5. Abbildungsoption: Liste ;;; P r o g r a m m

133

beenden (C EQ? A N T W O R T ' S T O P ) CWRITELN "Vorgangsverwaltung *THE-NON-PRINTING-OBJECT*)

;;; V o r g a n g

anzeigen (T

(vgl.

AI.1)

(WRITELN "Bitte bearbeiten Sie: " (CAR Z I R K U L A E R E _ L I S T E ) ) (VORGANGSVERWALTUNG ZIRKULAERE.LISTE)))))))

;; S t a r t d e r l o k a l e n e n d r e k u r s i v e n (VORGANGSVERWALTUNG Z.LISTE)))) Program

5.1-1

beendet")

Verwalten

von

Hauptfunktion

Arbeitsvorgängen

Zur Erläuterung wird angenommen, daß beim Aufruf des Programms 5.1-1 das Argument *ARBEITSPLAN* an eine zirkuläre Liste mit drei Elementen gebunden ist. eval > ( V E R W A L T E N - V O N - A R B E I T S V O R G A E N G E N !

*ARBEITSPLAN*)

==>

...

Damit ist zunächst die LAMBDA-Variable Z_ LISTE an die zirkuläre Liste von * ARBEITSPLAN* gebunden. Über die Applikation von (VORGANGANGSVERWALTUNG Z_ LISTE) wird die LAMBDA-Variable von VORGANGSVERWALTUNG, also ZIRKULAERE. LISTE, ebenfalls an diese zirkuläre Liste gebunden. Anders formuliert: Der Zeiger Z I R K U L Ä R E . LISTE weist auf dieselbe CONS-Zelle wie der Zeiger * ARBEITSPLAN*. Unterstellen wir nun, daß der Benutzer mit der Eingabe NEU antwortet und seinen neuen Vorgang am „Anfang" der zirkulären Liste einfügen will, dann zeigt das Bild 5.1-1 die Änderung der Zeiger auf die CONS-Zellen. Nochmals sei darauf hingewiesen, daß es sich um ein graphisches Modell für das Verstehen der Mutatoren SET!, SET-CAR! und SET-CDR! handelt. Im Bild 5.1-1 werden mit der Anwendung der Mutatoren SET-CAR! und SET-CDR! auf ZIRKULAERE. LISTE die Inhalte derjenigen CONS-Zellen geändert, auf die sowohl die LAMBDA-Variable Z I R K U L A R E . LISTE selbst als auch die globale Variable *ARBEITSPLAN* zeigen. Nach Beendigung des Programms wird die Bindung der LAMBDA-Variable wieder aufgehoben. Die Bindung der globalen Variable * ARBEITSPLAN* bleibt bestehen, d.h. es gibt weiterhin in der „top level" Umgebung (hier USER-INITIAL-ENVIRONMENT) die Assoziation zwischen dem Symbol *ARBEITSPLAN* und den modifizierten CONS-Zellen. Das Bild 5.1-2 zeigt das Einfügen eines neuen Vorgangs nach dem aktuellen Vorgang. Hier ist wieder das Aufbrechen einer CONS-Zellen-Kette und das Einfügen einer zusätzlichen CONS-Zelle durch den Mutator SET-CDR! abgebildet.

134

II. Konstruktionen (Analyse und Synthese)

Bei der zirkulären Liste können wir mit dem CDR-Konstrukt auf die nachfolgende CONS-Zelle positionieren. In Pfeilrichtung läßt sich der Zirkel durchlaufen, in der entgegengesetzten Richtung nicht. Soll der CDR-Part einer vorgehenden CONS-Zelle modifiziert werden, z.B. um die aktuelle CONS-Zelle zu überspringen, dann müssen wir eine Hilfslösung wählen. Wir durchlaufen den Zyklus in der CDR-Richtung so weit, bis wir an die vorhergehende CONS-Zelle kommen. Diese Hilfslösung bildet das Konstrukt QUASI-LETZTE-ELEMENT ab (vgl. Bild 5.1-3). Ausgangssituation:

V

V

"Element_l" NEUE-CONS-ZELLE

>

o

NIL

v "PLATZHALTER"

"Element_2"

V

"Element_3"

5. Abbildungsoption: Liste

135

(SET-CDR! NEUE-CONS-ZELLE (CDR ZIRKULAERE_LISTE)) = - >

...

v

"PLATZHALTER"

(SET-CAR! NEUE-CONS-ZELLE (CAR ZIRKULAERE_LISTE)) ==> (SET-CAR! ZIRKULAERE_LISTE NEUER-VORGANG)) —> . . .

v "Element_l"

...

136

II. Konstruktionen (Analyse und Synthese)

(SET-CDR!

ZIRKULAERE_LISTE

NEUE-CONS-ZELLE))

— >

...

v "Element_l" Legende:

Vgl.

Bild 5.1-1.

Bild

5-2.

Neuen Vorgang am "Anfang" der zirkulären einfügen (vgl. P r o g r a m m 5 . 1 - 1 )

Liste

Ausgangssituation:

v "Element_l" NEUE-CONS-ZELLE—>

o

NIL

v "PLATZHALTER"

v "Element_2"

v "Element_3"

5. Abbildungsoption: Liste

(SET-CDR! (SET-CAR! (SET-CDR!

137

N E U E - C O N S - Z E L L E (CDR Z I R K U L A E R E _ L I S T E ) ) = = > N E U E - C O N S - Z E L L E N E U E R - V O R G A N G ) - = > ... ZIRKULAERE_LISTE NEUE-CONS-ZELLE)) — > ...

...

v

NEUER-VORGANG Legende:

Vgl. B i l d

Bild 5.1-2.

Neuen (vgl.

5-2. Vorgang in die zirkuläre Programm 5.1-1)

Liste

einfügen

Das QUASI-LETZTE-ELEMENT-Konstrukt gibt als Wert einen Zeiger auf die CONS-Zelle wieder, die der aktuellen CONS-Zelle in der zirkulären Liste vorhergeht. Zum Herausnehmen einer CONS-Zelle aus der zirkulären Liste werden mit den Mutatoren SET-CAR! und SET-CDR! die Inhalte der gemeinsamen CONS-Zellen von * ARBEITSPLAN* und ZIRKULAERE_ LISTE modifiziert (vgl. Bild 5.1-4). Mit dem Mutator SET!, angewendet auf die LAMBDA-Variable ZIRKULAERE_ LISTE, wird jedoch nur dieser Zeiger geändert, d.h. auf die um das erste Element verkürzte zirkuläre Liste gesetzt. Der Zeiger * ARBEITSPLAN* bleibt davon unberührt. Wird nach dem Löschen eines Vorganges das Programm VERWALTENVON-ARBEITS VORGAENGEN! mit dem Argument * ARBEITSPLAN* ein zweites Mal gestartet, dann wäre das erste Element von *ARBEITSPLAN* NIL (vgl. Bild 5.1-4). Um diesen Effekt zu vermeiden, muß der Zeiger •ARBEITSP L A N * modifiziert werden. Dies kann mit dem Mutator SET! in der (Definitions-)Umgebung von * ARBEITSPLAN* erfolgen. Dazu könnte z.B. das Programm VERWALTEN-VON-ARBEITSVORGAENGEN an der Stelle der Programm-ENDE-Behandlung, wie folgt, geändert werden: bisher: ((EQ? A N T W O R T 'STOP) (WRITELN "Vorgangsverwaltung *THE-NON-PRINTING-OBJECT*)

beendet")

138

II. Konstruktionen (Analyse und Synthese)

Funktion QUASI - LETZTE-ELEMENT: (LETREC ((QUASI - L E T Z T E - E L E M E N T (LAMBDA (LISTEN_ZEIGER AKTUELLE_ZEIGER VORHERGEHENDE_POSITION) ;; Das quasi l e t z t e E l e m e n t der z i r k u ;; l ä r e n L i s t e w i r d e r k a n n t d u r c h Ver;; g l e i c h m i t t e l s EQ? wobei ;; A K T U E L L E _ Z E I G E R und ;; V O R H E R G E H E N D E . P O S I T I O N " s y n c h r o n " ;; die Liste e n t l a n g w a n d e r n . ( C O N D ((EQ? L I S T E N _ Z E I G E R A K T U E L L E _ Z E I G E R ) VORHERGEHENDE,POSITION) (T (QUASI - L E T Z T E - E L E M E N T LISTEN_ZEIGER (CDR A K T U E L L E _ Z E I G E R ) (CDR V O R H E R G E H E N D E _ P 0 S I T I O N ) ) ) ) ) ) ) ... )

Legende:

Vgl.

Bild 5.1-3.

Änderung:

Bild

5-2.

Hi1fslösung um die quasi letzte zirkulären Liste zu ermitteln (vgl. P r o g r a m m 5 . 1 - 1 )

((EQ? A N T W O R T 'STOP) (WRITELN "Vorgangsverwaltung ZIRKULAERE_LISTE)

CONS-Zelle

einer

beendet")

Der Rückgabewert des Programms VERWALTEN-VON-ARBEITSVORGAENGEN! ist dann stets der Zeiger ZIRKULAERE LISTE, so daß dann formuliert werden könnte: eval>

( B E G I N (SET! * A R B E I T S P L A N * ( V E R W A L T E N - VON - A R B E I T S V O R G A E N G E N ! * A R B E I T S P L A N * ) )

#T)

==>#T

/Hinweis: Einerseits ist diese umständliche Formulierung mit der zweimaligen Nennung von * ARBEITSPLAN* durch die Definition eines Makros syntaktisch vereinfachbar. Für eine solche Makro-Nutzung vgl. z.B. Abschnitt 13.3. Anderer-

5. Abbildungsoption: Liste

139

seits könnte * ARBEITSPLAN* direkt und nicht über die LAMBDA-Schnittstelle des Konstruktes VERWALTEN-VON-ARBEITSVORGAENGEN! modifiziert werden, vgl. z.B. die Konstruktion des Programms 6.3-1.7 (SET-CDR!

(SET-CAR!

(QUASI - L E T Z T E - E L E M E N T ZIRKULAERE_LISTE ¡Listenzeiger (CDDR ZIRKULAERE_LISTE) ¡aktueller Zeiger (CDR Z I R K U L A E R E _ L I S T E ) ) ¡vorhergehende Position (CDR Z I R K U L A E R E _ L I S T E ) ) — > ...

ZIRKULAERE_LISTE

(SET! Z I R K U L A E R E _ L I S T E

NIL)

¡notwendig, falls zirkuläre L i s t e n u r aus e i n e r CONS-Zel1e besteht. (CDR Z I R K U L A E R E _ L I S T E ) ) -=>...

"Element_2" Legende: Bild

Vgl.

5.1-4.

Bild

'Element_3"

5-2.

Vorgang aus der zirkulären (vgl. Programm 5.1-1)

Liste

entfernen

Wie die Bilder 5.1-1 bis 4 dokumentieren, verändert das Konstrukt VERWALTEN-VON-ARBEITS VORGAENGEN! die CONS-Zellen seines Argumentes. Hier ist gerade diese Modifikation der gewünschte Effekt. In anderen Fällen allerdings ist sicherzustellen, daß die CONS-Zellen eines Argumentes nicht verändert werden. Haben wir keinen Einfluß auf ein Konstrukt, d.h. können wir seine Implementation nicht beeinflußen und wollen trotzdem sichergehen, daß die CONS-Zellen des Arguments nicht modifiziert werden, dann können wir diese nicht direkt dem fremden Konstrukt übergeben. Keine LAMBDA-Variable darf direkt an diese CONS-Zellen gebunden werden. Es ist zunächst eine Kopie des Argumentes durch neue CONS-Zellen zu konstruieren und diese Kopie dient

140

II. Konstruktionen (Analyse und Synthese)

dann als Bindungswert. Wird die Kopie verändert, bleibt das Original erhalten. Die Sicherstellung des Argumentes ist damit erreicht. Eine solche Kopie ist der Rückgabewert des COPY-Konstruktes.

Fall 1 : Modifikation der CONS-Zellen des Argumentes eval> eval>

( D E F I NE F 0 0 ( D E F I NE BAZ

eval>

(EQ?

F00

' ( A (B C) D ) ) F 0 0 ) = = > BAZ

BAZ)

eval>

(SET-CDR!

eval>

FOO = = >

= = > #T

BAZ

(A

==>

"(E))

F00 ;F00 i s t Argument f ü r ; DEFINE-Konstrukt

das

; F 0 0 und BAZ z e i g e n a u f ; dieselben CONS-Zellen ==>

(A

E)

E)

¡Modifikation

von

FOO !

Fall 2: Modifikationsschutz durch COPY-Konstrukt eval> eval> eval> eval> eval> eval>

( D E F I N E FOO ' ( A ( B C ) D ) ) = = > FOO ( D E F I N E BAZ (COPY F O O ) ) = = > BAZ ( E Q ? FOO B A Z ) = = > ( ) ;FOO und BAZ z e i g e n a u f v e r ; schiedene CONS-Zellen ( E Q U A L ? FOO B A Z ) = = > # T ; P r ü f t Gl e i c h h e i t d e r E l e ; mente, n i c h t d i e I d e n t i t ä t ; der CONS-Zellen ( S E T - C D R ! BAZ ' ( E ) ) = = > ( A E) FOO = = > ( A ( B C) D) ¡ K e i n e M o d i f i k a t i o n v o n FOO

Fall 3: Zirkuläre eval> eval>

Liste

( D E F I N E FOO ' ( A ( B C ) D ) ) = = > FOO ;; Z i r l u l ä r e L i s t e - Vermeidung e i n e r (BEGIN

(SET-CDR!

(CDDR

eval>

(BEGIN

(DEFINE

eval>

(BEGIN

(SET-CAR!

BAZ

FOO)

eval>

(CAR

(CDDDDR

BAZ))

==>

eval>

(CAR

(CDDDDR

FOO))

==>

eval>

( B E G I N ( S E T ! BAZ = = > ERROR . . .

(CADR

(COPY

FOO)

FOO) # T )

#T)

==>

#T

BAZ)

'E)

#T)

(E

C)

(E

C)

FOO))

endlosen ==>

==>

Ausgabe

#T #T

¡Nebeneffekt

!

#T) ¡ R e k u r s i o n zu t i e f , ; Stack-Überlauf

daher

Bei einer zirkulären Liste ist das eingebaute COPY-Konstrukt nicht anwendbar, da beim Kopieren der CONS-Zellen kein Ende erkannt wird (analog zum PRINT-Konstrukt). Hier ist die Kopie selbst mit Hilfe des CONS-Konstruktes zu erstellen. Wir halten fest: Wenn ein Listenelement verändert wird, können dadurch gleichzeitig andere Listen davon betroffen sein. Zu empfehlen ist daher, eine Liste, die als Konstante dient, prinzipiell nicht zu verändern (vgl. Charniak u.a., 1987, p. 23). Man stelle sich vor, eine solche Konstante befindet sich in einem Lesespeicher (engl.: read only memory). Jeder Änderungsversuch führt zu ei-

141

5. Abbildungsoption: Liste

nem Hardwarefehler. Das folgende Beispiel macht nochmals die Gefahr deutlich, den Nebeneffekt der Modifikation zu übersehen. eval > (DEFINE PARLAMENTS-FRAKTION? (LAMBDA ( X ) (MEMBER X ' ( S P D CDU FDP G R U E N E ) ) ) ) ==> PARLAMENTS-FRAKTION? e v a l > (DEFINE SO-NICHT! (LAMBDA ( X ) (LET ( ( T E I L ( P A R L A M E N T S - F R A K T I O N ? X ) ) ) (COND ( T E I L ( S E T - C A R ! T E I L N I L ) ) (T N I L ) ) ) ) ) = = > S O - N I C H T ! e v a l > ( P A R L A M E N T S - F R A K T I O N ? ' F D P ) = = > (FDP GRUENE) e v a l > ( S O - N I C H T ! ' F D P ) = = > ( ( ) GRUENE) eval > (PARLAMENTS-FRAKTION? 'FDP) ==> () e v a l > ;; " P r e t t y P r i n t " (PP P A R L A M E N T S - F R A K T I O N ? ) = = > # = (LAMBDA ( X ) (MEMBER X ' ( S P D CDU ( ) G R U E N E ) ) )

5.2 Assoziationsliste Wenn wir auf der Basis der einfachen Liste Konstruktoren, Selektoren, Prädikate und Mutatoren definieren, dann ist vorab die Listenstruktur festzulegen, d.h. die Bedeutung der einzelnen Listenelemente ist zu fixieren. Wenn wir annehmen, daß es sich bei einer Liste um ein Konto handelt, dann ist beispielsweise festzulegen, daß das 1. Element die Kontonummer, das 2. Element den Kontentyp, das 3. Element den Namen des Kontoinhabers etc. abbilden. Wir betrachten Kontonummer, Kontentyp, Name des Kontoinhabers etc. als Attribute A zum Objekt Konto. Den einzelnen Listenelementen sind dann entsprechend ihrer Reihenfolge die einzelnen Attributbeschreibungen zuzuordnen. Objekt

Konto:

(



...

)

Beschreibung der Attribute: Wert i n der L i s t e

Bedeutung



: : = Kontonummer ::= Kontentyp : : = Name des K o n t o i n h a b e r s

: : = Datum der

letzten

Buchung

/Hinweis: Datenlexikon. Zur Beschreibung eines Attributes gehört in der Regel auch die Definition des Wertebereichs, z.B: Kontonummer, 4-stellig numerisch, positiv ganzzahlig, (AND ( eval>

eval>

(DEFINE

KONTONUMMER (LAMBDA

(LISTE)

(LIST-REF LISTE 0 ) ) ) = = > KONTONUMMER ( D E F I N E KONTENTYP (LAMBDA ( L I S T E ) ( L I S T - R E F L I S T E 1 ) ) ) = = > KONTENTYP ( D E F I N E NAME-DES-KONTOINHABERS (LAMBDA ( L I S T E ) ( L I S T - R E F L I S T E 2 ) ) ) = = > NAME-DES-KONTOINHABERS

( D E F I N E DATUM-LETZTE - BUCHUNG (LAMBDA (LIST-REF

(LISTE)

L I S T E N) = = > DATUM-LETZTE - BUCHUNG

Damit der jeweilige Selektor das richtige Attribut ermittelt, ist sicherzustellen, daß die Position eines Attributs sich in der Liste nicht verschiebt. Die L A M B DA-Variable LISTE der obigen Selektoren ist an ein Konto zu binden, bei dem die definierte Struktur statisch ist. Löschen eines Attributwertes setzt voraus, daß die Listenelemente ihre Position nicht ändern. Daher ist der aktuelle Attributwert beim Löschen durch einen vereinbarten Ersatzwert (engl.: default value) bzw. Löschwert, z.B. NIL, zu ersetzen. Die Maxime „Position ist Informationsträger" ist statisch und daher nur bedingt geeignet für das prinzipiell dynamische Listenkonzept. Dynamisch ist die Liste in bezug auf das Verschieben von Elementen, beim Einfügen und Löschen von Elementen. Sind viele Attribute abzubilden, dann ist die einfache Liste kaum geeignet. Ihr dynamisches Konzept erweist sich als nachteilig, wenn von den einzelnen Objekten (hier: Konten) nur wenige Attribute einen Wert ungleich dem Ersatzwert haben. In solchem Fall hat die Liste viele Platzhalter, die nur deshalb erforderlich sind, um die fest vorgegebene Position der Elemente zu sichern. Dadurch wird erstens die Selektionszeit verlängert und zweitens das Verstehen des Programms unnötig erschwert. Zumindest bei wenig „besetzten" Attributen ist es angebracht, die Position in einer Liste nicht als Informationsträger zu nutzen. Die Information, um welches Attribut es sich handelt, kann dem Element zugeordnet werden, wenn die Ele-

5. Abbildungsoption: Liste

143

mente jetzt selbst Listen sind. Eine solche Verknüpfung des Attributs mit seinem Wert wird als Assoziations-Ziste, kurz A-Liste, bezeichnet. Eine A-Liste ist eine Liste mit eingebetteten Sublisten, in denen das erste Element jeweils die Aufgabe eines Schlüsselbegriffs (key) übernimmt. /Hinweis: Allgemein können A-Listen als Listen aufgefaßt werden, deren Elemente Punkt-Paare (engl.: dotted pairs) s i n d j In unserem Beispiel könnte das Konto dann folgende Listenstruktur haben: Objekt Konto:

((KONTONUMMER < a _ l > ) (KONTOTYP ) (NAME - DES -KONTOINHABERS )

(DATUM-LETZTElBUCHUNG

))

Zur Konstruktion der Selektoren, die auf der Basis A-Liste arbeiten, können wir eingebaute Zugriffskonstrukte nutzen z.B. in Scheme ASSOC, ASSQ oder ASSV. Solche eingebauten Konstrukte sorgen für eine effiziente Selektion, da sie die jeweiligen Implementationsdetails nutzen können. Ihre prinzipielle Funktion verdeutlicht das selbstdefinierte Konstrukt MEIN-ASSQ: e v a l > (DEFINE MEIN-ASSQ (LAMBDA (KEY A _ L I S T E ) (COND ((NULL? A_ L I S T E ) N I L ) ( ( E Q ? KEY (CAAR A _ L I S T E ) ) ¡Vergleichsoperation (CAR A . L I S T E ) ) (T (MEIN-ASSQ KEY (CDR A _ L I S T E ) ) ) ) ) ) ==>MEIN-ASSQ

In dem Konstrukt MEIN-ASSQ fußt die Vergleichsoperation zwischen dem Wert, an den KEY gebunden ist, und dem ersten Element einer Subliste auf dem EQ?-Konstrukt. Unterstellen wir, daß der Wert von KEY nicht nur ein Symbol sein kann, sondern z.B. eine Liste, dann ist für die Vergleichsoperation das EQUAL?-Konstrukt zu verwenden. In solchem Fall wollen wir die Subliste selektieren, deren erstes Element „gleich" der Liste von KEY ist. Da hier Gleichheit nicht Identität bedeutet (d.h. nicht die identischen CONS-Zellen für beide Listen voraussetzen soll), ist EQUAL? statt EQ? zu wählen. Die Benutzung der eingebauten Selektoren für A-Listen setzt daher die Kenntnis der Vergleichsoperation voraus. [PC Scheme: ASSOC testet mit EQUAL?, ASSV mit EQV? und ASSQ mit EQ?./ Passende Selektoren für das Kontobeispiel können mit dem MEIN-ASSQ-Konstrukt, wie folgt, definiert werden:

144

II. Konstruktionen (Analyse und Synthese)

eval> (DEFINE KONTONUMMER (LAMBDA (A_LISTE) (MEIN-ASSQ 'KONTONUMMER A.LISTE))) ==> KONTONUMMER eval> (DEFINE KONTOTYP (LAMBDA (A_LISTE) (MEIN-ASSQ 'KONTOTYP A_LISTE))) ==> KONTOTYP eval> (DEFINE NAME-DES-KONTOINHABERS (LAMBDA (A_LISTE) (MEIN-ASSQ 'NAME-DES-KONTOINHABERS A.LISTE))) ==> . . . /Hinweis: Subliste als Selektionswert. Die A-Listen-Selektoren haben im Trefferfall die ganze Subliste als Wert und nicht nur den zum Schlüssel assozierten Wert. Vermieden wird damit die Doppeldeutigkeit im Fall NIL. Ist ein Schlüssel mit dem Wert NIL verknüpft, dann wäre sonst der Rückgabewert gleich dem Wert "kein Treffer".; Eine A-Liste, die z.B. keine Eintragung für KONTOTYP enthält, kann im Gegensatz zur einfachen Listenstruktur nun problemlos als Argument für den Selektor NAME-DES-KONTOINHABERS dienen. eval> (DEFINE *K007* '((KONTOTYP 'SACHMITTEL) (KONTONUMMER 4711))) ==> *K007* eval> (NAME-DES-KONTOINHABERS *K007*) ==> NIL eval> (KONTONUMMER *K007*) ==> (KONTONUMMER 4711) Zum Konstruieren und Ändern einer A-Liste stehen dieselben Konstrukte wie für die einfache Liste zur Verfügung: CONS, LIST, SET-CAR!, SET-CDR! etc. Auf die A-Liste ausgerichtete Konstruktoren und Mutatoren sind selbst zu definieren. Ein Prädikat zum Erkennen einer A-Liste kann, wie folgt, definiert werden: eval> (DEFINE A-LISTE? (LAMBDA (OBJEKT) (LETREC ((LEERE-A-LISTE? (LAMBDA (X) (EQUAL? X (LIST NIL)))) (NUR-EINE-SUBLISTE? (LAMBDA (X) (AND (PAIR? X) (NULL? (CDR X)) (PAIR? (CAR X))))) (A-L? (LAMBDA (X) (COND ((OR (NOT (PAIR? X)) (NULL? X)) NIL) ((OR (LEERE-A-LISTE? X) (NUR-EINE-SUBLISTE? X)) T) ((PAIR? (CAR X)) (A-L? (CDR X))) (T NIL))))) (A-L? OBJEKT))) ==> A-LISTE? eval> eval> eval> eval>

(A-LISTE? (A-LISTE? (A-LISTE? (A-LISTE?

(LAMBDA () (+ 1 2 ) ) ) ==> () ' ( ( ) ) ) ==> #T '(A (B) (C 3 ) ) ) ==> () '((A 10) (B 9) (C 3 ) ) ) ==> #T

Bei der Definition eines A-Listen-Konstruktors ist zu entscheiden, ob die A-Liste dasselbe Attribut (denselben Schlüsselbegriff) mehrfach enthalten kann

5. Abbildungsoption: Liste

145

oder nicht (Multiplizität). Der oben skizzierte Selektor ASSQ wäre nicht in der Lage, eine zweite Ausprägung desselben Attributs zu selektieren, wie das folgende Beispiel zeigt. eval>

(DEFINE

*K001*

eval>

' ( ( S T R A S S E "Fuhrenkamp 2a") (ORT " S c h i f f d o r f " ) ( P L Z 2 8 5 8 ) (TELEFON " 0 4 7 0 3 / 5 2 7 0 " ) ) ) ==> * K 0 0 1 * ( D E F I N E C 0 N S - A - L I S T E ( L A M B D A ( N E U E _ E L E M E N T A_ L I S T E ) (COND ( ( P A I R ? N E U E _ E L E M E N T ) ( C O N S N E U E _ E L E M E N T A . L I S T E ) ) (T ( C O N S ( L I S T N E U E . E L E M E N T ) A_ L I S T E ) ) ) ) ) ==> CONS-A-LISTE

eval>

(SET!

*K001*

eval>

(ASSQ

'TELEFON

(CONS-A-LISTE *K001*)

==>

'(TELEFON (TELEFON

"0421/63171"

*K001*))

"0421/63171")

Die Möglichkeit, A-Listen mit Attributen zu definieren, die mehrfach vorkommen können, setzt eine problemgerechte Festlegung für den Verbund von Konstruktoren, Selektoren, Prädikaten und Mutatoren voraus. Beispielsweise eignen sich A-Listen mit Multiplizität zum Abbilden von aktuellen Werten gemeinsam mit ihren vorherigen Werten (d.h. ihrer Historie). Im Fall der globalen Variable * K 0 0 1 * bleibt die alte Telefonnummer bestehen. Existierende Konstrukte greifen mit ihrem Selektor TELEFON ohne Änderung auf die aktuelle Telefonnummer zu. Die Historie, d.h. die zunächst unter dem Attribut TELEFON gespeicherte Telefonnummer, kann z.B. für Revisionszwecke über einen entsprechend definierten Selektor wiedergewonnen werden. Sind die Schlüssel einer A-Liste Symbole und kommt jeder Schlüssel nur einmal in der A-Liste vor, dann bietet sich als Alternative die Eigenschaftsliste an (vgl. Abschnitt 5.3). Sind die Schlüssel nicht nur Symbole, dann ist in modernen LISP-Systemen die „Hash"-Tabelle eine Alternative. Für große A-Listen bieten sie eine Effizienzsteigerung, da die Zugriffszeit auf eine Assoziation (quasi) konstant ist. Wir skizzieren die Hash-Option für PC Scheme im folgenden Exkurs. /Exkurs: Hash-Tabelle in PC Scheme. Für die Elemente der A-Liste FOO berechnen wir mit dem OBJECT-HASH-Konstrukt eine signifikante Integerzahl. Unter Angabe dieser Integerzahl selektiert das OBJECT-UNHASH-Konstrukt das Element in der Hash-Tabelle. eval>

eval>

( D E F I N E FOO '((A ("More" (#\a (4711 ( ( A B C ) (#(BONN B E R L I N )

"LAMBDA Das u l t i m a t i v e Denkmodell") ( M e a n s Of R e q u i r e m e n t s Engineering)) (LAMBDA ( X ) ( P R I N T X) X ) ) "Manchmal s e h r n o t w e n d i g " ) ( 1 2 3 4 5 6 7 8 9 1 2 3 4)) "Hauptstadt von?")))

(DEFINE HASH-A-LISTE (LAMBDA (HASH_RICHTUNG A _ L I S T E ) (MAP (LAMBDA ( X ) ( L I S T (HASH_RICHTUNG (HASH.RICHTUNG A _ L I S T E ) ) ) ==> HASH-A-LISTE

(CAR X ) ) (LIST-REF

X

1))))

146

II. Konstruktionen (Analyse und Synthese)

eval>

( H A S H - A - L I S T E OBJECT-HASH F00) ==> ( ( 720896 1507328) (1572864 1638400) (1114112 1769472) ( 1 8 3 5 0 0 8 1900544)

eval>

(EQUAL? F00 ( H A S H - A - L I S T E 0BJECT-UNHASH (HASH - A - L I S T E OBJECT-HASH F 0 0 ) ) ) ==> #T

( 983040 (1966080

1703936) 2031616))

]

Aus geschachtelten A-Listen sind Rahmen (engl.: frames) konstruierbar, die eine mehrstufige Struktur darstellen (vgl. Bild 5.2-1). Mit solchen Rahmen hat Marvin Minsky ein Paradigma zur Abbildung von „Wissen" vorgeschlagen (Minsky, 1975). Ein Rahmen besteht aus Einschüben (engl.: slots). Die Einschübe haben Facetten (engl.: facets), die wiederum Werte haben, die voreingestellt sein können. Die Werte selbst können weiter strukturiert sein, aber auch Funktionen umfaßen. Wir können z.B. ein Konto als einen Rahmen definieren. Alle Rahmen fassen wir hier in einer A-Liste * R A H M E N - D A T E N B A N K * zusammen. Es sei angemerkt, daß es zweckmäßiger ist, den einzelnen Rahmen als Eigenschaft einer Kontonummer zu verwalten. Die Konstrukte für eine solche Bindung behandeln wir im folgenden Abschnitt Eigenschaftsliste.

Detail i erungsgrad

( 1( {( (I ) 1 ))

Legende: BNF-Notation ( v g l . Abschnitt 2.2)

Rahmen - Name o b e r s t e Ebene d e r E i n h e i t Ei n s c h u b - Name n ä c h s t e Ebene (Komponenten)

Facetten-Name A t t r i b u t e e i n e r Komponente

Wert Ausprägungen der A t t r i b u t e

Bild 5.2-1.

Rahmen konstruiert

aus

geschachtelten

e v a l > ( D E F I N E * RAHMEN - DATENBANK* '(RAHMEN (K001 (KONTO-TYP (GRUPPE SACHKONTO)) (KONTO-INHABER (NAME KRAUSE) (TELEFON 4 7 1 1 ) ) (LETZTE-BUCHUNG (DATUM 9 0 0 6 0 1 ) (BUCHUNGS-ART AUSZAHLUNG) (DM 5 . ) ) (EINZAHLUNGEN (DM-DATUM ( 1 0 . 900110) ( 5 5 . 9 0 0 2 1 2 ) ) ) (AUSZAHLUNGEN (DM-DATUM ( 5 . 9 0 0 6 0 1 ) ) ) (SALDO (DM 6 0 . ) ) )

A-Listen

147

5. Abbildungsoption: Liste (K002

(KONTO-TYP (GRUPPE HAUSHALT)) (KONTO-INHABER (NAME E I S E R ) ) (LETZTE-BUCHUNG (DATUM 9 0 0 7 0 1 ) (BUCHUNGS-ART EINZAHLUNG) (DM 1 0 5 . ) ) (EINZAHLUNGEN (DM-DATUM ( 1 0 5 . 9 0 0 7 0 1 ) ) ) (SALDO (DM 1 0 5 . ) ) ) ) ) = = > *RAHMEN-DATENBANK*

5.3 Eigenschaftsliste Die Eigenschaftsliste, kurz P-Liste („Property LIST') genannt, ist das klassische Konzept zur Abbildung eines Lexikons. Mit der Definition eines Symbols (Literalatoms) wird eine an das Symbol gebundene Eigenschaftsliste verfügbar. Jedes Symbol hat eine P-Liste, die zunächst leer ist. Ziehen wir eine Analogie zur Kernspaltung in der Physik, dann entsprechen den Neutronen, Elektronen, Protonen, die Zellen des (Literal-)Atoms. Abhängig vom jeweiligen LISP-System und seiner Implementation faßt das Symbol bestimmte Zellen (slots) zusammen, d.h. einem Symbol sind Speichermöglichkeiten für mehrere Zwecke zugeordnet (vgl. Bild 7.3-1). Bisher haben wir den Wert eines Symbols betrachtet. Dieser wird mit der „Wertzelle" (engl.: value cell) abgebildet. Beim Evaluieren eines Symbols (vgl. EVAL-Regel 4, Abschnitt 1.2) wird auf diese Zelle zugegriffen. Im allgemeinen verfügt ein Symbol zusätzlich über eine Zelle zum Abbilden der P-Liste. Eine Eintragung in die P-Liste eines Symbols erfolgt mittels PUTPROP. Der zugehörende Selektor ist das GETPROP-Konstrukt. Mit dem REMPROP-Konstrukt wird eine Eigenschaft von der P-Liste entfernt. Die gesamte Eigenschaftsliste ist durch das PROPLIST-Konstrukt verfügbar. Ein besonderes Prädikat für die P-Liste gibt es nicht, da sich die P-Liste von einer „normalen" Liste nicht unterscheidet. Konstruktor/Mutator. eval> eval>

(PUTPROP < e i g e n s c h a f t > ) ==> (REMPR0P < e i g e n s c h a f t > ) — > < s y m b o l - p - 1 i s t e >

Sd^ktofstx' eval> eval>

( P R O P L I S T < s y m b o l > ) ==> < p - l i s t e > (GETPROP < e i g e n s c h a f t > ) = >

¡ganze

P-Liste

Prädikat: eval>

(PAIR?

)

==> #T

mit:

: : = Das S y m b o l , d e s s e n troffen ist.

Eigenschaftsliste

be-

II. Konstruktionen (Analyse und Synthese)

148



B e l i e b i g e r symbolischer Ausdruck als Ausprägung der E i g e n s c h a f t . E i n S y m b o l , das d i e E i g e n s c h a f t von benennt. Eine L i s t e mit der E l e m e n t f o l g e aus < e i g e n s c h a f t > und < w e r t > , s o r t i e r t i n d e r u m g e k e h r t e n R e i h e n f o l g e d e r PUTPROPA p p l i kati onen. M o d i f i z i e r t e < p - l i s t e > mit a l s z u s ä t z l i c h e s e r s t e s Element.

Die Konstrukte PUTPROP, GETPROP, REMPROP und PROPLIST evaluieren ihre Argumente, so daß an der Stelle von , und symbolische Ausdrücke stehen, die einen entsprechenden Rückgabewert haben. Das folgende Beispiel verdeutlicht die Konstrukte zur Eigenschaftsliste: eval eval eval eval eval

> > > > >

(PUTPROP (PUTPROP (PUTPROP (PUTPROP (PROPLIST

eval>

(REMPROP

eva1>

(GETPROP

eva1> eval> eval>

(PUTPROP (GETPROP (GETPROP ==> ()

' ' ' '

*K001* "Schiffdorf" 'ORT) ==> " S c h i f f d o r f " * K 0 0 1 * 2858 ' P L Z ) ==> 2858 *K001* "04703/5270" 'TELEFON) ==> "04703/5270" *K001* "0421/63171" 'TELEFON) ==> "0421/63171" ' * K 0 0 1 * ) ==> ( T E L E F O N " 0 4 2 1 / 6 3 1 7 1 " PLZ 2 8 5 8 ORT " S c h i f f d o r f " * K 0 0 1 * 'PLZ) ==> ( * K 0 0 1 * T E L E F O N " 0 4 2 1 / 6 3 1 7 1 " ORT " S c h i f f d o r f " ' * K 0 0 1 * 'ORT) ==> " S c h i f f d o r f "

' * K 0 0 1 * () 'ORT) ==> () ' * K 0 0 1 * 'ORT) ==> () '*K001* 'LAUFZEIT) Achtung! Keine Unterscheidung zwischen einer U n d e f i n i e r t e n E i g e n s c h a f t und e i n e r d e f i n i e r t e n E i g e n s c h a f t m i t dem W e r t ( ) .

In klassischen LISP-Systemen (z.B. LISP 1.5, vgl. McCarthy u.a., 1966) wird die P-Liste mitverwendet, um eine Funktion, die das Symbol benennt, zu Speichen. Die Selektion des Funktionswertes eines Symbols entspricht einer Anwendung des PUTPROP-Konstruktes mit der Eigenschaft VALUE (vgl. Abschnitt 7.3). In modernen LISP-Systemen ist die Wertzelle von der Zelle für die P-Liste zu unterscheiden. So kann ein Symbol in einer Umgebung keinen Wert haben, also keinen Eintrag in seiner Wertzelle aufweisen, jedoch Eintragungen in seiner PListe haben. Das folgende Beispiel zeigt einen solchen Fall. eval>

eval> eval>

(DEFINE (LET

M0DUL-P (LAMBDA ( ) ((SCHULZE ' P 2 3 4 5 ) (KRAUSE ' P 0 0 1 2 ) ) (PUTPROP SCHULZE 'MANAGER ' B E R U F ) (PUTPROP KRAUSE ' S C H R E I B K R A F T 'BERUF) (THE-ENVIRONMENT) ¡Hat d i e LET-Umgebung )) ==> M0DUL-P (MODUL-P) ==> # ( P R O P L I S T ' P 2 3 4 5 ) = = > ( B E R U F MANAGER)

als

Wert.

5. Abbildungsoption: Liste

149

eval>

P2345 ==>

ERROR

eval>

SCHULZE = = >

eval> eva1>

(PROPLIST 'SCHULZE) ==> () (ACCESS SCHULZE ( M O D U L - P ) ) ==> P2345 Wert von SCHULZE i n der M O D U L - P - U m g e b u n g . Zum A C C E S S Konstrukt vgl. Abschnitt 1.4.2.

ERROR

Symbol i s t i n d e r U S E R - I N I T I A L E N V I R O N M E N T an k e i n e n W e r t g e bunden . Symbol i s t i n d e r U S E R - I N I T I A L E N V I R O N M E N T an k e i n e n W e r t g e bunden .

/Hinweis: Eigenschaft PCS*PRIMOP-HANDLER. PC Scheme stellt zunächst fest, ob ein Symbol eine PCS*PRIMOP-HANDLER Eigenschaft hat; wenn ja, dann wird dessen CDR-Teil an die Stelle des Namens gesetzt. Das folgende Beispiel verdeutlicht die Auswertung der Eigenschaft PCS*PRIMOP-HANDLER. eval> eval> eval>

eval>

( D E F I N E F00 (LAMBDA ( X ) ( + X 7 ) ) ) = = > F00 ( F 0 0 4 ) = = > 11 ( P U T P R O P ' F 0 0 ' ( " H i e r o h n e B e d e u t u n g " LAMBDA ( Y ) ( + Y 3 ) ) 'PCS*PRIMOP-HANDLER) = = > ( " H i e r o h n e B e d e u t u n g " LAMBDA ( Y ) ( + Y 3 ) ) (F00 4) ==> 7

eval>

F00 = = >

(LAMBDA

(Y)

(+ Y 3))

]

Mit Hilfe des Iterationskontruktes FOR-EACH (vgl. Abschnitt 2.2.3) ist von einer vorgegebenen A-Liste eine P-Liste einfach erstellbar. Dazu definieren wir das Konstrukt MAKE-LEXIKON: eval>

eval>

eval>

( D E F I N E M A K E - L E X I K O N (LAMBDA (SYMBOL A _ L I S T E ) ( F O R - E A C H (LAMBDA ( X ) (PUTPROP SYMBOL ( L I S T - R E F X 1) (CAR X ) ) ) A_ L I S T E ) ) ) = = > M A K E - L E X I K O N (MAKE-LEXIKON '*K002* • ( ( T E L E F O N " 0 7 2 1 / 1 2 3 4 " ) (ORT " K a r l s r u h e " ) (PLZ 7500) (TELEFON " 0 7 2 1 / 4 5 6 7 " ) ) ) ==> ¡Rückgabewert des FOR-EACH-Konstruktes (PROPLIST '*K002*)) = = > ( P L Z 7 5 0 0 ORT " K a r l s r u h e " T E L E F O N " 0 7 2 1 / 4 5 6 7 " ) ;Zu b e a c h t e n i s t d i e R e i h e n f o l g e d e r E l e m e n t e . ; S i e w e i s t den l e t z t e n W e r t f ü r d i e E i g e n s c h a f t : T E L E F O N a u s , j e d o c h a u f g r u n d d e s e r s t e n PUTPROP : f ü r TELEFON a l s l e t z t e s P-Listen-Element. ; Neue E i g e n s c h a f t e n w e r d e n v o r n e i n g e f ü g t .

Die Konstruktion mit P-Listen birgt die Gefahr ungewollter Nebeneffekte. Das folgende Beispiel zeigt die Unterschiede der Effekte (Reichweite) der P-Liste zu einer lokalen A-Listendefinition. In beiden Fällen konstruieren wir ein Lexikon FOO, das zunächst die Attribute KEY-1, KEY-2 und KEY-3 enthält. Der Wert von KEY-1 wird modifiziert, und KEY-2 wird gelöscht. Danach wird auf der

150

II. Konstruktionen (Analyse und Synthese)

„top level"-Ebene (d.h. in der Umgebung USER-INITIAL-ENVIRONMENT) mit dem gleichen lokalen Namen eine KEY-4-Definition hinzugefügt. eval> (DEFINE LOKALE-A-LISTE (LAMBDA () (LET ((A-LISTE (COPY :um Konstante zu schützen * C C KEY -1 VALUE-1) (KEY-2 VALUE-2) (KEY-3 VALUE-3)))) (SET-CDR! (ASSQ 'KEY -1 A-LISTE) (LIST 'VALUE-NEU)) (DELETE! (ASSQ 'KEY-2 A-LISTE) A-LISTE) A-LISTE))) ==> LOKALE-A-LISTE eval> (DEFINE FOO (LOKALE-A-LISTE)) ==> FOO eval> FOO ==> ((KEY -1 VALUE-NEU) (KEY - 3 VALUE-3)) eval> (DEFINE A-LISTE '((KEY-4 'VALUE-4))) ==> A-LISTE eval> (DEFINE FOO (LOKALE-A-LISTE)) ==> FOO eval> FOO ==> ((KEY -1 VALUE-NEU) (KEY - 3 VALUE-3)) eval> (DEFINE VERMEINTLICH-LOKALE-P-LISTE (LAMBDA () (LET ((MEINE -P- LISTE 'BAZ)) (PUTPROP MEINE-P-LISTE 'VALUE-1 'KEY-D (PUTPROP MEINE-P-LISTE 'VALUE-2 'KEY - 2) (PUTPROP MEINE-P-LISTE 'VALUE-3 'KEY-3) (PUTPROP MEINE-P-LISTE 'VALUE-NEU 'KEY-D (REMPROP MEINE-P-LISTE 'KEY - 2) (PROPLIST MEINE-P-LISTE)))) ==> VERMEINTLICH-LOKALE-P-LISTE eval> (DEFINE FOO (VERMEINTLICH-LOKALE-P-LISTE)) ==> FOO eval> FOO ==> (KEY-3 VALUE-3 KEY -1 VALUE-NEU) Die P-Liste ist für das Symbol BAZ, das in der USER-INITIAL-ENVIRONMENT keinen Wert hat, angelegt. Mit dem Definieren des FOO-Konstruktes zeigt das Symbol FOO auf die P-Liste von BAZ. Wird die P-Liste von BAZ verändert, dann ist FOO gegebenenfalls davon mitbetroffen. Bezieht sich die Änderung auf eine Listenposition vor dem FOO-Zeiger, dann ist diese für FOO unerheblich. eval> (PUTPROP 'BAZ 'VALUE-4 'KEY-4) ==> VALUE-4 eval> BAZ ==> ERROR . . . ¡Variable BAZ nicht ; in a k t u e l l e r ; Umgebung d e f i n i e r t eval> FOO ==> (KEY-3 VALUE-3 KEY -1 VALUE-NEU);Keine Änderung Wird jedoch der FOO-Zeiger durch die erneute Applikation von VERMEINTLICH-LOKALE-P-LISTE auf den Anfang der P-Liste von BAZ gesetzt, dann ist FOO von der BAZ-P-Listen-Modifikation betroffen. eval> (DEFINE FOO (VERMEINTLICH-LOKALE-P-LISTE)) ==> FOO eval> FOO ==> (KEY-4 VALUE-4 KEY - 3 VALUE-3 KEY -1 VALUE-1) ¡Achtung Nebeneffekt! KEY-4 e x i s t i e r t .

5. Abbildungsoption: Liste

151

Diese Globalität der P-Liste führt leicht zu ungewollten Nebeneffekten (Fehlerquelle!). Man kann ihre Globalität jedoch vorteilhaft zur Kommunikation zwischen Konstrukten nutzen. Eine Kommunikation über die P-Liste zeigt das folgende Beispiel SCHNITTMENGE-SYMBOLE. Wir berechnen die Schnittmenge von Symbolen in zwei Listen. Zunächst werden alle Symbole, die in der ersten Liste vorkommen, markiert. Sie erhalten eine Eintragung in ihrer P-Liste. Damit eine bereits vorhandene Eigenschaft nicht überschrieben wird, ist sicherzustellen, daß wir eine Eigenschaft wählen, die nicht nocheinmal vorkommt. Dazu nutzen wir das GENSYM-Konstrukt (Näheres dazu vgl. Abschnitt 7.4). Die zweite Liste wird Symbol für Symbol abgearbeitet. Für jedes Symbol prüfen wir, ob es markiert ist. Wenn es markiert ist, dann gehört es zur Schnittmenge. Da es in der zweiten Liste nochmals vorkommen kann, heben wir im Trefferfall die Markierung wieder auf. Alle nicht markierten Symbole gehören nicht zur Schnittmenge. Zum Schluß heben wir die noch bestehenden Markierungen von Symbolen der ersten Liste auf. Das Durchlaufen der beiden Listen übernehmen „mapping functions" (vgl. Abschnitt 2.2.3). Durch das MAP-Konstrukt enthält die Schnittmenge NIL-Werte. Diese löschen wir durch das DELQ!-Konstrukt. Es prüft mit dem EQ?-Konstrukt und löscht ein Listenelement, wenn dieses Prädikat zutrifft. eval>

(DEFINE

KONTEN

'(A

B C D E F G (H

eval>

(DEFINE

O F F E N E - POSTEN

'(F

I

J

K)

Z Y G G A C))

L M N 0 ==>

P)) = = > KONTEN OFFENE-POSTEN

e v a l > (DEFINE SCHNITTMENGE-SYMBOLE (LAMBDA ( L _ l L _ 2 ) (LET ((MARKE (GENSYM))) ; Marke g e n e r i e r e n ;; M a r k i e r e n der Elemente von L_1 (FOR-EACH (LAMBDA ( X ) ( I F ( S Y M B O L ? X) (PUTPROP X T M A R K E ) ) ) L_1) ;; S e l e k t i e r e n der m a r k i e r t e n Werte (BEGINO (DELQ! ¡Loescht a l l e NIL-Werte () (MAP ( L A M B D A ( X ) (COND ( ( A N D ( S Y M B O L ? X ) (GETPROP X M A R K E ) ) ;; L ö s c h t m a r k i e r t e Werte (REMPROP X MARKE) X) ; R ü c k g a b e w e r t von ; ; vgl. Abschnitt 2.2.3 (T L_2))

NIL)))

152

II. Konstruktionen (Analyse und Synthese)

;;

Löschen

noch

bestehender

Marken

(FOR-EACH (LAMBDA (IF

(X)

(AND

(SYMBOL?

(REMPROP L_1))))) eval>

==>

X

X)

(GETPROP

X

MARKE))

MARKE)))

SCHNITTMENGE-SYMBOLE

(SCHNITTMENGE-SYMBOLE

KONTEN

OFFENE-POSTEN)

==>

(F

G A

C)

Als weiteres Beispiel für die Abbildungsoption P-Liste betrachten wir im folgenden ein Bürogebäude einer Kommunalverwaltung (vgl. Bild 5.3-1). Die Akten (Geschäftsvorfälle) werden in Laufmappen transportiert. Den Transport übernimmt ein mechanisches Fließbandsystem. Zu seiner elektronischen Steuerung ist ein Weg zwischen der jeweiligen Startstation und der angegebenen Zielstation zu bestimmen. Aufgabe des LISP-Programm ist es, einen solchen Weg zu ermitteln. Beispiel: Laufinappen-Transportsteuerung Entsprechend der Büroskizze (Bild 5.3-1) ist für jede Hauspoststation eine PListe definiert (vgl. Programmfragment 5.3-1). Sie enthält: o als Eigenschaft ORT, die Lage der Poststation, angegeben in X-Y-Koordinaten, und o als Eigenschaft NACHFOLGER die Hauspoststationen, die direkt erreicht werden können sowie ihre Entfernung (als A-Liste). Wir unterstellen, daß stets nur eine Laufmappe transportiert wird und die einzelnen Stationen diese Laufmappe durchschleusen bzw. aufnehmen können. Wir reduzieren damit das Problem auf eine einfache Wegesuche. Zunächst sei darüber hinaus nur gefordert, daß ein möglicher Weg zwischen Start und Ziel gefunden wird. Dieser Weg muß nicht der kürzeste Weg sein. e v a l > ( D E F I N E BUERO ( B E G I N ; ; ; ; K o o r d i n a t e n der Knoten (PUTPROP 'A ' ( 8 . 5 1 1 . 5 ) 'ORT) (PUTPROP 'B ' ( 1 5 . 5 10) 'ORT) (PUTPROP 'C ' ( 8 . 5 6 . 5 ) 'ORT) (PUTPROP 'D ' ( 8 . 5 5 . 5 ) 'ORT) (PUTPROP ' E ' ( 1 4 6 . 5 ) 'ORT) (PUTPROP ' F ' ( 1 5 . 5 4 . 5 ) 'ORT) (PUTPROP 'G ' ( 1 5 . 5 3) 'ORT) (PUTPROP 'H ' ( 0 . 5 0 . 5 ) 'ORT) (PUTPROP 'U ' ( 1 7 6 . 5 ) 'ORT)

5. Abbildungsoption: Liste ;;;;

153

E r r e i c h b a r e K n o t e n und i h r e E n t f e r n u n g e n (PUTPROP ' A ' ( ( C 5) (B 8 . 5 ) ) 'NACHFOLGER) (PUTPROP ' B ' ( ( A 8 . 5 ) (E 4 . 5 ) ) 'NACHFOLGER) ( P U T P R O P ' C ' ( ( D 1 ) (A 5 ) ( E 5 . 5 ) (H 1 4 ) ) 'NACHFOLGER) (PUTPROP ' D ' ( ( C 1 ) ) 'NACHFOLGER) ( P U T P R O P ' E ' ( ( C 5 . 5 ) ( F 3 ) ( B 4 . 5 ) (U 3 ) ) 'NACHFOLGER) ( P U T P R O P ' F ' ( ( E 3 ) (G 1 . 5 ) ) 'NACHFOLGER) ( P U T P R O P ' G ' ( ( F 1 . 5 ) (H 1 7 . 5 ) ) 'NACHFOLGER) ( P U T P R O P ' H ' ( ( C 1 4 ) (G 1 7 . 5 ) ) 'NACHFOLGER) (PUTPROP 'U ' ( ( E 3 ) ) 'NACHFOLGER) " E n d e " ) ) = = > BUERO

Programmfragment

5.3-1.

Hauspoststationen abgebildet

(Knoten)

als

P-Listen

Als Problemlösung bilden wir das Verfahren „Tiefensuche" (engl.: depth-firstsearch) ab. Die Bezeichnung „Tiefe" geht von einem Suchbaum (azyklischen Graphen) aus, der auf dem Kopf steht. Sie verdeutlicht, daß dieser Baum zunächst in Richtung auf die "Blätter" untersucht wird, ehe der nächste „Zweig" in Betracht gezogen wird. Gilt es z.B., einen Weg vom Startknoten H zum Zielknoten F zu finden, dann stellt Bild 5.3-2 die Knoten dar, die bei der Tiefensuche abzuarbeiten („zu expandieren") sind, ehe der Zielknoten F erreicht wird. Zunächst ist zu entscheiden, welcher Nachfolger vom Startknoten H als erster zu untersuchen ist. Ist C oder G zu wählen? Wir nehmen C, da C als erster Knoten in der Liste der Nachfolger von H genannt ist. eval>

(GETPROP

'H

'NACHFOLGER)

==>

((C

14)

(G

17.5))

Da C nicht der Zielknoten ist, ist zu entscheiden, ob zunächst der erste Nachfolger von C, hier D, oder der bisher nicht geprüfte Knoten G zu analysieren ist? Im Sinne der „Tiefengewinnung" verfolgen wir erst D weiter, also den ersten Nachfolger-Knoten (,,Kind"-Knoten) von C. Wir steigen im Suchbaum zunächst auf dem "linken Ast" eine Ebene tiefer, vorausgesetzt, es gibt dort noch eine solche Ebene, bevor wir die anderen Knoten auf gleicher Ebene untersuchen. Knoten, die schon überprüft darauf wurden, daß sie nicht der Zielknoten sind, müssen dabei nicht noch einmal analysiert, sondern sind nicht mehr zu berücksichtigen. Im Programm DEPTH-FIRST-SEARCH (vgl. Programm 5.3-1) merken wir uns die noch zu expandierenden Knoten als eine einfache Liste mit dem Namen LISTE-EROEFFNETE-KNOTEN. Knoten, die schon überprüft wurden, ob sie der Zielknoten sind, speichern wir als einfache Liste mit dem Namen LISTEGESCHLOSSENE-KNOTEN. Um von den Nachfolgern eines expandierten Knotens diejenigen Knoten streichen zu können, die schon bearbeitet wurden, definieren wir eine Liste mit dem Namen A R B E I T S L I S T E . Den aktuell expandierten Knoten speichern wir als Wert des Symbols ANALYSE-KNOTEN. Die Tabelle 5.3-1 zeigt die Veränderung dieser Variablen bezogen auf das Durchlau-

154

II. Konstruktionen (Analyse und Synthese)

Y

Amtsleiter Krause

1. Sachbearbeiter Huhn B

Mitarbeiter Wolf

Vorzimmer Schmidt

Stellvertretender Amtsleiter Schulze

Legende:

-•-

H

Mitarbeiter Gans

2. Sachbearbeiter Elster G

->

X

::= Hauspoststation x für den Laufmappentransport ::= Transportweg

Bild 5.3-1. Skizze der Büroräume und der Hauspoststation

fen der lokalen Funktion TIEFENSUCHE. Darüber hinaus sind die PUTPROPund GETPROP-Anwendungen angegeben. Die ARBEITSLISTE bereinigen wir um die Knoten, die schon in der LISTEGESCHLOSSENE-KNOTEN vorkommen. Dazu verwenden wir die Funktion DIFFERENZ-KNOTEN (vgl. Tab. 5.3-1, Spalte ARBEITSLISTE, jeweils zweite Eintragung). Enthält die bereinigte ARBEITSLISTE Knoten, die auch in der LISTE-EROEFFNETE-KNOTEN vorkommen, so streichen wir zunächst diese Knoten aus der LISTE-EROEFFNETE-KNOTEN. Dann setzen wir mit APPEND die Knoten der bereinigte ARBEITSLISTE an den Anfang von LI-

5. Abbildungsoption: Liste

155

Sta r t k n o t e n : H Ziel k n o t e n : F eval>

(DEPTH FIRST-SEARCH

'H

'F) = = >

(H C A B E F)

H i t i

(¿)

(E)

b

;Weil D k e i n e n o c h zu u n t e r ; s u c h e n d e n K n o t e n h a t , ist bei : A w e i t e r zu a n a l y s i e r e n .

[A]

[i]J è

[f]

1 [À]

1 1

Legende: (x) [x] Bild

: : = N o c h zu a n a l y s i e r e n d e r K n o t e n ::= S c h o n a n a l y s i e r t e r K n o t e n 5 . 3 - 2.

Tiefensuche für das F Start H und Ziel

obige

Beispiel:

STE-EROEFFNETE-KNOTEN. Die zunächst aus LISTE-EROEFFNETE-KNOTEN gestrichenen Knoten kommen dadurch wieder in die LISTE-EROEFFNETE-KNOTEN, jedoch in der Reihenfolge von ARBEITSLISTE. Dokument 5.3-1 Titel: Programm DEPTH-FIRST-SEARCH Erstellt: 20.09.89 ¡letzte Änderung: AI Al.l AI.2 El El.l El.2

3.11.90

D E P T H - F I R S T - S E A R C H d u r c h s u c h t ein angegebenes Knotennetz n a c h e i n e m W e g v o n e i n e m S t a r t - zu e i n e m Z i e l - K n o t e n . Der erste s e l e k t i e r t e N a c h f o l g e r w i r d z u n ä c h s t w e i t e r analysiert (expandiert), bevor die weiteren Nachfolger expandiert werden (Zweck: "Tiefengewinnung"). Es s i n d e i n S t a r t - u n d e i n Z i e l k n o t e n a n z u g e b e n . Ein K n o t e n i s t e i n S y m b o l . Die K o o r d i n a t e n eines Knoten sind als E i g e n s c h a f t ORT gespei chert. Die N a c h f o l g e r e i n e s K n o t e n s u n d i h r e E n t f e r n u n g e n s i n d a l s E i g e n s c h a f t N A C H F O L G E R g e s p e i c h e r t u n d z w a r als f o l g e n d e A - L i s t e : ( { ( < n a c h f o l g e r > < e n t f e r n u n g > ) 1)

156

II. Konstruktionen (Analyse und Synthese) T1 Tl.l

Beispiel Daten ( v g l .

Tl.2

A p p l i k a t i o n ( v g l . Tab. 5 . 3 - 1 ) e v a l > (DEPTH-FIRST-SEARCH 'H

Programmfragment

5.3-1) 'F)

==>

(H C A B E

F)

( D E F I N E D E P T H - F I R S T - S E A R C H (LAMBDA (START.KNOTEN Z I E L _ K N O T E N ) (LETREC ((LISTE-EROEFFNETE-KNOTEN ( L I S T START_KNOTEN)) (LISTE-GESCHLOSSENE-KNOTEN NIL) (ANALYSE-KNOTEN N I L ) (ARBEITSLISTE NIL) (GET-NACHFOLGER ; vgl . E l . 2 (ohne E n t f e r n u n g s a n g a b e n e n ) (LAMBDA (KNOTEN) (MAP ( L A M B D A ( X ) (CAR X ) ) ( G E T P R O P KNOTEN ' N A C H F O L G E R ) ) ) ) ;; G i b t L I S T E _ 1 z u r ü c k ohne d i e E l e m e n t e , ;; d i e i n L I S T E _ 2 vorkommen. (DIFFERENZ-KNOTEN ( L A M B D A ( L I ST E _ 1 L I S T E _ 2 ) (COND ( ( N U L L ? L I S T E _ 1 ) N I L ) ((MEMBER (CAR L I S T E _ 1 ) L I S T E _ 2 ) ( D I F F E R E N Z - K N O T E N (CDR L I S T E _ 1 ) LISTE_2)) (T (CONS ( C A R L I S T E _ 1 ) (DIFFERENZ-KNOTEN (CDR L I S T E _ 1 ) LISTE_2)))))] D i e E i g e n s c h a f t WEG v e r k n ü p f t d e n A N A L Y S E - KNOTEN m i t s e i n e n N a c h f o l g e r n . AUSGABE-WEG s e t z t d i e s e K e t t e r ü c k w ä r t s vom Z I E L _ K N O T E N zum S T A R T _ K N O T E N a l s Liste zusammen. (AUSGABE-WEG (LAMBDA (KNOTEN) (COND ( ( N U L L ? K N O T E N ) N I L ) (T ( A P P E N D ( A U S G A B E - W E G ( G E T P R O P KNOTEN ' W E G ) ) (LIST KNOTEN))))))

5. Abbildungsoption: Liste

157

;; E r l ä u t e r u n g siehe Tab. 5 . 3 - 1 (TIEFENSUCHE (LAMBDA ( ) (COND ( ( N U L L ? L I S T E - E R O E F F N E T E - K N O T E N ) N I L ) (T ( S E T ! ANALYSE-KNOTEN ; vgl. Al.l (CAR L I S T E - E R O E F F N E T E - K N O T E N ) ) (SET! LISTE-EROEFFNETE-KNOTEN (CDR L I S T E - E R O E F F N E T E - K N O T E N ) ) (SET! LISTE-GESCHLOSSENE-KNOTEN (CONS A N A L Y S E - K N O T E N LISTE-GESCHLOSSENE-KNOTEN)) (COND ( ( E Q ? A N A L Y S E - K N O T E N Z I E L _ K N O T E N ) (AUSGABE-WEG ANALYSE - KNOTEN)) (T (SET! ARBEITSLISTE (GET-NACHFOLGER ANALYSE - KNOTEN)) (SET! ARBEITSLISTE (DIFFERENZ-KNOTEN ARBEITSLISTE LISTE-GESCHLOSSENE-KNOTEN)) (SET! LISTE-EROEFFNETE-KNOTEN (APPEND ARBEITSLISTE (DIFFERENZ-KNOTEN LISTE-EROEFFNETE-KNOTEN ARBEITSLISTE))) (FOR-EACH (LAMBDA (KNOTEN) (PUTPROP KNOTEN ANALYSE-KNOTEN 'WEG)) ARBEITSLISTE) (TIEFENSUCHE)))))))) ; ; Um e i n A b b r u c h k r i t e r i u m f ü r AUSGABE-WEG z u h a b e n . (PUTPROP START_KNOTEN N I L 'WEG) (TIEFENSUCHE)))) Programm

5.3-1.

DEPTH-FIRST-SEARCH

Das Programm DEPTH-FIRST-SEARCH expandiert stets den ersten Knoten von LISTE-EROEFFNETE-KNOTEN. Anders formuliert: Die Nachfolger von (CAR LISTE-EROEFFNETE-KNOTEN) bilden die ARBEITSLISTE. Ändern wir z.B. für den Knoten H die Reihenfolge der Nennungen bei der Eigenschaft NACHFOLGER (vgl. Programmfragment 5.3-1), dann erhalten wir für unser Beispiel mit Start bei H und Ziel bei F einen kürzeren Weg; statt 35 nur 19 Entfernungseinheiten. eval>

(PUTPROP

'H

'((G

17.5)

eval>

(DEPTH-FIRST-SEARCH

'H

(C 'F)

14)) ==>

'NACHFOLGER) ==> ( ( G (H G F)

17.5)

(C

14))

Ob die Tiefensuche für eine vorgegebene Start-Ziel-Angabe einen kurzen Weg ermittelt, hängt von der Reihenfolge der Knoten in der LISTE-EROEFFNETE-KNOTEN ab, die sich aufgrund der Reihenfolge der Nachfolgeknoten be-

158

II. Konstruktionen (Analyse und Synthese)

eval> TIEFEN SUCHEAufruf

(DEPTH-FIRST-SEARCH

ANALYSEKNOTEN ( )

1.

'H

LISTE-EROEFFNETEKNOTEN (H) (PUTPROP ( )

C

(C G) (PUTPROP (PUTPROP (G)

'C 'G

3.

D

(D A E (PUTPROP (PUTPROP (PUTPROP ( A E G

G) 'D 'C ' A •C ' E 'C )

4.

A

5.

6.

7.

'H 'H

'WEG) 'WEG) 'WEG)

'A

'WEG)

'E

'B

E

( E G) (PUTPROP (G)

'WEG) (E

F

( F U G) (PUTPROP 'F (PUTPROP 'U (U G)

'E •E

Reihenfolge im Programm Zielknoten 5.3-1.

'WEG) 'WEG) (F 'F

ARBEITSLISTE

()

()

(H)

(C (C

'WEG) 'WEG)

B

5.3-1.

F)

'WEG)

(A E G) (EG)

(AUSGABE-WEG (GETPROP ==> (H C A B E F )

(H C A B E

LISTE-GESCHLOSSENEKNOTEN

(B E G) (PUTPROP 'B (EG)

(APPEND Tab.

==>

'H N I L

H

2.

'F)

(C

H)

(D

C

(A

D C

(B

A D C

H)

B A D C

H)

(D A (D A

H)

E H) E)

(C) ( \ l ) H)

(C B) (l D R ;1 (A E) (E) (C (F

E B A D C H)

'WEG) )

G) G)

(LIST

;

'F))

F B U)

U)

Ziel ...

der

PUTPROPund GETPROP-Anwendungen DEPTH-FIRST-SEARCH bei Startknoten H, F und dem Büro von Programm- fragment

stimmt. Die Tiefensuche ermittelt stets einen Weg vom Startknoten zum Zielknoten, falls ein solcher exsistiert, aber nur „zufällig" ist dieser Weg der kürzeste Weg. Wir können es nicht der zufällig passenden Reihenfolge in der LISTE-EROEFFNETE-KNOTEN überlassen, welchen Knoten wir expandieren, wenn das Suchverfahren den kürzesten Weg ermitteln soll; natürlich ohne zunächst alle Knoten zu expandieren. Wir benötigen für die Auswahl des zu expandierenden Knotens eine zusätzliche Information. Diese Angabe muß es gestatten, eine Priorität für das Expandie-

5. Abbildungsoption: Liste

159

ren eines Knotens zu ermitteln, so daß das bisherige „blinde" Suchen ersetzt werden kann durch ein prioritäts-gesteuertes Suchen; z.B. nach dem A*-Verfahren (vgl. Programm 5.3-2). Benötigt wird eine sogenannte „Evaluations"-Funktion (engl.: evaluation function) für das Expandieren der Knoten. (Achtung! Nicht verwechseln mit dem EVAL-Konstrukt.). Die Priorität ergibt sich aufgrund einer Entfernungsschätzung vom Start zum Ziel bei dem Weg über den jeweiligen Knoten. Den zurückgelegten Weg vom Start bis zum Knoten merken wir uns in der P-Liste des Knotens unter der Eigenschaft ENTFERNUNG-VOM-START. Addieren wir zu diesem Wert eine Schätzung vom Knoten zum Ziel, dann haben wir einen Schätzwert für die Gesamtentfernung, die wir unter der Eigenschaft SCHAETZUNG-GESAMTENTFERNUNG speichern. Wird die LISTE-EROEFFNETE-KNOTEN nach den Werten von SCHAETZUNG-GESAMTENTFERNUNG sortiert, dann ist ihr erster Knoten die beste Wahl, weil er den kürzesten Gesamtweg verspricht. Das Problem liegt im Berechnen eines geeigneten Schätzwertes. Auf keinen Fall darf der Schätzwert größer sein als die tatsächliche Entfernung zwischen dem Knoten und dem Ziel (Zulässigkeitsbedingung für das A*-Verfahren). Andernfalls wäre nicht sichergestellt, daß der erste Knoten von LISTE-EROEFFNETE-KNOTEN die höchste Priorität hat. Es könnte dann ein Knoten mit höherem Schätzwert letztlich eine kürzere Entfernung repräsentieren als der vermeintlich beste Knoten.

Legende: . . .

>> ::= zurückgelegter Weg ::= mögliche Wege

Bild 5.3-3. Differenz der X-Koordinatenwerte als Schätzung für die kürzeste Entfernung vom Knoten zum Zielknoten

Nehmen wir zur Erfüllung dieser Bedingung als extremen Schätzwert stets 0 an, dann entspricht das A*-Verfahren einem uninformierten Verfahren, mit der Konsequenz, daß wir viele Knoten expandieren müssen. Ein geeigneter Schätzwert ist die Differenz der X-Koordinatenwerte (vgl. Bild 5.3-3). Wie immer der Weg vom Knoten zum Zielknoten auch verläuft, kürzer als die Differenz der X-Koor-

II. Konstruktionen (Analyse und Synthese)

160

dinatenwerte kann er nicht sein, höchsten gleich groß. Damit wird auch die Konsistenzbedingung erfüllt. Sie fordert, daß für zwei beliebige Knoten K. und K die Differenz der Schätzwerte nicht gößer ist als die Differenz der tatsächlichen Entfernungen zum Zielknoten. ;;;; ;;;; ;;;; ;;; ;;: ;;; ;;; ;;; ;;; ;;;

Dokument 5 . 3 - 3 T i t e l : Programm A * - S E A R C H E r s t e l l t : 20.09.89 ¡letzte AI Al.l

AI.2

Änderung:

3.11.90

A*-SEARCH e r m i t t e l t in einem angegebenen Knotennetz d e n k ü r z e s t e n Weg v o n e i n e m S t a r t - z u e i n e m Z i e l - K n o t e n . D e r N a c h f o l g e r m i t dem k l e i n s t e n W e r t d e r F u n k t i o n E N T F E R N U N G S S C H A E T Z U N G - S T A R T - > Z I EL ( v g l . E 2 ) w i r d a l s nächster analysiert (expandiert). ( Z w e c k : Der " b e s t e " K n o t e n z u e r s t ) . Es s i n d e i n S t a r t - und e i n Z i e l k n o t e n a n z u g e b e n .

;;; ;;; ;;; ;;; ;;; ;;; ;:; ;;; ;;; ;;; ;;; ;;;

El El.l

;;; ;;;

T1 Tl.l

B e i s p i el Daten ( v g l .

;;; ;;;

Tl.2

A p p l i k a t i o n ( v g l . Tab. 5 . 3 - 2 ) e v a l > ( A * - S E A R C H ' H ' U ) = = > (H C E U)

El.2 E2

E3

Ein Knoten i s t ein Symbol. D i e K o o r d i n a t e n e i n e s K n o t e n s i n d a l s E i g e n s c h a f t ORT gespei chert. D i e N a c h f o l g e r e i n e s K n o t e n s und i h r e E n t f e r n u n g e n s i n d a l s E i g e n s c h a f t NACHFOLGER g e s p e i c h e r t und z w a r a l s folgende A-Liste: ((( )}) E N T F E R N U N G S S C H A E T Z U N G - S T A R T - > Z I E L a d d i e r t zum z u r ü c k g e l e g t e n Weg vom S t a r t zum K n o t e n d e n A b s o l u t b e t r a g d e r D i f f e r e n z d e r X - K o o r d i n a t e n w e r t e z w i s c h e n K n o t e n und Ziel knoten (vgl . B i l d 5 . 3 - 3 ) . Z w i s c h e n zwei n i c h t m i t e i n a n d e r v e r b u n d e n e n Knoten i s t d i e E n t f e r n u n g u n e n d l i c h ; h i e r i s t es der Wert 9 . 9 E 9 9 . Programmfragment

5.3-1)

( D E F I N E A * - S E A R C H (LAMBDA (START_KN0TEN Z I E L _ K N 0 T E N ) (LETREC ((LISTE-EROEFFNETE-KNOTEN ( L I S T START_KN0TEN)) (LISTE-GESCHLOSSENE-KNOTEN NIL) (ANALYSE-KNOTEN N I L ) (ARBEITSLISTE NIL) (GET-NACHFOLGER (LAMBDA (KNOTEN) (MAP ( L A M B D A ( X ) ( C A R ( G E T P R O P KNOTEN

X)) 'NACHFOLGER))))

(ENTFERNUNGSSCHAETZUNG-START->ZIEL (LAMBDA (KNOTEN) ( + ( G E T P R O P KNOTEN ' E N T F E R N U N G - V O M - S T A R T ) (ENTFERNUNGSSCHAETZUNG-KNOTEN->ZIEL KNOTEN)))) ( E N T F E R N U N G S S C H A E T Z U N G - K N O T E N - > Z I EL (LAMBDA (KNOTEN) ( A B S ( - (CAR (GETPROP Z I E L _ K N 0 T E N 'ORT)) ( C A R ( G E T P R O P KNOTEN ' O R T ) ) ) ) ) )

5. Abbildungsoption: Liste

161

(ENTFERNUNG-START-KNOTEN->ANDERER-KNOTEN (LAMBDA (KNOTEN ANDERER_KNOTEN) ( + ( G E T P R O P KNOTEN ' E N T F E R N U N G - V O M - S T A R T ) ; ; F a l l s KNOTEN n i c h t m i t A N D E R E R _ K N O T E N v e r b ü n d e n ;; i s t , w i r d a l s P s e u d o e n t f e r n u n g e i n g r o ß e r Wert ; ; angenommen ( v g l . E 3 ) . (COND ( ( C A D R ( A S S O C ANDERER.KNOTEN ( G E T P R O P KNOTEN ' N A C H F O L G E R ) ) ) ) (T 9 . 9 e 9 9 ) ) ) ) ) ;; Knoten i n LISTE-EROEFFNETE-KNOTEN s i n d i n der R e i h e n ;; f o l g e i h r e r P r i o r i t a e t s o r t i e r t . Zugaenge s i n d daher ;; entsprechend i h r e s Schaetzwertes einzufliegen. ( G E T - B E S T E - K N O T E N (LAMBDA ( L I S T E ) (CAR L I S T E ) ) ) (EINFUEGEN-NACH-ENTFERNUNGSSCHAETZUNG (LAMBDA (KNOTEN L I S T E ) (LETREC ((NEUE-WERT (ENTFERNUNGSSCHAETZUNG-START->ZIEL KNOTEN)) (EINFUEGEN (LAMBDA (K L) (COND ( ( N U L L ? L ) ( L I S T K ) ) ( ( < NEUE-WERT (GETPROP (CAR L) 'SCHAETZUNG-GESAMTENTFERNUNG)) (CONS K L ) ) (T ( C O N S ( C A R L ) ( E I N F U E G E N K (CDR L ) ) ) ) ) ) ) ) ( E I N F U E G E N KNOTEN L I S T E ) ) ) ) ;; OFFENE-KNOTEN s c h r e i b t d i e E i g e n s c h a f t s l i s t e f ü r d i e ; ; n e u e n K n o t e n d e r b e r e i n i g t e n A R B E I T S L I S E f o r t und ;; s o r t i e r t d i e s e in LISTE-EROEFFNETE-KNOTEN e i n . (OFFENE-KNOTEN (LAMBDA (KNOTEN) ( P U T P R O P KNOTEN (ENTFERNUNG-START-KNOTEN->ANDERER-KNOTEN A N A L Y S E - K N O T E N KNOTEN) 'ENTFERNUNG-VOM-START) ( P U T P R O P KNOTEN (ENTFERNUNGSSCHAETZUNG- S T A R T - > Z I E L KNOTEN) 'SCHAETZUNG-GESAMTENTFERNUNG) ( P U T P R O P KNOTEN A N A L Y S E - K N O T E N ' W E G ) (SET! LISTE-EROEFFNETE-KNOTEN (EINFUEGEN-NACH-ENTFERNUNGSSCHAETZUNG KNOTEN L I S T E - E R O E F F N E T E - K N O T E N ) ) ) )

II. Konstruktionen (Analyse und Synthese) NEUBERECHNEN-OFFENE-KNOTEN i s t e r f o r d e r l i c h f ü r d i e K n o t e n , d i e a u f e i n e m a n d e r e n Weg s c h o n e r r e i c h t w u r d e n , d . h . s i c h i n L I S T E - E R O E F F N E T - K N O T E N und ARBEITSLISTE befinden. (NEUBERECHNEN-OFFENE-KNOTEN (LAMBDA (KNOTEN) (LETREC ((NEUE-WERT (ENTFERNUNG-START-KNOTEN->ANDERER-KNOTEN ANALYSE-KNOTEN KNOTEN))) (COND ( ( < N E U E - W E R T ( G E T P R O P KNOTEN ' E N T F E R N U N G - V O M - S T A R T ) ) ( P U T P R O P KNOTEN NEUE-WERT 'ENTFERNUNG-VOM-START) ( P U T P R O P KNOTEN ( E N T F E R N U N G S S C H A E T Z U N G - S T A R T - > Z I E L KNOTEN) •SCHAETZUNG-GESAMTENTFERNUNG) ( P U T P R O P KNOTEN A N A L Y S E - K N O T E N ' W E G ) (SET! LISTE-EROEFFNETE-KNOTEN (EINFUEGEN-NACH-ENTFERNUNGSSCHAETZUNG KNOTEN ( D E L E T E ! KNOTEN LISTE-EROEFFNETE-KNOTEN)))) (T N I L ) ) ) ) ) ;; GEMEINSAME-KNOTEN g i b t e i n e L i s t e z u r ü c k , d i e n u r ; ; K n o t e n e n t h ä l t , d i e i n L I S T E _ 1 und L I S T E _ 2 v o r k o m m e n . (GEMEINSAME-KNOTEN (LAMBDA ( L I S T E _ 1 L I S T E _ 2 ) (COND ( ( N U L L ? L I S T E _ 1 ) N I L ) ((MEMBER (CAR L I S T E _ 1 ) LISTE_2) (CONS (CAR L I S T E _ 1 ) (GEMEINSAME-KNOTEN (CDR L I S T E _ 1 ) L I S T E _ 2 ) ) ) (T ( G E M E I N S A M E - K N O T E N ( C D R L I S T E _ 1 ) LISTE_2))))) ;; D I F F E R E N Z - K N O T E N g i b t L I S T E _ l z u r u e c k o h n e d i e E l e m e n t e , ;; d i e i n L I S T E _ 2 vorkommen. (DIFFERENZ-KNOTEN (LAMBDA ( L I S T E 1 L I S T E 2) (COND ( ( N U L L ? L I S T E _ 1 ) N I L ) ((MEMBER (CAR L I S T E _ 1 ) LISTE_2) ( D I F F E R E N Z - K N O T E N (CDR L I S T E _ 1 ) LISTE_2)) (T ( C O N S ( C A R L I S T E _ 1 ) (DIFFERENZ-KNOTEN (CDR L I S T E _ 1 ) LISTE_2)))))) D i e E i g e n s c h a f t WEG v e r k n u e p f t d e n A N A L Y S E - K N O T E N m i t seinen Nachfolgern. AUSGABE-WEGsetztdieseKette rueckw a e r t s v o n Z I E L _ K N O T E N zum S T A R T _ K N O T E N a l s L i s t e zusammen. (AUSGABE-WEG (LAMBDA (KNOTEN) (COND ( ( N U L L ? KNOTEN) N I L ) (T (APPEND ( A U S G A B E - W E G ( G E T P R O P KNOTEN ' W E G ) ) (LIST KNOTEN))))))

5. Abbildungsoption: Liste

163

;; Erlaeuterung siehe Tab. 5.3-2. (A*-SUCHE (LAMBDA () (COND ((NULL? L I S T E - E R O E F F N E T E - K N O T E N ) NIL) (T (SET! A N A L Y S E - K N O T E N (GET-BESTE-KNOTEN LISTE-EROEFFNETE-KNOTEN)) (SET! L I S T E - E R O E F F N E T E - K N O T E N (DELETE! A N A L Y S E - K N O T E N LISTE-EROEFFNETE-KNOTEN)) (SET! L I S T E - G E S C H L O S S E N E - K N O T E N (CONS A N A L Y S E - K N O T E N LISTE-GESCHLOSSENE-KNOTEN)) (COND ((EQ? A N A L Y S E - K N O T E N Z I E L _ K N O T E N ) (AUSGABE-WEG A N A L Y S E - KNOTEN)) (T (SET! A R B E I T S L I S T E (GET-NACHFOLGER A N A L Y S E - K N O T E N ) ) (FOR-EACH O F F E N E - K N O T E N (DIFFERENZ-KNOTEN (DIFFERENZ-KNOTEN ARBEITSLISTE LISTE-GESCHLOSSENE-KNOTEN) LISTE-EROEFFNETE-KNOTEN)) (FOR-EACH N E U B E R E C H N E N - O F F E N E - K N O T E N (GEMEINSAME-KNOTEN ARBEITSLISTE LISTE-EROEFFNETE-KNOTEN)) (A*-SUCHE)))))))) ;; Um A b b r u c h k r i t e r i u m fuer A U S G A B E - W E G zu haben. (PUTPROP START.KNOTEN NIL 'WEG) ;; I n i t i a l i s i e r u n g (PUTPROP S T A R T _ K N O T E N 0 ' E N T F E R N U N G - V O M - S T A R T ) (PUTPROP S T A R T . K N O T E N (ENTFERNUNGSSCHAETZUNG-START->ZIEL START_KNOTEN) 'SCHAETZUNG-GESAMTENTFERNUNG) ;; Start der (A*-SUCHE))) Programm 5.3-2.

Haupfunktion A*-SEARCH

Da das A*-Verfahren den kürzesten Weg ermittelt, können wir Ziel- und StartKnoten vertauschen und erhalten den gleichen Weg, wenn wir die erzeugte Liste umkehren. Bei der Tiefensuche ist dies nicht der Fall. eval > eval> eval> eval>

(DEPTH-FIRST 'U 'H) ==> (U E C H) (REVERSE (DEPTH-FIRST 'H 'U)) ==> (U E B A C H) (A*-SEARCH 'U 'H) = = > (U E C H) (REVERSE (A*-SEARCH 'H 'U)) = - > (U E C H)

164

II. Konstruktionen (Analyse und Synthese)

e v a l > ( A * - S E A R C H 'H X-KoY-Koordinate ordinate 8.5 11.5 15.5 10 8.5 6.5 8.5 5.5 14 6.5 15.5 4.5 15.5 3 0.5 0.5 17 6.5

Hauspoststationen A B C D E F G H U WEG

'U) = = >

P-Liste des Knotens S C H A E T Z U N G - ENTFERGESAMTENTUNG FERNUNG VOM SART

(H C E U)

(ohne O R T ) NACHFOLGER

c G F E

H H G F

22.,5 19. 20.Ì5 25.

14 17.5 19. 22.

D A

C C

23..5 27..5

15 19

Achtung! E

N E U B E R E C H N E N - O F F E N E - K N O T E N für E: C 22.5 19.5 ((C 5.5) (F 3)

B U ; U = Tab.

E 25.5 E 22.5 ZIEL_KN0TEN

24. 22.5

5 . 3 - 2 . Applikation des bei Startknoten Programmfragment

((D ((F ((E ((C

i:) (A 5:) (E 5,.5) (H 14)) (C) î..5) (H 17.5):) (G C) 3:) (G 1.,5)) (F C) 5.,5) (F 3) (B 4 . 5 ) (U 3)) (E C) ((C î:>) (D E) (A D E) ((C 5:> (B 8.,5))

((A 8 . 5 ) ((E 3))

(B 4 . 5 )

(E 4 . 5 ) )

OFFENE-KNOTEN-Konstruktes H, Zielknoten F und dem 5.3-1.

(U 3)) (E A D) (B A D) (U B A D) in Büro

A* von

5.4 Zusammenfassung: Liste, A-Liste und P-Liste Die Assoziationsliste (kurz: A-Liste) ist eine Liste, deren Elemente Sublisten sind, wobei das erste Element jeder Subliste die Aufgabe eines Zugriffsschlüssels hat. Statt Sublisten können auch Punkt-Paare stehen. Genutzt werden Konstruktionsmittel für die „einfache" Liste, d.h. die Konstruktoren CONS und LIST, die Selektoren CAR, CDR und LIST-REF, das Prädikat PAIR? und die Mutatoren SET!, SET-CAR! und SET-CDR!. Der Mutator SET! dient zum Benennen einer existierenden (Teil-)Liste. Die Mutatoren SET-CAR! und SET-CDR! ändern Listenelemente. Die Selektoren für ein A-Listen-Elenent (Subliste) prüfen das Schlüsselelement. Der Selektor ASSOC vergleicht mit EQUAL? und der Selektor ASSQ mit EQ?. Jedem Symbol ist eine zunächst leere Eigenschaftsliste (engl.: property list; kurz: P-Liste) zugeordnet. Das PUTPROP-Konstrukt fügt eine neue Eigenschaft

5. Abbildungsoption: Liste

165

ein bzw. überschreibt eine schon vorhandene. Das GETPROP-Konstrukt selektiert den Wert einer angegebenen Eigenschaft. Die P-Liste ist global. Dies hat Vor- und Nachteile. Vorteilhaft kann die P-Liste zur Kommunikation zwischen Konstrukten genutzt werden. Nachteilig ist die Gefahr ungewollter Nebeneffekte. Charakteristische

Beispiele für Abschnitt 5:

; ; ; ; Z i r k u l ä r e s Punkt-Paar e v a l > ( D E F I N E ENDLOS (CONS ' A ' B ) ) = = > ENDLOS e v a l X B E G I N ( S E T - C D R ! ENDLOS ENDLOS) ( S E T - C A R ! ENDLOS " L I S P : Das u l t i m a t i v e M o d e l l " ) #T) ¡Damit e i n e n d l i c h e r Rückgabewert b e s t e h t . = = > #T e v a l > ( L I S T - R E F ENDLOS 1 0 0 ) = = > " L I S P : Das u l t i m a t i v e ;;;; ;;; ;;; ;;;

Modell"

Zweidimensionale Matrix konstruiert als A - L i s t e . M i t H i l f e von M u t a t o r e n w i r d d i e l o k a l e MATRIX f o r t g e s c h r i eben. E i n E l e m e n t w i r d mit dem A S S O C - K o n s t r u k t s e l e k t i e r t ,

eval> (LET*

(DEFINE MAKE-X-Y-SPEICHER(LAMBDA ((MATRIX ;;

(LIST

Selektor

(GET

für

(LAMBDA (LET

()

'*MATRIX*))

(X

ein

Matrixelement

Y)

((ZEILE

(ASSOC X (CDR

(COND ( ( N U L L ? (T ( L E T

ZEILE)

MATRIX))))

NIL)

((SPALTE

(ASSOC Y (CDR

(COND ( ( N U L L ? (T ;;

Konstruktor/Mutator

(PUT!

(LAMBDA (LET

(CDR S P A L T E ) ) ) für

ein

ZEILE))))

NIL) ))))))

Matrixelement

(X Y WERT) ((ZEILE

(ASSOC X (CDR

(COND ( ( N U L L ?

(LIST

((SPALTE

MATRIX

X (CONS Y WERT))

(CDR (LET

MATRIX))))

ZEILE)

(SET-CDR! (CONS (T

SPALTE)

MATRIX))))

(ASSOC Y (CDR

(COND ( ( N U L L ?

ZEILE))):

SPALTE)

(SET-CDR! (CONS

ZEILE

(CONS Y WERT) (CDR

(T ( S E T - C D R !

ZEILE)))) SPALTE WERT))):

(PP

MATRIX)))

166

II. Konstruktionen (Analyse und Synthese) ;;

Verzweigungsfunktion

;;

jeweiligen

zum S e l e k t i e r e n

der

Operation

(DISPATCH (LAMBDA

(OP)

(COND

( ( E Q ? OP

'GET)

((EQ?

'PUT!)

(T

OP

(ERROR

GET) PUT!)

"Unbekannte

Operation:

" OP))))))

;;

Rückgabewert

DISPATCH)))

ist

==>

die

Verzweigungsfunktion

HAKE-X-Y-SPEICHER

eval>

(DEFINE

X-Y-MATRIX

eval>

(DEFINE

PUT!

(X-Y-MATRIX

'PUT!))

eval>

(DEFINE

GET

(X-Y-MATRIX

'GET))

eval>

(PUT!

1 2 "heute")

eval>

(PUT!

3 4 "gestern")

eval>

(PUT!

(*MATRIX* '(A

(3

B C)

(MAKE - X - Y - S P E I C H E R ) )

==>

(4

==>

(*MATRIX*

==>

X-Y-MATRIX

PUT! GET

(1

(2

.

"heute")))

(1

(2

.

"heute")))

==> .

#\a

==>

"gestern"))

"Alles

klar")

==>

(*MATRIX* (CA

eval> ;;;; ;;; ;;; ;;; ;;; ;;; ;;;

(GET

B C)

(#\a

. "Alles

(3

(4

.

"gestern"))

(1

(2

.

"heute")))

'(A

B C)

#\a)

==>

klar"))

"Alles

klar"

Geschachtelte GETPROP-Konstrukte Konten mit u n t e r s c h i e d l i c h e n TREND-Funktionen. Für e i n K o n t o , z . B . K001, w i r d über d i e E i g e n s c h a f t KONTO-TYP e i n Symbol s e l e k t i e r t . D i e s e s Symbol h a t a l s Wert s e i n e r E i g e n s c h a f t TREND, d i e anzuwendende T R E N D - F u n k t i o n . Das Argument f ü r d i e s e F u n k t i o n i s t u n t e r d e r E i g e n s c h a f t BUCHUNGEN g e s p e i c h e r t .

eval>

(PUTPROP

'K001

'VERMOEGEN

eval>

(PUTPROP

'K001

'(20

eva1>

(PUTPROP

'K002

'VERBRAUCH

eval>

(PUTPROP

'K002

'(10

eval>

(PUTPROP

'VERMOEGEN

(LAMBDA (MAP

30

'KONTO-TYP)

'BUCHUNGEN)

'KONTO-TYP)

100)

1.1

(GETPROP ==>

X)) 'BUCHUNGEN)))

#

VERMOEGEN

(20

==>

'BUCHUNGEN)

(X) KONTO

==>

==>

(KONTO) (LAMBDA (*

'TREND)

30)

30)

VERBRAUCH

==>

(10

30

100)

6. Abbildungsoption: Vektor

eval>

(PUTPROP

167

'VERBRAUCH

(LAMBDA (MAP

(KONTO) (LAMBDA (+

(X)

100

(GETPROP 'TREND) eval>

(DEFINE

==>

X)) KONTO

'BUCHUNGEN)))

#

TREND (LAMBDA

(KONTO)

((GETPROP (GETPROP

KONTO

'KONTO-TYP)

'TREND) KONTO)))

= = T R E N D

eval>

(TREND

'K001)

==>

(22.

33.)

eval>

(TREND

'K002)

==>

(110

130

200)

6. Abbildungsoption: Vektor LISP-Systeme ermöglichen neben der Definition von Listen auch die Definition von Vektoren. Dabei ist ein Vektor eine modifizierbare Struktur. Den Elementen dieser Strukur ist ein Index vom Typ ganzzahlige, positive Zahl (Integer-Zahl) zugeordnet. Die Vektorelemente können von beliebigem Typ sein, also auch wieder Vektoren. Z. B. ist ein zweidimensionales Feld (engl.: array) ein Vektor mit Vektoren als Elemente. Die Länge eines Vektors ist gegeben durch die Anzahl der Elemente, die er enthält. Sie wird zum Zeitpunkt der Vektordefinition festgelegt. Im Gegensatz zur Liste ist der Vektor daher eine „statische" Abbildungsoption. Ein Vektor hat eine signifikant andere Zugriffszeit-Charakteristik als eine Liste. Die Zugriffszeit ist konstant, d.h. sie ist unabhägig davon, ob auf ein Element am Anfang (kleiner Index) oder am Ende des Vektors (großer Index) zugegriffen wird. Bei der Liste steigt die Zugriffszeit linear mit der Position des gesuchten Elementes. Zunächst erörtern wir eingebaute Vektor-Konstrukte im Sinne des Verbundes von Konstruktor, Selektor, Prädikat und Mutator (Abschnitt 6.1). Mit diesen Konstrukten implementieren wir einen solchen Verbund für die Liste, d.h. wir bilden die CONS-Zelle als Vektor ab (vgl. Abschnitt 6.2). Anschließend nutzen wir die Abbildungsoption Vektor, um eine Aktenverwaltung als einen höhenbalancierten Baum abzubilden (vgl. Abschnitt 6.3). Dieses größere Beispiel möge gleichzeitig dem Training im Lesen fremder Programme dienen.

168

II. Konstruktionen (Analyse und Synthese)

6.1 Vektor- Konstrukte In Scheme unterscheidet sich die Notation eines Vektors von der einer Liste durch ein vorrangestelltes #-Zeichen. e v a l > # ( A B C D E) = = > # ( A B C 0 E) ¡ V e k t o r m i t 5 e v a l > # ( # ( A B) # ( C D) E) ;Vektor mit 3 = = > # ( # ( A B) # ( C D) E) e v a l > (VECTOR-LENGTH # ( # ( A ) ( B C D E ) ) ) = = > 2

Elementen Elementen

Wie die Beispiele zeigen, gilt für Vektoren die EVAL-Regel 1 (vgl. Abschnitt 1.2). Sie haben sich selbst als Wert. Wir können daher nicht (- wie im Fall der Liste -) direkt eine Funktionapplikation notieren. Enhält der Vektor eine Funktion und ihre Argumente und ist diese Funktion anzuwenden, dann ist der Vektor vorab in eine Liste zu überführen. Dazu dient das Konstrukt VECTOR->LIST. Das LIST->VECTOR-Konstrukt führt die umgekehrte Transformation aus. eval> eval> eval> eval> eval>

( D E F I N E F00 # ( + 1 2 3 ) ) = = > F00 F00 = = > # ( + 1 2 3 ) ( V E C T O R - > L I S T F 0 0 ) = = > ( + 1 2 3) (EVAL ( V E C T O R - > L I S T F 0 0 ) ) = = > 6 ( L I S T - > V E C T 0 R ' ( A B C ) ) = = > # ( A B C)

Konstruktoren:

eval>(VECTOR

eval> eval>

< e l _ 0 > < e l _ l > . . . < e l _ j > . . . < e l _ n > ) ==> #( . . . < w e r t _ j > . . . ) (MAKE-VECTOR k) ==> # ( . . . ) (MAKE-VECTOR k < i n i t - s e x p r > ) ==> # ( < v a l u e > . . . < v a l u e > )

mit:

#( . . . ) k

= j - t e Element des V e k t o r s = Wert von < e l _ j > , VECTOR und MAKE-VECTOR e v a l u i e r e n i h r e Argumente = Notation für einen Vektor = Anzahl der Elemente = I n i t i a l a u s d r u c k f ü r d i e g e n e r i e r t e n Elemente = Wert von < i n i t - s e x p r >

$e le letot" eval>

(VECTOR-REF < v e k t o r >

i)

==>

mit: i = 0 , 1, . . . ( - 1 + (VECTOR-LENGTH < v e k t o r > ) ) Das e r s t e E l e m e n t h a t den I n d e x 0 . Das l e t z t e E l e m e n t h a t den I n d e x d e r um 1 v e r m i n d e r t e n V e k t o r l ä n g e . VECTOR-REF i s t " z e r o b a s e d " .

169

6. Abbildungsoption: Vektor Prädikat: eval>

(VECTOR?

)

= = > #T

¡Falls ; ist,

ein sonst NIL.

ein

Vektor

Mutator: eval>

(VECTOR-SET!

i

) = >

#(

...

i

hat

den Wert

...)

mit:

::=

Das E l e m e n t .

von

Die folgenden Beispiele verdeutlichen diese VECTOR-Konstrukte. eval>

(DEFINE

eval> eval> eval> eval>

( V E C T O R ? * V 0 0 1 * ) = = > #1 ( V E C T O R - R E F * V 0 0 1 * 3 ) = = > ERROR . . . : V e k t o r i n d e x z u g r o ß (VECTOR-REF * V 0 0 1 * 1) = = > 2858 (VECTOR-SET! *V001* 0 " S c h i f f d o r f " ) ==> # ( " S c h i f f d o r f " 2858 "04703/5270) (MAKE-VECTOR 4 " J " ) ==> # ( " J " " J " " J " "J") ( V E C T O R ? (MAKE-VECTOR 3 0 ) ) = = > #T (VECTOR? ( L I S T 1 2 ) ) ==> N I L

eval> eval> eval>

*V001*

(VECTOR

"Sellstedt"

2858

"04703/5270")) ==> *V001*

eval>

(DEFINE M0DUL-V! ¡ D e s t r u k t i v e s K o n s t r u k t durch VECTOR-SET! (LAMBDA (OBJEKT INDEX NEUE.WERT) (COND ( ( A N D ( V E C T O R ? O B J E K T ) (INTEGER? INDEX) ( MODUL-V!

eval>

(MODUL-V!

eval>

*V001*

(MODUL-V!

*V001*

==> #{"Bremen"

1 2500) 0 "Bremen") ==> # ( " B r e m e n " 2500 " 0 4 7 0 3 / 5 2 7 0 " ) 2500 " 0 4 7 0 3 / 5 2 7 0 " )

Zum Vergleich ist für MODUL-V! im folgenden eine Listenlösung angegeben: eval> eval>

(DEFINE

*L001*

(LIST

"Schiffdorf"

2858

"04703/5270")) ==> * L001* (DEFINE MODUL-L! ¡ D e s t r u k t i v e s K o n s t r u k t d u r c h SET-CAR! (LAMBDA ( O B J E K T INDEX NEUE_WERT) (COND ( ( A N D ( P A I R ? O B J E K T ) (INTEGER? INDEX) ( MODUL-L!

170

II. Konstruktionen (Analyse und Synthese)

eval> (MODUL-L! (MODUL-L! *L001* 1 2500) 0 "Bremen") ==> ("Bremen" 2500 "04703/5270") eval> *L001* ==> ("Bremen" 2500 "04703/5270") Wann eine A-Liste effizienter als ein Vektor ist, d.h. eine kleinere durchschnittliche Selektionszeit hat, ist abhängig von der jeweiligen LISP-Implementation. Als Faustregel gilt, daß ein dünn besetzter Vektor besser als eine A-Liste zu implementieren ist (vgl. Abschnitt 5.4, zweidimensionale Matrix).

6.2 Abbildung der CONS-Zelle als Vektor Die CONS-Zelle verknüpft zwei symbolische Ausdrücke (vgl. Abschnitt 2.1). Sie ist das klassische Mittel um eine Liste zu konstruieren. Wir bilden im folgenden eine CONS-Zelle als Vektor ab. Den Konstruktor für diese CONS-Zelle nennen wir V-CONS. Damit vermeiden wir Namensgleichheit und infolgedessen das Überschreiben des eingebauten CONS-Konstruktes. Selektoren, Prädikate und Mutatoren haben aus gleichem Grund den Präfix „V-". Zum Konstruieren einer Liste gehen wir von NIL, der leeren Liste, aus. Wir definieren daher ein *V-NIL* mit dem Konstrakt VECTOR. Die Sternchen im Namen sollen ein versehenliches Überschreiben dieser globalen Variablen verhindern (Näheres zur Benennung vgl. Abschnitt 11.1). Das *V-NIL* kann, wie folgt, definiert werden: eval> (DEFINE *V-NIL* (VECTOR #\0 # \ 0 ) ) ==> *V-NIL* Das zugehörende Prädikat V-NULL? könnten wir so definieren, daß jeder Vektor mit den beiden Elementen #\0 ein *V-NIL* repräsentiert. Das V-NULL?-Prädikat stützt sich damit auf den Vergleich der Elemente: eval> (DEFINE V-NULL? (LAMBDA (V_PAIR) (AND (VECTOR? V_PAIR) (= (VECT0R-LENGTH V_PAIR) 2) (EQ? (VECT0R-REF V_PAIR 0) # \ 0 ) ) (EQ? (VECT0R-REF V_PAIR 1) # \ 0 ) ) ) ) ) ==> V-NULL? Wir unterstellen jedoch, daß es nur ein Objekt gibt, das *V-NIL* repräsentiert. Das Prädikat V-NULL? testet daher auf Identität und nicht auf Gleichheit von Strukturen (vgl. Abschnitt 2.1). Das V-NULL?-Konstrukt nutzt daher für den direkten Vektor-Vergleich das EQ?-Konstrakt. eval> (DEFINE V-NULL? (LAMBDA (0BJECT) (EQ? 0BJECT *V-NIL*))) ==> V-NULL? Der Konstruktor CONS generiert eine neue CONS-Zelle, um den CAR-Teil mit

6. Abbildungsoption: Vektor

171

dem CDR-Teil zu verknüpfen. Dies Verknüpfung realisieren wir durch das Konstruieren eines zweielementigen Vektors. eval>

( D E F I N E V-CONS (LAMBDA ( C A R _ T E I L C D R _ T E I L ) (VECTOR C A R . T E I L C D R _ T E I L ) ) )

==>

V-CONS

Die Selektoren V-CAR und V-CDR realiseren wir dann mit dem Selektor VECTOR-REF. eval>

eval>

(DEFINE V-CAR (LAMBDA ( V _ P A I R ) (VECTOR-REF V_PAIR

0)))

==>

V-CAR

( D E F I N E V-CDR ( L A M B D A ( V _ PA I R ) (VECTOR-REF V.PAIR

1)))

==>

V-CDR

Das erforderliche Prädikat V-PAIR? nutzt das eingebaute Prädikat VECTOR?. Das V-PAIR?-Konstrukt testet, ob eine V-CONS-Zelle vorliegt (bzw. mehrere). Da nicht jeder Vektor vom Typ V-CONS ist, überprüft V-PAIR? auch die Länge des Vektors. Wir unterstellen damit, daß jeder zweielementige Vektor eine VCONS-Zelle ist. eval>

(DEFINE V-PAIR? ( L A M B D A ( V _ PA I R ) (AND (VECTOR? V_PAIR) (= (VECTOR-LENGTH

V_PAIR)

2))))

==>

V-PAIR?

Die Mutatoren V-SET-CAR! und V-SET-CDR! sind mit dem eingebauten Mutator VECTOR-SET! leicht realisierbar. eval>

eval>

(DEFINE V-SET-CAR! (LAMBDA ( V _ P A I R C A R . T E I L ) (VECTOR-SET! V_PAIR 0 CAR_TEIL)))

==>

V-SET-CAR!

(DEFINE V-SET-CDR! ( L A M B D A ( V _ PA I R C D R_ T E I L ) (VECTOR-SET! V_PAIR 1 CDR_TEIL)))

==>

V-SET-CDR!

Unser Verbund von Konstruktor V-CONS, Selektoren V-CAR und V-CDR sowie Prädikat V-NULL? hat die wesentliche Eigenschaft: Das Zusammengefügte kann ohne Verlust wieder getrennt werden. eval> eval> eval>

( V - C A R ( V - C O N S 'X ' Y ) ) ==> X ( V - C D R ( V - C O N S 'X ' Y ) ) ==> Y (V-NULL? (V-CAR (V-CONS * V - N I L *

*Y)))

==>

#T

172

II. Konstruktionen (Analyse und Synthese)

e v a l > ( V - N U L L ? ( V - C D R ( V - C O N S 'X * V - N I L * ) ) ) = = > # T e v a l > ( D E F I N E F 0 0 ( V - C O N S 'X 'Y)) = = > F00 e v a l > F00 = = > # ( X Y) Der Wert von FOO „verrät", daß unsere V-CONS-Zellen als Vektoren abgebildet sind. Wir definieren ein geeignetes V-PP-Konstrukt, um auch nach außen hin das gewohnte Layout einer Listen-Darstellung vermitteln zu können. eval> (DEFINE V-PP (LAMBDA (V_PAIR) (LETREC ((V-ATOM? (LAMBDA (OBJEKT) (NOT ( V - P A I R ? O B J E K T ) ) ) ) (AUSGABE (LAMBDA (V_PAIR) (COND ( ( V - N U L L ? V _ P A I R ) ( D I S P L A Y ") ")) ((V-ATOM? (V-CAR V_PAIR)) (WRITE ( V - C A R V _ P A I R ) ) (COND ( ( V - P A I R ? ( V - C D R V _ P A I R ) ) (COND ( ( V - N U L L ? (V-CDR V _ P A I R ) ) ( A U S G A B E (V-CDR V _ P A I R ) ) ) (T ( D I S P L A Y " ") (AUSGABE (V-CDR V_PAIR))))) (T (DISPLAY " . ") (WRITE (V-CDR V_PAIR)) (AUSGABE *V-NIL*)))) (T ( D I S P L A Y "(") (AUSGABE (V-CAR V_PAIR)) (AUSGABE (V-CDR V_PAIR))))))) (COND ( ( V - P A I R ? V _ P A I R ) (DISPLAY "(") (AUSGABE V_PAIR)) (T (WRITE V _ P A I R ) ) ) ¡ A u s g a b e e i n e s s o n s t i g e n *THE-NON-PRINTING-OBJECT*))) ==> V-PP e v a l > ( D E F I N E FOO ( V - C O N S "Emma" ( V - C O N S " K r a u s e "

Objektes

*V-NIL*))) = = > FOO

e v a l > ( D E F I N E B A R ( V - C O N S "Frau" F O O ) ) = = > B A R e v a l > ( V - P P B A R ) = = > ( " F r a u " "Emma" " K r a u s e " ) eval> (V-PP ( V - C O N S '*TAB* ( V - C O N S ( V - C O N S 'A f B ) ( V - C O N S 'X * V - N I L * ) ) ) ) = = > ( * T A ß * (A . B) X)

6.3 Höhenbalancierter Baum Beispiel Aktenverwaltung Als Beispiel dient eine Verwaltung von Akten, bei der man neue Akten anlegen und angelegte Aktenbeschreibungen modifizieren kann; jedoch keine Akten entfernen (löschen) kann (vgl. Programm 6.3-1). Unterstellt wird für jede Akte ein eindeutiges Aktenzeichen (KEY). Jedem Aktenzeichen kann ein beliebiger Text

6. Abbildungsoption: Vektor

173

als Inhaltsbeschreibung zugeordnet werden. Die erfaßten Akten können in einer anzugebenden Datei abgelegt und von dieser wieder eingelesen werden. Da unterstellbar ist, daß in dieser Aktenverwaltung häufig gesucht und neue Akten eingefügt werden, speichern wir die Akten als „höhenbalancierten Baum" (engl.: balanced tree). Für einen binären Baum gilt folgende Definition der Ausgeglichenheit: Defintion: Ausgeglichenheit. Ein Baum ist genau dann ausgeglichen, wenn sich für jeden Knoten die Höhen der zugehörigen Teilbäume um höchstens 1 unterscheiden (Adelson-Velskii/Landis, 1962; zitiert nach Wirth, 1983, S.244). Dabei ist die Höhe eines Baumes gleich der maximalen Astlänge (größte Knotenzahl zu einem Baumblatt). Ein solcher ausgeglichener Baum wird zu Ehren von Adelson-Velskii und Landis kurz als AVL-Baum bezeichnet. In einigen LISP-Systemen sind Konstrukte für die Handhabung von AVL-Bäumen integriert (z.B. Cambridge LISP, vgl. Anhang B; Näheres zu AVL-Bäumen vgl. z.B. Kruse, 1984 oder Mühlbacher, 1978). Ein AVL-Baum ist durch einen Vektor abbildbar, der die Wurzel darstellt. Für unsere Aktenverwaltung ist es ein Vektor mit den fünf Elementen: o o o o o

Höhe des Baums, Aktenzeichen (KEY), zugeordnete Aktenbeschreibung (TEXT), linker Teilbaum und rechter Teilbaum.

Die sogenannte Balance B eines Baums ist für einen Knoten, wie folgt, definiert: B ::= Höhe des rechter Teilbaums minus Höhe des linken Teilbaums Zum Aufbau eines AVL-Baums dient ein Anfangsbaum, hier *LEERERBAUM*. In diesen leeren Baum werden zunächst Aktenzeichen, d.h. neue Knoten, eingefügt. Beim Einfügen ist zu überprüfen, ob weiterhin das Kriterium der Ausgeglichenheit gegeben ist. Liegt die Ausgeglichenheit nicht mehr vor, dann ist abhängig vom Baumzustand eine Rotation vorzunehmen. Bei der Rotation ist der jeweilige Wurzelknoten neu zu ermitteln. Die bisherigen Teilbäume sind „umzuhängen", so daß der linke Ast stets zu den kleineren Key-Werten und der rechte Ast zu den größeren Key-Wert führen. Bei dieser Rotation sind vier Fälle zu unterscheiden (vgl. Bild 6.3-1). Das Einfügen eines Knotens ist als Konstruieren eines neuen AVL-Baums implementiert und nicht mit Hilfe des Mutators VECTOR-SET!. Der Grund ist hier das leichtere Verstehen des Beispielprogramms.

174

II. Konstruktionen (Analyse und Synthese)

Fall

1:

Linker Vor der

Teilbaum =>

für L = -2 für G , D - -1 für A,H,Y = 0

Fall

Rechter

Teilbaum

Vor

Rotation

Bai a n c e

für für für für

der

Wurzel

(einfache

Rotation

Bai a n c e

2:

neue

Rotation)

Nach der Balance

vom

G = -2 E = -1 AL,DZ,EL,H,Y D,A,DL = 1

linken

Rotation

für A , H , Y , G = 0 für D = -1

T e i l b a u m => neue Wurzel (doppelte Rotation) Nach der Rotation Balance

für A , D L , G = für sonst =

+1 0

= 0

r

iL

k

'

Àl

Fall

'

3:

Rechter T e i l b a u m => Vor

Balance

für für für für

der

neue Wurzel

Rotation

^

(einfache

Nach

Y = -1 D,A,E,H,GA,HA,X,Z= L - 1 G = 2

1A

ÄL

r

i

der

Balance 0

n

fr

i

Rotation)

Rotation für für für

HA

Y = V = sonst =

H

L

-1 1 0

6. Abbildungsoption: Vektor

Fall

4:

Linker Vor

Teilbaum

der

für für für für

175

vom

rechten

T e i l b a u m => neue Wurzel (doppelte Rotation; Nach der Rotation

Rotation

L - -1 D, A,, E , G A , H A , Y , X , Z = H = 1 G - 2

Balance 0

GA für für s o n s t

G

í

—

J

= -1 = 0

H

1

i

,

I

1

fl

5T

J

1 HZ X

I

,

,

}

6

H Z

A

E

i

1

,

'

¡U I

HA

,

í

L-

HF H

HA Legende: A

Z

::= A u s p r ä g u n g e n d e s S c h l ü s s e l s ( K E Y ) f ü r d e n binären Baum. Sie repräsentieren einen Knoten als f o l g e n d e n V e k t o r : D

#(2

"D"

"Text"

)

mi t:

#(1

::= "A" < t e x t >

::=

#(1

"E"

KEY

zugeordnete

::= Z u m

*LEERER-BAUM*

*LEERER-BAUM*)

*LEERER-BAUM*

*LEERER-BAUM*)

Daten

eval> *LEERER-BAUM* ==> #(0 NIL NIL) B i l d 6 . 3 - 1 . Ausbai anderen eines Baums durch Rotation - Beispiel zum V e r s t e h e n des K o n s t r u k t e s AVL-BAUM-MONTAGE - (vgl.Pro-gramm 6.3-1)

Das Konstrukt AKTENVERWALTUNG nutzt die Möglichkeit eine LAMBDASchnittstelle (vgl. Abschnitt 1.4.1) für eine unbestimmte Anzahl von Argumenten zu definieren. eval>

(DEFINE AKTENVERWALTUNG (LAMBDA (OPERATION . PARAMETER) ¡Schnittstelle ... ) ;Funktionskörper ==> AKTENVERWALTUNG

176

II. Konstruktionen (Analyse und Synthese)

Die LAMBDA-Variable OPERATION wird an den Wert des ersten Arguments gebunden. Aufgrund der Angabe des Punkt-Paares werden alle Werte von weiteren Argumenten zunächst zu einer Liste zusammengefaßt, dann wird die LAMBDA-Variable PARAMETER an diese Liste gebunden. Gibt es keine weiteren Argumente, hat PARAMETER den Ersatzwert NIL. e v a l > (AKTENVERWALTUNG ' E I N G A B E " A - 1 2 " " F a l l ¡Während d e r A b a r b e i t u n g d i e s e r A p p l i k a t i o n ; düngen g e g e b e n : ; OPERATION — > EINGABE ; PARAMETER—> ("A-12" "Fall Krause")

K r a u s e " ) = = > #T sind folgende Bin-

Diese LAMBDA-Schnittstelle gestattet es z.B, die AKTENVERWALTUNG zum Anzeigen der erfaßten Aktenzeichen mit weniger Argumenten aufzurufen als beim Einfügen eines Aktenzeichens. e v a l > (AKTENVERWALTUNG ' S T R U K T U R - Z E I G E N ) = = > . . . ¡Während d e r A b a r b e i t u n g d i e s e r A p p l i k a t i o n s i n d ; düngen g e g e b e n : ; OPERATION — > S T R U K T U R - Z E I G E N ; PARAMETER — > ( ) ;Da k e i n A r g u m e n t h i e r f ü r a n g e g e b e n i s t , ; w i r d der E r s a t z w e r t ( e n g l . : d e f a u l t ; v a l u e ) angenommen.

folgende

Bin-

Die globale Variable *DATEN* hat den aktuellen Bearbeitungsstand, d.h. den AVL-Baum, als Wert. Wir sichern diesen mit Hilfe des eingebauten SchemeKonstruktes WITH-OUTPUT-TO-FILE. Das Laden des gesicherten AVL-Baumes erfolgt mit dem Konstrukt WITH-INPUT-FROM-FILE. Diese beiden Konstrukte arbeiten mit einem LAMBDA-Konstrukt ohne LAMBDA-Variable („thunk", vgl. Abschnitt 2.3). Es wird ausgeführt mit der angegebenen Datei als aktuelle Datenquelle bzw. Datensenke. eval>

eval>

; ; S i c h e r u n g d e s AVL-Baumes (WITH-OUTPUT-TO-FILE "C: W L I S P - E X W A V L . D A T " (LAMBDA ( ) (WRITE * D A T E N * ) ) = = > . ; ; Laden d e s A V L - B a u m e s (SET! *DATEN* (WITH-INPUT-FROM-FILE "C: W L I S P - E X W A V L . D A T " (LAMBDA ( ) ( R E A D ) ) ) ) = = >

; Si cherungsdatei ;Speicherungsfunktion

; Si cherungsdatei ; Ei n i e s e f u n k t i on

177

6. Abbildungsoption: Vektor

Dokument 6.3-1 Titel: Programm AKTENVERWALTUNG Erstellt: 25.09.89; letzte Aenderung:

19.10.90

AI AI.1

AKTENVERWALTUNG speichert einen Aktenbestand. E i n e A k t e b e s t e h t a u s e i n e m A k t e n z e i c h e n (= K E Y ) u n d e i n e m E r l ä u t e r u n g s t e x t (= T E X T ) . A I . 2 Ein h ö h e n b a l a n c i e r t e r B a u m ( A V L - B a u m ) r e p r ä s e n t i e r t d e n Aktenbestand. A2

Ein n e u e r KEY ist in d e n A V L - B a u m e i n f ü g b a r . g e p r ü f t , ob d e r B a u m a u s g e g l i c h e n i s t , f a l l s w i r d ein neuer A V L - B a u m k o n s t r u i e r t .

A3

Ein T E X T

A4

Eingespeicherter 1öschbar

El

J e d e r B a u m k n o t e n ist e i n V e k t o r , d e r B a u m h ö h e , T E X T und die beiden T e i l b ä u m e a b b i l d e t :

#(

ist durch

einen

KEY

neuen

istausdem

ersetzbar. AVL-Baumnicht

Typ

Zeichenkette

KEY,

)

E2

KEY

E3 E4

TEXT hat einen b e l i e b i g e n Typ ;vgl . A l . l Zum A u s b a l a n c i e r e n des A V L - B a u m e s (beim E i n f ü g e n von neuen Aktenzeichen) wird eine KEY-Gleichheit mit dem S T R I N G - C I = ? - K o n s t r u k t f e s t g e s t e l l t . Es g i b t d a h e r k e i n e Unterscheidung durch eine Gross-/Kl einschreibung. Z . B . : Ist "A-1 - 1 2 3 " d a m i t g l e i c h " a - 1 - 1 2 3 " .

E5 E5.1

hat den

Dabei w i r d nicht,

;vgl.

Al.l

Benutzerschnittstelle: Laden eines A k t e n b e s t a n d e s : ( A K T E N V E R W A L T U N G 'START "") E5.2 Sichern eines A k t e n b e s t a n d e s : ( A K T E N V E R W A L T U N G 'ENDE "") E5.3 Eingeben/Modifizieren einer Akte: (AKTENVERWALTUNG 'EINGABE "" "") E5.4 A n z e i g e n A k t e : (AKTENVERWALTUNG 'GET-TEXT "") E5.5 Kleinste A k t e n z e i c h e n : (AKTENVERWALTUNG 'GET-MIN-KEY) E5.6 G r ö ß t e A k t e n z e i c h e n : (AKTENVERWALTUNG 'GET-MAX-KEY) E5.7 Nächstes A k t e n z e i c h e n : (AKTENVERWALTUNG 'GET-NEXT-KEY) E5.7 B e s t a n d an A k t e n z e i c h e n als A V L - B a u m z e i g e n : (AKTENVERWALTUNG 'STRUKTUR-ZEIGEN)

178

II. Konstruktionen (Analyse und Synthese) T1 B e i s p i e l Tl.l

Aktenbestand: eval > (BEGIN (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG (AKTENVERWALTUNG

'EINGABE 'EINGABE 'EINGABE 'EINGABE 'EINGABE 'EINGABE 'EINGABE 'EINGABE 'ENDE "C:

" L - a - 2 " " F a l l Meyer") " L - a - 2 / b " " F o r t s e t z u n g Meyer") "G-b-3-2" "Plan Westfeld") "Y-345-6" " F a l l Schulze") "Dortmund" " S t a d t p l a n u n g " ) "Herbert" " F a l l Herbert") "A-l-122" "Rechnerbeschaffung": "G-b-3-2" "Plan Neu-Westfeid") W L I S P - E X W A V L . D A T " ) ) ==> . . .

; ; ; T l . 2 E r z e u g t e r AVL-Baum ; // ;;; e v a l > (AKTENVERWALTUNG 'STRUKTUR-ZEIGEN) ==> ;;; Y-345-6 III ;;; L-a-2/b III ;;; L - a - 2 IM ;;; Herbert III ;;; G - b - 3 - 2 131 ;;; Dortmund /2/ ;;; A-l-122 III (DEFINE *DATEN* ( ) ) ( D E F I NE AKTENVERWALTUNG (LAMBDA (OPERATION . PARAMETER) (LETREC ;;;;

K o n s t r u k t o r e n , S e l e k t o r e n und P r ä d i k a t e ((MAKE-BAUM (LAMBDA (HOEHE KEY TEXT L I N K E R - T E I L RECHTER-TEIL) (VECTOR HOEHE KEY TEXT L I N K E R - T E I L R E C H T E R - T E I L ) ) ) (AVL-BAUM? (LAMBDA (BAUM) (COND ((LEERER-BAUM? BAUM) BAUM) ((AND (VECTOR? BAUM) ( = (VECTOR-LENGTH BAUM) 5) (INTEGER? (BAUM-HOEHE BAUM)) ( P O S I T I V E ? (BAUM-HOEHE BAUM)) (STRING? (BAUM-KEY BAUM)) (AVL-BAUM? (LINKER-TEILBAUM BAUM)) (AVL-BAUM? (RECHTER-TEILBAUM BAUM)) (= (BAUM-HOEHE BAUM) (1+ (MAX (BAUM-HOEHE (LINKER-TEILBAUM BAUM)) (BAUM-HOEHE (RECHTER-TEILBAUM BAUM))))) (= (BALANCE BAUM) - 1 ) (OR (LEERER-BAUM? (LINKER-TEILBAUM BAUM)) (STRING-CK? (BAUM-KEY (LINKER-TEILBAUM BAUM)) (BAUM-KEY BAUM))) (OR (LEERER-BAUM? (RECHTER-TEILBAUM BAUM)) (STRING-CK? (BAUM-KEY BAUM) (BAUM-KEY (RECHTER-TEILBAUM BAUM)))))

179

6. Abbildungsoption: Vektor BAUM) (T NIL)))) ;: Zur B e s t i m m u n g der A u s g e g l i c h e n h e i t (BALANCE (LAMBDA (BAUM) (COND ((LEERER-BAUM? BAUM) 0) (T (- (BAUM-HOEHE ( R E C H T E R - T E I L B A U M BAUM)) (BAUM-HOEHE ( L I N K E R - T E I L B A U M B A U M ) ) ) ) ) ) ) ( * L E E R E R - B A U M * (MAKE-BAUM 0

NIL N I L ) )

(LEERER-BAUM? (LAMBDA (BAUM) (AND (VECTOR? BAUM) (= (VECTOR-LENGTH BAUM) 5) (= (BAUM-HOEHE BAUM) 0) (STRING-NULL? (BAUM-KEY BAUM)) (STRING-NULL? (BAUM-TEXT BAUM)) (NULL? ( L I N K E R - T E I L B A U M BAUM)) (NULL? ( R E C H T E R - T E I L B A U M BAUM))))) (BAUM-HOEHE (LAMBDA (BAUM) ( V E C T O R - R E F BAUM 0 ) ) ) (BAUM-KEY (LAMBDA (BAUM) ( V E C T O R - R E F BAUM 1))) (BAUM-TEXT (LAMBDA (BAUM) ( V E C T O R - R E F BAUM 2 ) ) ) (LINKER-TEILBAUM (LAMBDA (BAUM) (VECTOR-REF BAUM 3 ) ) ) (RECHTER-TEILBAUM (LAMBDA (BAUM) (VECTOR-REF BAUM 4 ) ) ) (GET-KEY-AVL-BAUM (LAMBDA (KEY BAUM) (COND ( ( L E E R E R - B A U M ? BAUM) BAUM) ((STRING-CI=? KEY (BAUM-KEY BAUM)) BAUM) ( ( S T R I N G - C K ? KEY (BAUM-KEY BAUM)) ( G E T - K E Y - A V L - B A U M KEY (LINKER-TEILBAUM BAUM))) ( ( S T R I N G - C K ? (BAUM-KEY BAUM) KEY) ( G E T - K E Y - A V L - B A U M KEY ( R E C H T E R - T E I L B A U M BAUM))) (T (ERROR "Fehler bei G E T - K E Y - A V L - B A U M ! " BAUM))))) (GET-MINIMUM-KEY-AVL-BAUM (LAMBDA (BAUM) (COND ( ( L E E R E R - B A U M ? BAUM) BAUM) ((LEERER-BAUM? ( L I N K E R - T E I L B A U M BAUM)) BAUM) (T ( G E T - M I N I M U M - K E Y - A V L - B A U M (LINKER-TEILBAUM B A U M ) ) ) ) ) ) (GET-MAXIMUM-KEY-AVL-BAUM (LAMBDA (BAUM) (COND ( ( L E E R E R - B A U M ? BAUM) BAUM) ((LEERER-BAUM? ( R E C H T E R - T E I L B A U M BAUM)) BAUM) (T ( G E T - M A X I M U M - K E Y - A V L - B A U M ( R E C H T E R - T E I L B A U M BAUM))))))

II. Konstruktionen (Analyse und Synthese) (GET-NEXT-KEY-AVL-BAUM (LAMBDA (KEY BAUM) (COND ((LEERER-BAUM? BAUM) BAUM) ( ( S T R I N G - C K ? KEY (BAUM-KEY BAUM)) (LET ((L-TEIL (GET-NEXT-KEY-AVL-BAUM KEY (LINKER-TEILBAUM BAUM)))) (COND ((LEERER-BAUM? L-TEIL) BAUM) (T L - T E I L ) ) ) ) ((STRING-CI=? KEY (BAUM-KEY BAUM)) (GET-MINIMUM-KEY-AVL-BAUM ( R E C H T E R - T E I L B A U M BAUM))) ( ( S T R I N G - C K ? (BAUM-KEY BAUM) KEY) (GET-NEXT-KEY-AVL-BAUM KEY ( R E C H T E R - T E I L B A U M BAUM))) (T (ERROR "Fehler bei G E T - N E X T - K E Y - A V L - B A U M :" BAUM))))) (AVL-BAUM-MONTAGE (LAMBDA (BAUM L_TEILBAUM R_TEILBAUM) (LET* ((L-HOEHE (BAUM-HOEHE L_TEILBAUM)) (R-HOEHE (BAUM-HOEHE R_TEILBAUM) ) (KNOTENBILDUNG (LAMBDA (KEY TEXT L_BAUM R_BAUM) (MAKE-BAUM (1+ (MAX (BAUM-HOEHE L_BAUM) (BAUM-HOEHE KEY TEXT L_BAUM R.BAUM))))

R.BAUM)))

(COND (;; A u s g e g g l i c h e n (AND (< L - H O E H E (+ R - H O E H E 2)) (< R - H O E H E (+ L - H O E H E 2 ) ) ) (KNOTENBILDUNG (BAUM-KEY BAUM) (BAUM-TEXT BAUM) L_TEILBAUM R_TEILBAUM)) ;; Fall 1 (Bild 6.3-1) ((AND (> L - H O E H E R-HOEHE) (< (BALANCE L.TEILBAUM) 1)) (LET* ((L-L-TEIL ( L I N K E R - T E I L B A U M L.TEILBAUM)) (R-L-TEIL ( R E C H T E R - T E I L B A U M L_TEILBAUM)) (R-L-TEIL&R-TEIL (KNOTENBILDUNG (BAUM-KEY BAUM) (BAUM-TEXT BAUM) R-L-TEIL R.TEILBAUM))) (KNOTENBILDUNG (BAUM-KEY L.TEILBAUM) (BAUM-TEXT L.TEILBAUM) L-L-TEIL R-L-TEIL&R-TEIL)))

6. Abbildungsoption: Vektor

181

;; Fall 2 (Bild 6.3-1) ( ( A N D ( > L-HOEHE R-HOEHE) ( = (BALANCE L _ T E I L B A U M ) 1 ) ) ( L E T * ((NEUE-WURZEL (RECHTER-TEILBAUM L_TEILBAUM)) ( L - R - L - T E I L (LINKER-TEILBAUM NEUE-WURZEL)) ( L - L - T E I L (LINKER-TEILBAUM L_TEILBAUM)) ( R - R - L - T E I L (RECHTER-TEILBAUM NEUE-WURZEL)) (L-L-TEIL&L-R-L-TEIL (KNOTENBILDUNG (BAUM-KEY L _ T E I L B A U M ) (BAUM-TEXT L _ T E I L B A U M ) L-L-TEIL L-R-L-TEIL)) (R-R-L-TEIL&R-TEIL (KNOTENBILDUNG (BAUM-KEY BAUM) (BAUM-TEXT BAUM) R - R - L - T E I L R_TEILBAUM))) (KNOTENBILDUNG (BAUM-KEY NEUE-WURZEL) (BAUM-TEXT NEUE-WURZEL) L-L-TEIL&L-R-L-TEIL R-R-L-TEIL&R-TEIL))) ;; Fal1 3 ( B i l d 6 . 3 - 1 ) ( ( A N D ( < L-HOEHE R-HOEHE) ( > (BALANCE R _ T E I L B A U M ) - 1 ) ) ( L E T * ( ( R - R - T E I L (RECHTER-TEILBAUM R_TEILBAUM)) ( L - R - T E I L (LINKER-TEILBAUM R_TEILBAUM)) (L-TEIL&L-R-TEIL (KNOTENBILDUNG (BAUM-KEY BAUM) (BAUM-TEXT BAUM) L_TEILBAUM L - R - T E I L ) ) ) (KNOTENBILDUNG (BAUM-KEY R _ T E I L B A U M ) (BAUM-TEXT R . T E I L B A U M ) L-TEIL&L-R-TEIL R-R-TEIL))) ;; Fal1 4 ( B i l d 6 . 3 - 1 ) ( ( A N D ( < L-HOEHE R-HOEHE) ( = (BALANCE R _ T E I L B A U M ) - 1 ) ) ( L E T * ((NEUE-WURZEL (LINKER-TEILBAUM R_TEILBAUM)) (R-L-R-TEIL (RECHTER-TEILBAUM NEUE-WURZEL)) ( R - R - T E I L (RECHTER-TEILBAUM R_TEILBAUM)) (L-L-R-TEIL ( L I N K E R - T E I L B A U M NEUE-WÜRZEL)) (R-L-R-TEIL&R-R-TEIL (KNOTENBILDUNG (BAUM-KEY R _ T E I L B A U M ) (BAUM-TEXT R _ T E I L B A U M ) R-L-R-TEIL R-R-TEIL)) (L-TEIL&L-L-R-TEIL (KNOTENBILDUNG (BAUM-KEY BAUM) (BAUM-TEXT BAUM) L_TEILBAUM L - L - R - T E I L ) ) )

II. Konstruktionen (Analyse und Synthese) (KNOTENBILDUNG (BAUM-KEY N E U E - W U R Z E L ) (BAUM-TEXT N E U E - W U R Z E L ) L-TEIL&L-L-R-TEIL R-L-R-TEIL&R-R-TEIL) ) ) ) ) ) ) (EINFUEGEN-IN-AVL-BAUM (LAMBDA (KEY TEXT BAUM) (COND ((LEERER-BAUM? BAUM) (MAKE-BAUM 1 KEY TEXT * L E E R E R - B A U M * * L E E R E R - B A U M * ) ) ((STRING-CI=? KEY (BAUM-KEY BAUM)) (MAKE-BAUM (BAUM-HOEHE BAUM) (BAUM-KEY BAUM) TEXT ( L I N K E R - T E I L B A U M BAUM) ( R E C H T E R - T E I L B A U M BAUM))) ( ( S T R I N G - C K ? KEY (BAUM-KEY BAUM)) (AVL-BAUM-MONTAGE BAUM (EINFUEGEN-IN-AVL-BAUM KEY TEXT ( L I N K E R - T E I L B A U M BAUM)) ( R E C H T E R - T E I L B A U M BAUM))) ( ( S T R I N G - C K ? (BAUM-KEY BAUM) KEY) (AVL-BAUM-MONTAGE BAUM ( L I N K E R - T E I L B A U M BAUM) (EINFUEGEN-IN-AVL-BAUM KEY TEXT (RECHTER-TEILBAUM BAUM))))))) (AVL-BAUM-STRUKTUR-ZEIGEN (LAMBDA (BAUM A N Z A H L _ S P A C E ) (LETREC ((WRITE-SPACE (LAMBDA (N) (COND ((= N 0) NIL) (T (WRITE-CHAR " ") ( W R I T E - S P A C E ( - 1 + N)))))) (ZEIGEN (LAMBDA (BAUM E I N G E R U E C K T ) (COND ( ( L E E R E R - B A U M ? BAUM) *THE-NON-PRINTING-OBJECT*) (T (ZEIGEN ( R E C H T E R - T E I L B A U M BAUM) (+ EINGERUECKT A N Z A H L . S P A C E ) ) ( W R I T E - S P A C E EINGERUECKT) (WRITELN (BAUM-KEY BAUM) " /" (BAUM-HOEHE BAUM) "/ ") (ZEIGEN ( L I N K E R - T E I L B A U M BAUM) (+ EINGERUECKT A N Z A H L _ S P A C E ) ) ) ) ) ) ) (ZEIGEN BAUM A N Z A H L _ S P A C E ) ) ) ) )

183

6. Abbildungsoption: Vektor ;;;;

Auswahl des B e n t z e r k o m m a n d o s

(dispatch

function)

(COND ((EQ? OPERATION 'START) (SET! *DATEN* (WITH -1NPUT-FROM-FILE (CAR PARAMETER) (LAMBDA ( ) (READ)))) T) ((EQ? OPERATION 'ENDE) (WITH-OUTPUT-TO-FILE (CAR PARAMETER) (LAMBDA ( ) (WRITE * D A T E N * ) ) ) T) ((AVL-BAUM? *DATEN*) (COND ((EQ? OPERATION 'EINGABE) (SET! *DATEN* (EINFLIEGEN - IN-AVL-BAUM (CAR PARAMETER) (CADR PARAMETER) *DATEN*)) T) ((EQ? OPERATION 'GET-TEXT) (BAUM-TEXT (GET-KEY-AVL-BAUM (CAR PARAMETER) * D A T E N * ) ) ) ((EQ? OPERATION ' G E T - M I N - K E Y ) (BAUM-KEY (GET-MINIMUM-KEY-AVL-BAUM * D A T E N * ) ) ) ((EQ? OPERATION 'GET-MAX-KEY) (BAUM-KEY (GET-MAXIMUM-KEY-AVL-BAUM * D A T E N * ) ) ) ((EQ? OPERATION 'GET-NEXT-KEY) ( I F (STRING-CI=? (CAR PARAMETER) (BAUM-KEY (GET-MAXIMUM-KEY-AVL-BAUM *DATEN*))) (BEGIN (WRITELN " H i n w e i s : E i n g a b e war g r o e s s t e r Key! " ) (CAR PARAMETER)) (BAUM-KEY (GET-NEXT-KEY-AVL-BAUM (CAR PARAMETER) * D A T E N * ) ) ) ) ((EQ? OPERATION 'STRUKTUR-ZEIGEN) (AVL-BAUM-STRUKTUR-ZEIGEN *DATEN* 2 ) ) (T (ERROR " O p e r a t i o n n i c h t i m p l e m e n t i e r t : " OPERATION)))) ((AND (NULL? *DATEN*) (EQ? OPERATION ' E I N G A B E ) ) (SET! *DATEN* (EINFUEGEN-IN-AVL-BAUM (CAR PARAMETER) (CADR PARAMETER) *LEERER-BAUM*)) T) (T (ERROR " K e i n e w o h l s t r u k t u r i e r t e n D a t e n : " *DATEN*)))))) Programm 6 . 3 - 1 Aktenverwaltung

mittels

AVL-Baum

(Basis:

Vektor)

184

II. Konstruktionen (Analyse und Synthese)

6.4 Zusammenfassung: Vektor Ein Vektor ist eine Struktur mit konstanter Länge. Seine Elemente können beliebige symbolische Ausdrücke sein, also auch wieder Vektoren. Ein Vektor hat sich selbst als Wert (EVAL-Regel 1, vgl. Abschnitt 1.2). Die Zugriffzeit ist unabhängig davon, ob auf ein Element mit kleinem oder großem Index zugegriffen wird. Für einen dünn besetzten Vektor ist die A-Liste eine zweckmäßige Alternative (vgl. Abschnitt 5.2). Charakteristisches

Beispiel für Abschnitt 6:

; ; ; ; V e r w a l t u n g von A d r e s s e n e v a l > ( D E F I NE A D R E S S E N - S T R U K T U R # ( " A n r e d e & T i t e l " " V o r n a m e & Name" " S t r a s s e & Nummer" "Postfach" "Landeskenner & Postleitzahl & Ortsname")) ==> ADRESSEN-STRUKTUR e v a l > ( D E F I NE P R I V A T - A D R E S S E ( L A M B D A ( A N R E D E NAME S T R A S S E O R T ) (LET ((ADRESSE (MAKE-VECTOR (VECTOR-LENGTH ADRESSEN-STRUKTUR) ()))) (VECTOR-SET! ADRESSE 0 ANREDE) ( V E C T O R - S E T ! A D R E S S E 1 NAME) (VECTOR-SET! ADRESSE 2 STRASSE) ( V E C T O R - S E T ! A D R E S S E 4 ORT) ADRESSE))) ==> PRIVAT-ADRESSE eval> eval>

eval>

( D E F I NE K R A U S E ( P R I V A T - A D R E S S E " H e r r " "Hans Krause" "Entenweg

7"

"D-1000

Berlin")) = = > KRAUSE

(DEFINE DRUCKE-ADRESSE (LAMBDA ( A D R E S S E ) (LET ((V-LAENGE (VECTOR-LENGTH A D R E S S E ) ) ) (DO ( ( I 0 ( 1 + I ) ) ) ( ( = I V-LAENGE) *THE-NON-PRINTING-OBJECT*) ( I F (VECTOR-REF ADRESSE I ) (WRITELN (VECTOR-REF ADRESSE I))))))) ==> DRUCKE-ADRESSE (DRUCKE-ADRESSE Herr Hans K r a u s e Entenweg 7 D-1000 B e r l i n

KRAUSE)

==>

7. Abbildungsoption: Zeichenkette und Symbol Eine Zeichenkette (engl.: string) ist eine Sequenz aus einzelnen Zeichen (Elementen). Im Unterschied zur Liste oder zum Vektor können die Elemente dieser

7. Abbildungsoption: Zeichenkette und Symbol

185

Sequenz jedoch nicht wieder Zeichenketten sein. Eine Zeichenkette hat sich selbst als Wert (EVAL-Regel 1, vgl. Abschnitt 1.2). Bisher haben wir daher eine Zeichenkette als Konstante benutzt. In diesem Abschnitt konstruieren, selektieren und manipulieren wir solche „Konstanten". Die Zeichenkette ist damit eine eigenständige Abbildungsoption wie die Liste oder der Vektor. Als Beispiel dient die Aufgabe zwei Muster miteinander zu vergleichen (engl.: pattern matching). Ein entsprechendes Konstrukt realisieren wir zunächst mit der Abbildungsoption Liste (vgl. Abschnitt 7.1). Dieses SIMPLE-MATCH-Konstrukt arbeitet „naturgemäß" mit CAR- und CDR-Selektoren. Um Zeichenketten vergleichen zu können, implementieren wir entsprechende CAR-STRING- und CDR-STRING-Konstrukte mit Hilfe der eingebauten String-Konstrukten (vgl. Abschnitt 7.2). LISP-Systeme verfügen über ein große Zahl spezieller String-Konstrukte. Wir wollen hier primär den Aspekt Abbildungsoption vertiefen und erwähnen daher nur einige Konstrukte aus dem String-Konstrukte-Repertoire von PC Scheme. Im Rahmen des Vergleichs zweier Muster führen wir Variable (engl.: match variables) ein. Das so erweiterte Konstrukt MUSTERVERGLEICH nutzt die Repräsentation des Symbols, d.h. das Ergebnis der PRINT-Phase (kurz: PRINTName) als Informationsträger. Bisher haben wir ein Symbol mit einem Wert oder einer Eigenschaft (P-Liste) verknüpft. Der im READ-EVAL-PRINT-Zyklus (vgl. Abschnitt 1.2) zurückgegebene PRINT-Name diente zur Identifizierung. Er wurde als eine Konstante (Literalatom) betrachtet. Hier wird dieser PRINT-Namen selbst selektiert und neu konstruiert (vgl. Abschnitt 7.3). Daß leistungsfähige MATCH-Konstrukte einen eigenständigen „Denkrahmen" (vgl. Abschnitt 4) bilden, skizzieren wir mit einem kleinen Vorübersetzer („Precompiler" oder „Präprozessor"). Er setzt Pseudocode-Formulierungen in LISP-Code um. Er transformiert z.B. eine „WHILE ... DO ... OD"-Iteration (vgl. Abschnitt 2.2.3) in ein rekursives LISP-Konstrukt. Dazu ist ein neues Symbol zu generieren, das keine Namensgleichheit mit anderen Symbolen hat. Es darf nicht mit schon existierenden Symbolen bzw. mit Symbolen, die als spätere Eingabe vorkommen, verwechselbar sein. Ein solches, einmaliges Symbol generiert das eingebaute Konstrukt GENSYM (vgl. Abschnitt 7.4).

7.1 Mustervergleich Programme, die Muster miteinander vergleichen, sind ein klassisches Anwendungsgebiet für LISP. Die LISP-Literatur befaßt sich eingehend mit dem Thema „Pattern Matching" (vgl. z.B. Müller, 1985, S. 151 ff; Stoyan/Görz, 1984, S. 235 ff oder Winston/Horn, 1984, S. 253 ff). Dabei ist anzumerken, daß der Terminus „Mustervergleich" eine unzureichende Übersetung darstellt. Er vermittelt spontan den Eindruck, es wird nur verglichen im Sinne einer Klassifikation.

186

II. Konstruktionen (Analyse und Synthese)

Vielmehr zielt „pattern matching" jedoch auf ein Paradigma, auf einen eigenständigen „Denkrahmen" für die Problemanalyse und Lösungsfindung. Ein Muster beschreibt den Typ einer „Einheit". Beim Vergleich wird entschieden, ob ein symbolischer Ausdruck „paßt", d.h. ob er dieser Typbeschreibung entspricht. Ein Muster selbst besteht aus einer linearen Folge von Elementen. Das Muster wird von links nach rechts mit dem zu prüfenden symbolischen Ausdruck verglichen. Wir nehmen zunächst an, daß das Muster und der zu prüfende symbolische Ausdruck Listen sind. Die Listenelemente unseres Musters können sein: o ? (ein Fragezeichen), o * (ein Stern) oder o ein zu erfüllendes Kennwort (ein sonstiges Symbol). Ein Fragezeichen im Muster steht für ein beliebiges Element im Prüfling. Anders formuliert: Das Fragezeichen deckt ein Element. Der Stern deckt eine Folge von beliebigen Elementen (incl. einer leeren Folge). Er deckt ein ganzes Segment. Jedes andere Symbol im Muster deckt nur das gleiche Symbol im Prüfling. Ein solch einfacher Mustervergleich kann z.B. folgende Entscheidungen treffen: eval>

eval>

(SIMPLE-MATCH ' ( E I N E ? ANALYSE SICHERT * ) ' ( E I N E ZWECKMAESSIGE ANALYSE SICHERT DEN AUTOMATIONSERFOLG) ) ==> #T (SIMPLE-MATCH ' ( E I N E * ANALYSE SICHERT ? ) ' ( E I N E ZWECKMAESSIGE ANALYSE SICHERT DEN AUTOMATIONSERFOLG) ) ==> ()

¡Muster ¡Prüfling ¡Ergebnis ¡Muster ¡Prüfling ;Ergebni s

Für den Vergleich von Listen definieren wir das SIMPLE-MATCH-Konstrukt als eine rekursive Funktion, wie folgt:

7. Abbildungsoption: Zeichenkette und Symbol eval>

( D E F I N E S I M P L E - M A T C H (LAMBDA (MUSTER L I S T E ) (COND ( ( A N D ( N U L L ? MUSTER) ( N U L L ? L I S T E ) ) T) ((AND (NULL? L I S T E ) ( N U L L ? (CDR M U S T E R ) ) ( E Q ? ' * (CAR M U S T E R ) ) ) T) ( ( O R ( N U L L ? MUSTER) ( N U L L ? L I S T E ) ) N I L ) (COR ( E Q ? (CAR MUSTER) (CAR L I S T E ) ) ( E Q ? ' ? (CAR M U S T E R ) ) ) ( S I M P L E - M A T C H (CDR MUSTER) (CDR L I S T E ) ) ) ;; E r l ä u t e r u n g s i e h e Text ( ( E Q ? ' * (CAR M U S T E R ) ) (COND ( ( S I M P L E - M A T C H (CDR MUSTER) (CDR L I S T E ) ) T) ((SIMPLE-MATCH MUSTER (CDR L I S T E ) ) T ) ((SIMPLE-MATCH (CDR MUSTER) L I S T E ) T ) (T N I L ) ) ) (T N I L ) ) ) ) = = > S I M P L E - M A T C H

187

;*-Fall

A

;*-Fall

B

; * - Fa 11 C ; * - Fa 11 D

Die erste Klausel des ersten obigen COND-Konstruktes prüft, ob das Muster (hier LAMBDA-Variabale MUSTER) und der Prüfling (hier LAMBDA-Variable LISTE) zum gleichen Zeitpunkt abgearbeitet sind; also faktisch gleich lang sind. Ist die Liste abgearbeitet und das letzte Element von Muster ein Stern, dann paßt das Muster, da wir unterstellen, daß der Stern auch ein leeres Segment deckt. Ist die Liste kürzer, dann kann das Muster nicht passen (3. Klausel). Ist das erste Element im Muster gleich dem ersten Element im Prüfling, dann entscheidet der Mustervergleich der Restlisten, ob das Muster paßt oder nicht (4. Klausel). Ist das erste Element im Muster das Fragezeichen, dann paßt es auf jedes erste Element im Prüfling. Auch dann entscheidet der Mustervergleich der Restlisten (daher auch 4. Klausel). Ist das erste Element des Musters ein Stern, dann sind folgende Fälle zu unterscheiden (5. Klausel): o Der Stern steht für ein Element im Prüfling (*-Fall A). Der Mustervergleich ist mit den Restlisten fortzusetzen. Ist der Vergleich der Restlisten erfolgreich, dann paßt das Muster. o Der Stern steht für mehrere Elemente im Prüfling (*-Fall B). Wir behalten das aktuelle Muster bei, d.h. verkürzen es nicht und vergleichen es mit dem Rest des Prüflings. Dadurch ist es beim erneuten Vergleich (CAR MUSTER) wieder der Stern, der dann mit dem nächsten Element des Prüflings verglichen wird. o Der Stern steht für kein Element im Prüfling (*-Fall C). Wir verkürzen das Muster, so daß wir den Stern „aufgeben", und vergleichen das verkürzte Muster mit dem aktuellen Prüfling.

II. Konstruktionen (Analyse und Synthese)

188

o Die rekursiven SIMPLE-MATCH-Anwendungen stehen im COND-Konstrukt als Prädikate. Führt keines zu einem Wert ungleich NIL, dann paßt das Muster nicht. Zur leichteren Erkennbarkeit ist eine entsprechende T-Klausel formuliert (*-Fall D).

7.2 STRING-Konstrukte Beispiel: Einfacher Mustervergleich

für

Zeichenketten

Im bisherigen SIMPLE-MATCH-Konstrukt (vgl. Abschnitt 7.1) sind das Muster und der Prüfling Listen. Wir entwickeln daraus ein SIMPLE-MATCH-Konstrukt, das mit Zeichenketten arbeitet. Statt Symbole in einer Liste zu prüfen, sind Teile von Zeichenketten zu prüfen. Das obige Beispiel ist für dieses stringbasierte SIMPLE-MATCH-Konstrukt, wie folgt, zu notieren: eval> (SIMPLE-MATCH "Eine ? Analyse s i c h e r t *" "Eine zweckmaessige Analyse s i c h e r t den Automationserfolg")) ==> #T An die Stelle des Prädikates NULL? für die Liste tritt das in Scheme eingebaute Prädikat STRING-NULL?. Das Prädikat EQ? wird durch das eingebaute Prädikat STRING=? ersetzt. Der Wert des STRING-NULL?-Konstruktes ist nur dann ungleich NIL, also „wahr", wenn die Länge der Zeichenkette gleich Null ist. Die Länge einer Zeichenkette bestimmt das Konstrukt STRING-LENGTH. Das STRING=?-Konstrukt vergleicht seine beiden Argumente Zeichen für Zeichen. Es hat einen Wert ungleich NIL, wenn für jedes Zeichen Gleichheit gilt und die beiden Zeichenketten gleich lang sind. Die folgenden Beispiele zeigen die beiden Prädikate für Zeichenketten. eval> eval> eval> eval> eval> eval>

(STRING-NULL? "") ==> #T (DEFINE F00 " ") ==> F00 (STRING-LENGTH F00) ==> 1 (STRING-NULL? F00) ==> () (STRING=? "more" "more") ==> #T (STRING=? "MoRe " "MoRe") ==> () ¡Länge ungleich

Zum Ersatz der Selektoren CAR und CDR sind entsprechende Selektoren für eine Zeichenkette selbst zu definieren. Wir nennen sie CAR-STRING und CDR-STRING. Dazu betrachten wir das Zeichen Zwischenraum, allgemein auch Space oder Blank genannt, als Trennzeichen für die Zeichenteilketten. Der Zwischenraum als einzelnes Zeichen (engl.: character) hat in Scheme die Repräsentation #\SPACE. Ob eine Zeichenkette vorliegt, stellt das Prädikat STRING? fest. Ob ein einzelnes Zeichen vorliegt, stellt das Prädikat CHAR? fest. Ein Zeichen einer Zeichenkette selektiert das STRING-REF-Konstrukt. Es ist, wie folgt, definiert:

7. Abbildungsoption: Zeichenkette und Symbol eval>

(STRING-REF

)

189 — >

mit:

::= E i n e

Zeichenkette.

::= E i n e g a n z z a h l i g e , n i c h t n e g a t i v e A n g a b e d e r P o s i t i o n d e s zu s e l e k t i e r e n d e n Z e i c h e n s . Die Z ä h l u n g d e r P o s i t i o n b e g i n n t bei 0. B e d i n g u n g ist: ( A N D ( ) (< (STRING-LENGTH )))

::= Das s e l e k t i e r t e Z e i c h e n d e r Z e i c h e n k e t t e . A c h t u n g ! Es i s t v o m T y p Z e i c h e n ( e n g l . : c h a r a c t e r ) nicht vom Typ Z e i c h e n k e t t e (engl.: string). Vgl. dazu die folgenden Beispiele.

eval>

(DEFINE

eval>

(STRING-LENGTH

F00

"Requirements FOO) = = >

Engineering")

==>

F00

24

eval>

(STRING-REF

F00 3) = = >

eval>

(STRING-REF

F00 2 4 ) = = >

#\u ERROR

eval>

(STRING-REF

FOO 2 3 ) = = >

#\g

eval>

(STRING-REF

FOO

#\SPACE

eval>

(STRING?

FOO) = = >

eval>

(STRING?

(STRING-REF

eval>

(CHAR?

(STRING-REF

eval>

(CHAR?

FOO) = = >

12) = = >

...

;Index

zu

groß

#T FOO

FOO

12)) ==>

12)) ==>

()

#T

()

Der Wert des STRING-REF-Konstruktes ist vom Typ Zeichen, d.h. das Prädikat CHAR? ist erfüllt, und nicht vom Typ Zeichenkette, d.h. das Prädikat STRING? wird nicht erfüllt. Zum Prüfen eines mit dem STRING-REF-Konstrukt selektiertem Zeichen auf #\SPACE, können wir daher nicht das Prädikat STRING=? nutzen. Es ist mit dem Prädikat CHAR=? zu prüfen. Wir definieren daher ein Konstrukt SPACE?, das prüft, ob an einer bestimmten Stelle ein Zwischenraum in der Zeichenkette gegeben ist, wie folgt: eval>

(DEFINE SPACE? (LAMBDA (STRING (CHAR=? (STRING-REF STRING

POS) POS) # \ S P A C E ) ) )

==>

SPACE?

Analog zu einer Liste, bei der zur Trennung der Elemente ein Zwischenraum ausreicht, jedoch beliebig viele Zwischenräume stehen können, fassen wir für das Selektieren einer Zeichenteilkette ebenfalls beliebig viele Zwischenräume als ein Trennzeichen auf. Für die zu definierenden Konstrukte CAR-STRING und CDR-STRING unterstellen wir folgende Ergebnisse: eval>

(CAR-STRING " ==> "more"

m o r e L I S P ") ¡Keine f ü h r e n d e n und ; Zwischenräume.

nachfolgenden

190

II. Konstruktionen (Analyse und Synthese)

eval > ( C D R - S T R I N G " = = > " LISP "

m o r e L I S P ") ¡Führende und n a c h f o l g e n d e ; bleiben erhalten.

Zwischenräume

Die Annahme, daß mehrere Zwischenräume als ein Trennzeichen gewertet werden, erleichtert das Formulieren des Musters. Ein Nachteil ist jedoch, daß wir die Zusicherung aufgeben, aus den selektierten Teile wieder das Ganze in ursprünglicher Form erstellen zu können (vgl. Abschnitt 4.2). Das STRINGAPPEND-Konstrukt verbindet zwei Zeichenketten zu einer. Wenden wir dieses Konstrukt auf die selektierten Zeichenteilketten an, dann fehlen dem Ergebnis die Zwischenräume, die zu Beginn der Zeichenkette standen. eval>

(STRING-APPEND (CAR-STRING (CDR-STRING

" "

more more

LISP LISP

") ")) = = >

"more

LISP "

Unsere Selektoren CAR-STRING und CDR-STRING nutzen den in PC Scheme eingebauten Selektor SUBSTRING. Das SUBSTRING-Konstrukt ist, wie folgt, definiert: eval>

(SUBSTRING



) ==>

mit:





::= E i n e

Zeichenkette.

::= E i n e g a n z z a h l i g e , n i c h t n e g a t i v e A n g a b e d e r P o s i t i o n d e s e r s t e n Z e i c h e n s d e r zu s e l e k t i e r e n d e n Zeichentei1 kette. Die Zählung der P o s i t i o n b e g i n n t bei 0. B e d i n g u n g i s t : ( A N D ( ) ( ( S T R I N G - L E N G T H < s t r i n g > ) ) ) ::= E i n e g a n z z a h l i g e , n i c h t n e g a t i v e A n g a b e d e r Position des ersten Z e i c h e n s , das nicht m e h r zur Zeichentei1 kette gehören soll. Die Zählung d e r P o s i t i o n b e g i n n t bei 0. B e d i n g u n g i s t : (AND ( ) ( ) . V g l . d a z u d i e f o l g e n den B e i s p i e l e .

eval>

(DEFINE

eval>

(SUBSTRING

F00

F00 0 12) = = >

"Requirements

"Requirements"

Engineering")

eval>

(SUBSTRING

F00 0 24) = = >

"Requirements

==>

F00

Engineering"

191

7. Abbildungsoption: Zeichenkette und Symbol

eval>

( S U B S T R I N G F00 24 2 4 ) = = >

eval>

(STRING-NULL?

eval>

(SUBSTRING

F00 13 12) = = > ERROR

eval>

(SUBSTRING

F00 0 2 7 ) = = > ERROR

(SUBSTRING

"" F00 13 1 3 ) ) ... ...

= = > #T ¡Ende v o r

Start

¡Endeangabe

zu

groß

Das CAR-STRING-Konstrukt definieren wir als eine LISP-Funktion mit dem eigentlichen Selektionskonstrukt VON-BIS-ANALYSE und den Hilfsgrößen wie z.B. SPACE? als lokale Funktionen. Die rekursive VON-BIS-ANALYSEFunktion ermittelt für die Anwendung des SUBSTRING-Konstruktes die - und -Werte. Sie arbeitet mit zwei Zeigern. Der erste Zeiger ist der Wert ihrer LAMBDA-Variablen CAR-START. Dieser Zeiger wird auf das erste Zeichen, das ungleich #\SPACE ist, gesetzt. Der zweite Zeiger ist der Wert ihrer LAMBDA-Variablen AKTUELLE-POSITION. Dieser wird so lange verschoben, bis er auf dem ersten Zwischenraum nach einem Zeichen ungleich #\SPACE steht oder das Ende der Zeichenkette erreicht wurde. Zum Überspringen von führenden Zwischenräumen verwenden wir die lokale Variable VORSPANN-SPACE? im Sinne eines Schalters. Zunächst ist ihr Wert T. Wird das erste Zeichen ungleich #\SPACE erkannt, erhält sie den Wert NIL. Ist ihr Wert NIL und wird ein Zeichen gleich #\SPACE erkannt, dann ist das Ende der Zeichenteilkette erreicht. Zu beachten ist, daß das SUBSTRING-Konstrukt als -Wert die Position nach unserer CAR-STRING-Zeichenteilkette benötigt. Wir definieren somit folgendes CAR-STRING-Konstrukt: eval>

( D E F I N E C A R - S T R I N G (LAMBDA ( S T R I N G ) (LETREC ( ( E N D E - P O S I T I O N ( - 1 + (STRING-LENGTH S T R I N G ) ) ) ( V O R S P A N N - S P A C E ? T) ( S P A C E ? (LAMBDA ( P O S ) (CHAR=? ( S T R I N G - R E F S T R I N G POS) # \ S P A C E ) ) ) ( V O N - B I S - A N A L Y S E (LAMBDA ( C A R - S T A R T A K T U E L L E - P O S I T I O N ) (COND ( ( < = A K T U E L L E - P O S I T I O N E N D E - P O S I T I O N ) (COND ( ( A N D V O R S P A N N - S P A C E ? (SPACE? AKTUELLE-POSITION)) (VON-BIS-ANALYSE (1+ CAR-START) (1+ AKTUELLE-POSITION))) ((SPACE? AKTUELLE-POSITION) (SUBSTRING STRING CAR-START AKTUELLE-POSITION)) (T ( S E T ! V O R S P A N N - S P A C E ? N I L ) (VON-BIS-ANALYSE CAR-START (1+ AKTUELLE-POSITION))))) ( ( = AKTUELLE-POSITION (1+ ENDE-POSITION)) (SUBSTRING STRING CAR-START AKTUELLE-POSITION)) (T (ERROR " K e i n C A R - S T R I N G b e s t i m m t : " STRING)))))) (VON-BIS-ANALYSE 0 0 ) ) ) ) ==> CAR-STRING

192

II. Konstruktionen (Analyse und Synthese)

Das CDR-STRING-Konstrukt ist analog zum CAR-STRING-Konstrukt aufgebaut. Die eigentliche Berechnung der Positionen für das SUBSTRING-Konstrukt vollzieht die lokale Funktion VON-ANALYSE. Hier ist nur die Anfangsposition der zu selektierenden Zeichenteilkette durch den Zeiger AKTUELLEPOSITION zu ermitteln. Die Endeposition ist identisch mit der gesamten Zeichenkette; sie ist mit dem STRING-LENGTH-Konstrukt bestimmbar. Wenn eine Zeichenkette leer ist oder nur eine Zeichenteilkette für das CAR-STRING-Konstrukt enthält, ist der Wert des CDR-STRING-Konstruktes die leere Zeichenkette. Im Sinne unseres Verbundes aus Konstruktor, Selektor, Prädikat und Mutator erstellen wir die leere Zeichenkette mit dem Konstruktor MAKE-STRING. Das MAKE-STRING-Konstrukt ist, wie folgt, definiert: eval>

(MAKE-STRING





{})

==>

: := E i n e g a n z z a h l i g e , n i c h t n e g a t i v e A n g a b e d e r L ä n g e d e r Z e i c h e n k e t t e . In PC S c h e m e b e s t e h t die R e s t r i k t i o n : (AND ( ) ( 1 6 3 8 0 ) ) ::= Ein e i n z e l n e s Z e i c h e n als F ü l l z e i c h e n f ü r d i e Z e i c h e n k e t t e . Ist k e i n F ü l l z e i c h e n a n g e g e b e n v e r w e n d e t PC S c h e m e # \ S P A C E . ::= E i n e

eval>

(MAKE-STRING

eval>

(STRING-NULL?

eval>

(MAKE-STRING

eval>

(DEFINE

eval>

(MAKE-STRING

Zeichenkette

5 #\g) ==>

(* 2 3) # \ a ) #\|)

==>

4 STRICH)

angegebenen

"ggggg"

(MAKE-STRING

STRICH

mit der

0)) ==> ==>

#T

"aaaaaa"

STRICH ==>"||||"

Wir definieren damit das CDR-STRING-Konstrukt, wie folgt: eval>

(DEFINE CDR-STRING (LAMBDA (STRING) (LETREC ((ENDE-POSITION (-1+ (STRING-LENGTH STRING))) ( V O R S P A N N - S P A C E ? T) (SPACE? (LAMBDA (POS) (CHAR=? ( S T R I N G - R E F S T R I N G POS) # \ S P A C E ) ) )

Länge.

7. Abbildungsoption: Zeichenkette und Symbol

193

(VON-ANALYSE (LAMBDA ( A K T U E L L E - P O S IT ION) (COND ( ( < = A K T U E L L E - P O S I T I O N E N D E - P O S I T I O N ) (COND ((AND V O R S P A N N - S P A C E ? (SPACE? AKTUELLE-POSITION)) (VON-ANALYSE (1+ AKTUELLE-POSITION))) ((SPACE? AKTUELLE-POSITION) (SUBSTRING STRING AKTUELLE-POSITION (1+ ENDE-POSITION))) (T ( S E T ! VORSPANN-SPACE? N I L ) (VON-ANALYSE (1+ AKTUELLE-POSITION))))) ( ( = AKTUELLE-POSITION (1+ ENDE-POSITION)) (MAKE-STRING 0 ) ) (T (ERROR " K e i n C D R - S T R I N G b e s t i m m t : " STRING)))))) (VON-ANALYSE 0 ) ) ) ) = = > C D R - S T R I N G

Mit den erstellten Selektoren CAR-STRING und CDR-STRING können wir den obigen Mustervergleich für Zeichenketten formulieren. Das SIMPLE-MATCHKonstrukt hat dann folgende Definition: eval>

( D E F I N E S I M P L E - M A T C H (LAMBDA (MUSTER STRING) (COND ( ( A N D ( S T R I N G - N U L L ? MUSTER) ( S T R I N G - N U L L ? S T R I N G ) ) T) ((AND

(STRING-NULL? (STRING-NULL? (STRING=? " * "

((OR

(STRING-NULL? (STRING-NULL?

((OR

(STRING=?

STRING) (CDR-STRING MUSTER)) (CAR-STRING MUSTER))) MUSTER) STRING))

T)

NIL)

(CAR-STRING

MUSTER) (CAR-STRING (STRING=? " ? " (CAR-STRING MUSTER))) ( S I M P L E - M A T C H ( C D R - S T R I N G MUSTER) (CDR-STRING STRING)))

STRING))

( ( S T R I N G = ? " * " (CAR-STRING MUSTER)) (COND ( ( S I M P L E - M A T C H ( C D R - S T R I N G MUSTER) (CDR-STRING STRING)) ( ( S I M P L E - M A T C H MUSTER (CDR-STRING STRING)) ( ( S I M P L E - M A T C H ( C D R - S T R I N G MUSTER) S T R I N G ) T) (T N I L ) ) ) (T N I L ) ) ) ) = = > S I M P L E - M A T C H eval>

eval>

(SIMPLE-MATCH "Eine ? Analyse sichert *" "Eine Analyse sichert E r f o l g " ) ==> () ¡ K e i n Element f ü r das ? . (SIMPLE-MATCH " * haben * W e r t " " V i e l e S y m b o l e haben e i n e n k o m p l e x e n W e r t " )

= = > #T

T) T)

194

II. Konstruktionen (Analyse und Synthese)

eval >

eval>

(SIMPLE-MATCH "? P h a s e n p l a n b e s t i m m t * V o r g e h e n " "Der l i n e a r e P h a s e n p l a n b e s t i m m t das V o r g e h e n " ) = = > () ;Mehr als ein E l e m e n t für das ?. (SIMPLE-MATCH "* P h a s e n p l a n b e s t i m m t * V o r g e h e n " "Der l i n e a r e P h a s e n p l a n b e s t i m m t das V o r g e h e n " ) = = >

#T

7.3 Symbol und PRINT-Name Ein Symbol (Literalatom) ist eine „Einheit" mit einer eigenen Identität (vgl. Abschnitt 1.4.2). Seine Elementarteilchen sind abhängig vom jeweiligen LISPSystem. So haben Common LISP-Systeme im Gegensatz zu Scheme-Systemen das Elementarteilchen FUNCTION-cell (vgl. Bild 7.3-1). Im Mittelpunkt dieses Abschnittes steht das Elementarteilchen PRINT-Name.

pSYMBOL PRINT-name V A L U E - eel 1 FUNCTION-cel1 P- LI ST PACKAGE-cel1 Legende: D a r g e s t e l l t s i n d d i e E l e m e n t a r t e i l c h e n bei e i n e m C o m m o n L I S P - S y s t e m . Das S c h e m e - K o n z e p t v e r z i c h t e t b e w u ß t auf d i e F U N C T I O N - c e l l und g e w i n n t d a d u r c h an S t r i n g e n z . PRINT-name VALUE-cel 1 FUNCTION-cell P-LIST PACKAGE-cel1

3ild 7 . 3 - 1

I d e n t i f i z i e r u n g s - E l e m e n t des S y m b o l s S p e i c h e r für (den Z e i g e r auf) den Symbol wert S p e i c h e r für (den Z e i g e r a u f ) den F u n k tionswert eines Symbols S p e i c h e r für (den Z e i g e r a u f ) d i e E i g e n s c h a f t s l i s t e ( P r o p e r t y LIST, vgl. Abschnitt 5.3) S p e i c h e r für (den Z e i g e r auf) d i e Z u o r d n u n g zu e i n e r e i g e n e n S y m b o l s a m m l u n g (z.B. S y s t e m , B e n u t z e r , E d i t o r , e t c . )

Elementarteilchen

eines

Symbols

(Literalatoms)

7. Abbildungsoption: Zeichenkette und Symbol

195

Wird ein Symbol eingelesen, dann konvertiert ein LISP-System in der READPhase des READ-EVAL-PRINT-Zyklus (vgl. Abschnitt 1.2) alle kleinen Buchstaben in große Buchstaben. So wird z.B. aus FoO oder fOo jeweils FOO. Dies ist ein Kennzeichen für das Alter von LISP. Als LISP Ende der 50er Jahre konzipiert wurde, konnten die Terminals (z.B. einfache Kartenleser und Drucker) nur mit Großbuchstaben umgehen. Als Terminals mit Kleinbuchstaben auf den Markt kamen, wurden Betriebssysteme und Programmiersprachen zunächst nur leicht modifiziert. Sie setzten die Kleinbuchstaben in Großbuchstaben um und konnten damit die Verarbeitung wie bisher durchführen. Heute ermöglichen viele LISP-Systeme das Ausschalten dieser Konvertierung. Als ein Beispiel von vielen sei Allegro Common LISP genannt (vgl. Anhang B). Die externe Repräsentation eines Symbols ergibt sich aus der Zeichenfolge im Slot PRINT-name. Dort wollen wir möglichst alle beliebigen Zeichen ablegen können z.B. auch Sonderzeichen wie Leerzeichen, öffendene oder schließende Klammern. Dazu müssen wir verhindern, daß solche Sonderzeichen in der READ-Phase entsprechend ihrer üblichen Aufgabe interpretiert werden. Damit solche Zeichen als Teil des Symbolnamens behandelt werden, sind sie durch ein Fluchtsymbol zu kennzeichnen. Die Zeichen \ (ASCII 124) und \ (ASCII 92) dienen in Scheme als Fluchtsymbole. Das Zeichen ! wird mehrfaches Fluchtsymbol genannt. Das Zeichen \ ist eine einfaches Fluchtsymbol. Beim mehrfachen Fluchtsymbol werden vom ersten Zeichen ! bis zum nächsten Zeichen I alle Zeichen vom READ-Prozeß als Symbolname interpretiert (vgl. Abschnitt 11.1). eval> (OEFINE !(! 5) ==> !(! eval> (OEFINE ¡ s o z i a l e Marktwirtschaft! ' \ ( ) ==>¡soziale Marktwirtschaft, eval> ¡ s o z i a l e Marktwirtschaft! ==> !(! eval> (EVAL i s o z i a l e M a r k t w i r t s c h a f t ! ) ==> 5 Beispiel: Mustervergleich

mit Variablen fiir Listen

Wir betrachten erneut das SIMPLE-MATCH-Konstrukt (vgl. Abschnitt 7.1) für Listen und erweitern dieses um sogenannte Mustervariablen (engl.: match variables). Das erweiterte Konstrukt nennen wir MUSTERVERGLEICH. Wir vereinbaren, daß Symbole mit einem Fragezeichen oder einem Stern zu Beginn ihres PRINT-Namens Mustervariablen sind. Solche Mustervariablen decken Elemente im Prüfling ab. Dabei wirken sie wie die Symbole ? bzw. *. Paßt das Muster, dann sind die abgedeckten Werte durch die Mustervariablen verfügbar. Wir binden unter der Eigenschaft MATCH-VALUE den von der Mustervariablen abgedeckten Wert an ein namensähnliches Symbol, dessen PRINT-Name nicht das Kennzeichen ? bzw. * aufweist. Da der Stern für mehrere Symbole im Prüfling steht, fassen wir unter der Eigenschaft MATCH-VALUE alle abgedeckten Elemente zu einer Liste zusammen. Das folgende Beispiel hat die beiden Mustervariablen ?WER und *WAS.

II. Konstruktionen (Analyse und Synthese)

196 eval> eval> eval>

( M U S T E R V E R G L E I C H ' ( ? W E R BEGRUENDEN * W A S ) ' ( R E G E L N BEGRUENDEN E I N E N S T I L DER P R O G R A M M I E R U N G ) = = > #T ( G E T P R O P 'WER ' M A T C H - V A L U E ) = = > REGELN (GETPROP 'WAS ' M A T C H - V A L U E ) = = > ( E I N E N S T I L DER P R O G R A M M I E R U N G )

Wie das Beispiel verdeutlicht, ist aus dem Namen einer Mustervariablen der Name des zugehörenden Symbols für die Wertebindung zu selektieren. So ist aus der Mustervariablen ?WER der Teil WER und aus der Mustervariablen *WAS der Teil WAS zu ermitteln. Dazu verwenden wir das in PC Scheme eingebaute EXPLODE-Konstrukt. Es hat als Wert eine Liste von Einzeichensymbolen, die den PRINT-Namen seines Arguments repräsentieren. Das EXPLODEKonstrukt ist in PC Scheme auf Symbole, Zeichenketten und ganze Zahlen anwendbar. Das Gegenstück zum EXPLODE-Konstrukt ist das eingebaute IMPLODE-Konstrukt. Es verlangt eine Liste und baut daraus den PRINT-Namen des Symbols. Die folgenden Beispiele zeigen die Umsetzung der PRINT-Repräsentation in die Elemente einer Liste bzw. ihre Zusammenfassung zu einem Symbol. eval > (EXPLODE eval > (EXPLODE ==> (?

' ?WER ) "?Wer" W le!

==>

(?

W E R)

K l e i n e B u c h s t a b e n werden durch e i n e n unterbrochenen senkrechten S t r i c h umgeben. Das F l u c h s y m b o l verhindert ihre Konvertierung in Großbuchstaben .

eval>

(SYMBOL?

(CADDR

eval>

(IMPLODE

(EXPLODE

'?WER))

eval>

(IMPLODE

(EXPLODE

"?Wer"))

eval>

(IMPLODE

(CDR

eval>

(DEFINE

eval>

(SYMBOL?

eval>

(EQ?

eval>

(EXPLODE

-1234)

eval>

(NUMBER?

(IMPLODE

(CDR

(EXPLODE

-1234))))

==>

()

e v a " '>

(SYMBOL?

(IMPLODE

(CDR

(EXPLODE

-1234))))

==>

#T

F00

(EXPLODE

(IMPLODE

F00)

' |Wer!

(EXPLODE

==>

F00)

"?Wer"))) ==> ==>

'?WER)))

(CDR

==>

#T

?WER !?Wer| ==>

(EXPLODE

WER "?Wer"))))

==>

F00

#T ==>

==>

#T (-

¡1]

|2|

13]

¡4])

Das Konstrukt MUSTERVERGLEICH arbeitet sowohl mit Mustervariablen als auch mit den einfachen Deckelementen Fragezeichen und Stern. Es bietet sich daher an, in einem ersten Schritt die Unterschiede in der Notation im Muster in eine einheitliche Notation zu überführen. Dazu definieren wir ein Konstrukt ANALYSE-LITERAL-ATOM. Eine Mustervariable bzw. ein einfaches Deckelement werden in eine zweielementige Liste transformiert. Ihr erstes Element (ein Fragezeichen bzw. ein Stern) gibt den Typ an. Im Fall der Mustervariablen ist

7. Abbildungsoption: Zeichenkette und Symbol

197

das zweite Element das Symbol, dessen Eigenschaft MATCH-VALUE den abgedeckten Wert aufnimmt. Liegt keine Mustervariable vor, sondern nur ein Fragezeichen bzw. ein Stern, dann ist das zweite Element NIL. Eine solche Transformation bietet sich auch als Eingabe an, wenn das verwendete LISP-System keine EXPLODE- und IMPLODE-Konstrukte enthält. eval> (ANALYSE-LITERAL-ATOM ' ( ? PROGRAMM * BEDINGT *X UND *Y)) ==> ((? NIL) PROGRAMM (* NIL) BEDINGT (* X) UND (* Y)) Mit der Annahme, daß das Eingabe-Muster eine Liste ist, deren Elemente alle Symbole sind, können wir das Transformations-Konstrukt, wie folgt, definieren: eval> (DEFINE ANALYSE-LITERAL-ATOM (LAMBDA (LISTE) (COND ((NULL? LISTE) NIL) ((SYMBOL? (CAR LISTE)) (LET* ((ALLE-ZEICHEN (EXPLODE (CAR LISTE))) (MATCH-TYP (CAR ALLE-ZEICHEN)) (MATCH-VARIABLE (COND ((NULL? (CDR ALLE-ZEICHEN)) NIL) (T (IMPLODE (CDR ALLE-ZEICHEN)))))) (COND ((EQ? '? MATCH-TYP) (CONS (LIST '? MATCH-VARIABLE) (ANALYSE-LITERAL-ATOM (CDR LISTE)))) ((EQ? '* MATCH-TYP) (CONS (LIST '* MATCH-VARIABLE) (ANALYSE-LITERAL-ATOM (CDR LISTE)))) (T (CONS (CAR LISTE) (ANALYSE-LITERAL-ATOM (CDR LISTE))))))) (T (ERROR "Fuer diesen Elementtyp nicht implementiert: " (CAR LISTE)))))) ==> ANALYSE-LITERAL-ATOM Auf der Basis dieser Eingabe-Transformation sind Prädikate zu definieren, die erkennen, ob ein Deckelement bzw. eine bestimmte Mustervariable vorliegt. Wir definieren z.B. für den Stern bzw. für die Mustervariable, deren PRINTName mit einem Stern beginnt, folgende Prädikate: eva1> (DEFINE *-SYMB0L? (LAMBDA (L) (AND (PAIR? L) (EQ? '* (CAR L)) (NULL? (LIST-REF L 1 ) ) ) ) ) ==> *-SYMB0L? eval> (DEFINE *-VARIABLE? (LAMBDA (L) (AND (PAIR? L) (EQ? '* (CAR L)) (LIST-REF L 1 ) ) ) ) ==> ^-VARIABLE?

II. Konstruktionen (Analyse und Synthese)

198

Wir benötigen Selektoren und Mutatoren für den Wert einer Mustervariablen. Wir verwenden hier die Eigenschaftsliste des Symbols (vgl. Abschnitt 5.3), um abgedeckte Elemente zu speichern. Die Entscheidung für die Eigenschaftsliste verhindert einerseits das Überschreiben bestehender Symbol-Wert-Bindungen und dient andererseits zum Training der P-Listen-Konstrukte. Die Selektoren und den Mutator definieren wir, wie folgt: eval> eval>

eval>

(DEFINE GET-MATCH-VARIABLE (LAMBDA ( L ) ( L I S T - R E F L 1 ) ) ) ( D E F I N E GET-MATCH-VALUE (LAMBDA (SYMBOL) (GETPROP

==>

SYMBOL

GET-MATCH-VARIABLE 'MATCH - V A L U E ) ) ) ==> GET-MATCH-VALUE

(DEFINE SET-MATCH-VALUE! ( L A M B D A ( S Y M B O L WERT) ( P U T P R O P SYMBOL WERT ' M A T C H - V A L U E ) T ) ) ==> SET-MATCH-VALUE!

Die Erweiterung um Mustervariablen bedingt einige Anpassungen am obigen SIMPLE-MATCH-Konstrukt (vgl. Abschnitt 7.1). Zur Erläuterung sind die betroffenen Änderungsstellen in der folgenden Wiederholung des SIMPLEMATCH-Konstruktes markiert. eval>

(DEFINE (COND

S I M P L E - M A T C H (LAMBDA (MUSTER L I S T E ) ((AND (NULL? MUSTER) (NULL? L I S T E ) ) T) ( ( A N D ( N U L L ? L I S T E ) ( N U L L ? (CDR M U S T E R ) ) ( E Q ? ' * (CAR M U S T E R ) ) ) T) :Ergänzung A *-VARIABLE? als letztes M u s t e r e l e m e n t , dann Wertbindung NIL v o l l z i e h e n . ((OR (NULL? MUSTER) (NULL? L I S T E ) ) N I L ) ( ( O R ( E Q ? (CAR MUSTER) (CAR L I S T E ) ) ( E Q ? ' ? (CAR M U S T E R ) ) ) ( S I M P L E - M A T C H (CDR MUSTER) (CDR L I S T E ) ) ) ;Ergänzung B ; ?-VARIABLE? auswerten ( ( E Q ? ' * (CAR MUSTER)) (COND ( ( S I M P L E - M A T C H

(T

(CDR MUSTER) (CDR L I S T E ) ) T) ((SIMPLE-MATCH MUSTER (CDR L I S T E ) ) T ) ((SIMPLE-MATCH (CDR MUSTER) L I S T E ) T) (T N I L ) ) ) ;Ergänzung C ; *-VARIABLE? auswerten N I L ) ) ) ) ==> SIMPLE-MATCH

Die Ergänzung A betrifft den Fall, daß der Prüfling vollständig abgearbeitet ist, d.h. die LAMBDA-Variable L I S T E ist an NIL gebunden, aber das Muster enthält noch Elemente. Dann ist festzustellen, ob das Muster nur noch ein Element enthält und dieses entweder das Prädikat * - S Y M B O L ? oder das Prädikat *-VA-

7. Abbildungsoption: Zeichenkette und Symbol

199

RIABLE? erfüllt. Ist * - S Y M B O L ? bzw. *-VARIABLE? erfüllt, dann paßt das Muster, so daß wir T zurückgeben können und im Fall *-VARIABLE? noch das zugehörende Symbol an NIL binden. Wir unterstellen damit, daß unser Muster auch dann paßt, wenn der Stern für eine leere Folge von Elementen im Prüfling steht. Die Ergänzung B betrifft den Fall, daß im Muster das Prädikat ?-VARIABLE? erfüllt ist. Hierzu ist eine entsprechende Klausel einzufügen. Wenn der Rest des Musters mit dem Rest des Prüflings paßt, ist das zugehörende Symbol an den Wert zu binden. Wir können diese Klausel, wie folgt, definieren: ((AND

( ? - V A R I A B L E ? (CAR MUSTER)) (MATCH (CDR MUSTER) (CDR L I S T E ) ) ) (SET-MATCH-VALUE! (GET-MATCH-VARIABLE (CAR L I S T E ) ) T)

(CAR

MUSTER))

Die Ergänzung C betrifft den Fall, daß im Muster das Prädikat »-VARIABLE? erfüllt ist. Im SIMPLE-MATCH ist quasi der Fall formuliert, der * - S Y M B O L ? abdeckt. Statt (EQ? ' * (CAR MUSTER)) ist ( * - S Y M B O L ? (CAR MUSTER)) zu setzen. Die einzelnen Klauseln dieses *-SYMBOL?-Falles sind hier für den Fall »-VARIABLE? ebenfalls zu formulieren, allerdings sind dann die Wertbindungen zu ergänzen. Wir können diese Ergänzung, wie folgt, definieren: ( ( * - V A R I A B L E ? (CAR MUSTER)) (COND ( ; ; VARIABLE? deckt ein Element! (MATCH (CDR MUSTER) (CDR L I S T E ) ) ( S E T - M A T C H - V A L U E ! (GET-MATCH - V A R I A B L E (CAR MUSTER)) ( L I S T (CAR L I S T E ) ) ) ) ; ; * - V A R I A B L E ? deckt mehrere Elemente! ; ; Der b i s h e r i g e Wert i s t zu e r g ä n z e n . ((MATCH MUSTER (CDR L I S T E ) ) ( S E T - M A T C H - V A L U E ! ( G E T - M A T C H - V A R I A B L E (CAR MUSTER)) (CONS (CAR L I S T E ) (GET-MATCH-VALUE (GET-MATCH - VARIABLE (CAR M U S T E R ) ) ) ) ) T) ; ; * - V A R I A B L E ? deckt kein Element! ((MATCH (CDR MUSTER) L I S T E ) T ) ; ; Muster paßt n i c h t . (T N I L ) ) )

Dieses erweiterte MATCH-Konstrukt und seine Hilfsfunktionen wie Prädikate, Selektoren, Mutatoren sowie das ANALYSE-LITERAL-ATOM sind als lokale Funktionen im Konstrukt MUSTERVERGLEICH definiert (vgl. Programm 7.3-1).

200

;;;; ;;;; ;;;;

II. Konstruktionen (Analyse und Synthese)

Dokument 7 . 3 - 1 T i t e l : Programm MUSTERVERGLEICH E r s t e l l t am: 3 1 . 1 2 . 8 9 ¡ l e t z t e Ä n d e r u n g :

;;; ;;; ;:; ;;; ;;: ;;; ;;; ::; ;;; ;;; ;;; ;;; ;;; ;;; ;;;

AI

;;; ;;; ;;; ;;; ;;; :;;

El

;;; ;;; ;;; ;::

T1

;;;

A2 A2.1 A2.2 A2.3

A2.4

A2.5

El.1 El.2 El.3 El.3

8.11.90

MUSTERVERGLEICH a n a l y s i e r t zwei L i s t e n , d i e L i s t e PATTERN und d i e L i s t e OBJEKT, mit dem Z i e l Werte f ü r M A T C H - V a r i a b l e zu b e s t i m m e n . PATTERN kann a u s f o l g e n d e n S y m b o l e n b e s t e h e n : ? : : = D e c k t e i n L i s t e n e l e m e n t im OBJEKT. * : : = D e c k t e i n e F o l g e von L i s t e n e l e m e n t e n im OBJEKT. ? : : = D e c k t e i n L i s t e n e l e m e n t im OBJEKT und b i n d e t d i e s e s L i s t e n e l e m e n t u n t e r der E i g e n s c h a f t MATCH-VALUE an d a s Symbol . * : : = D e c k t e i n e F o l g e von L i s t e n e l e m e n t e n im OBJEKT und b i n d e t d i e s e F o l g e a l s L i s t e u n t e r der E i g e n s c h a f t MATCH-VALUE an d a s Symbol . < s y m b o l > : : = D e c k t das g l e i c h e < s y m b o l > im OBJEKT. K o n v e r t i e r u n g der M a t c h v a r i a b l e n 2 Elementen, wie f o l g t : ? ==> (? NIL) * ==> ( * NIL) ? = = > ( ? ) * = = > ( * )

in eine

Liste

mit

Bei s p i e l e v a l > (MUSTERVERGLEICH ' ( * X HAT ? WARTBARE ? Y ) ' ( D E R ENTWURF HAT E I N E WARTBARE STRUKTUR) eval> eval>

(GETPROP (GETPROP

'X 'Y

'MATCH-VALUE) 'MATCH-VALUE)

==> ==>

(DER ENTWURF) STRUKTUR

—>

#T

( D E F I N E MUSTERVERGLEICH (LAMBDA (PATTERN OBJECT) (LETREC ( ;; K o n v e r t i e r u n g der M a t c h v a r i a b l e n i n e i n e ;; z w e i e l e m e n t i g e L i s t e ( A N A L Y S E - L I T E R A L - A T O M (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) N I L ) ( ( S Y M B O L ? (CAR L I S T E ) ) ( L E T * ( ( A L L E - Z E I C H E N (EXPLODE (CAR L I S T E ) ) ) (MATCH-TYP (CAR A L L E - Z E I C H E N ) ) (MATCH-VARIABLE (COND ( ( N U L L ? (CDR A L L E - Z E I C H E N ) ) N I L ) (T ( I M P L O D E (CDR A L L E - Z E I C H E N ) ) ) ) ) ) (COND ( ( E Q ? ' ? MATCH-TYP) (CONS ( L I S T ' ? M A T C H - V A R I A B L E ) (ANALYSE-LITERAL-ATOM (CDR L I S T E ) ) ) ) ( ( E Q ? ' * MATCH-TYP) (CONS ( L I S T ' * M A T C H - V A R I A B L E ) (ANALYSE-LITERAL-ATOM (CDR L I S T E ) ) ) ) (T (CONS (CAR L I S T E ) (ANALYSE-LITERAL-ATOM (CDR L I S T E ) ) ) ) ) ) ) (T (ERROR "Fuer diesen Elementtyp nicht implementiert: " (CAR L I S T E ) ) ) ) ) )

7. Abbildungsoption: Zeichenkette und Symbol ; ; ; ; Prädi kate ( ? - S Y M B O L ? (LAMBDA ( X ) (AND ( P A I R ? X ) ( E Q ? ' ? (CAR X ) ) (NULL? ( L I S T - R E F X ( ? - V A R I A B L E ? (LAMBDA ( X ) (AND ( P A I R ? X ) ( E Q ? ' ?

1))))) (CAR

( * - SYMBOL? (LAMBDA ( X ) (AND ( P A I R ? X ) (EQ? ' * (CAR X ) ) (NULL? ( L I S T - R E F X ( * - V A R I A B L E ? (LAMBDA ( X ) (AND ( P A I R ? X ) ( E Q ? ' * ; ;;;

Seiektoren ( G E T - M A T C H - V A R I AB LE

X))

(LIST-REF

X

1))))

(LIST-REF

X

1))))

1))))) (CAR

(LAMBDA

(X)

X))

(LIST-REF

X

1)))

( G E T - M A T C H - V A L U E (LAMBDA (SYMBOL) ( G E T P R O P SYMBOL ' M A T C H - V A L U E ) ) ) ; ;;;

Mutator ( S E T - M A T C H - V A L U E ! ( L A M B D A ( S Y M B O L WERT) ( P U T P R O P SYMBOL WERT ' M A T C H - V A L U E ) T))

;;;;

MATCH-Konstrukt (MATCH ( L A M B D A ( M U S T E R L I S T E ) (COND ( ( A N D ( N U L L ? M U S T E R ) ( N U L L ? L I S T E ) ) T ) ((NULL? LISTE) (COND ( ( A N D ( * - S Y M B O L ? ( C A R M U S T E R ) ) ( N U L L ? (CDR M U S T E R ) ) ) T) ( ( A N D ( * - V A R I A B L E ? (CAR M U S T E R ) ) ( N U L L ? (CDR M U S T E R ) ) ) (SET-MATCH-VALUE! ( G E T - M A T C H - V A R I A B L E (CAR M U S T E R ) ) NIL) T) (T N I L ) ) ) ((OR (EQUAL? (CAR MUSTER) (CAR L I S T E ) ) ( ? - SYMBO L ? ( C A R M U S T E R ) ) ) (MATCH ( C D R M U S T E R ) ( C D R L I S T E ) ) ) ((AND

( ? - V A R I A B L E ? (CAR MUSTER)) (MATCH ( C D R M U S T E R ) ( C D R L I S T E ) ) ) (SET-MATCH-VALUE! ( G E T - M A T C H - V A R I AB LE ( C A R M U S T E R ) ) (CAR L I S T E ) ) T)

( ( * - SYMBOL? (CAR M U S T E R ) ) (COND ( ( M A T C H ( C D R M U S T E R ) ( C D R L I S T E ) ) ((MATCH MUSTER (CDR L I S T E ) ) T) ((MATCH (CDR MUSTER) L I S T E ) T) (T N I L ) ) )

T)

202

II. Konstruktionen (Analyse und Synthese) ( ( * - V A R I A B L E ? (CAR M U S T E R ) ) (COND ((MATCH (CDR MUSTER) (CDR L I S T E ) ) (SET-MATCH-VALUE! ( G E T - M A T C H - V A R I AB LE (CAR M U S T E R ) ) ( L I S T (CAR L I S T E ) ) ) ) ((MATCH MUSTER (CDR L I S T E ) ) (SET-MATCH-VALUE! ( G E T - M A T C H - V A R I AB LE (CAR M U S T E R ) ) (CONS (CAR L I S T E ) (GET-MATCH-VALUE (GET-MATCH-VARIABLE (CAR M U S T E R ) ) ) ) ) T) ((MATCH (CDR MUSTER) L I S T E ) T) (T N I L ) ) ) (T

NIL)))))

(MATCH ( A N A L Y S E - L I T E R A L - A T O M

PATTERN)

OBJECT))))

Programm 7 . 3 - 1 Mustervergleich mit Mustervariablen (Abb i 1 d u n g s b a s i s : L i s t e n )

7.4 Generieren eines Symbols Wird der Name eines Symbol eingelesen, dann ist zu prüfen, ob dieses Symbol schon existiert oder nicht. Da wir laufend mit Symbolen umgehen, ist so effizient wie möglich zu prüfen, ob es sich um ein vorhandenes oder neues, zu erzeugendes Symbol handelt. Z.B. benötigt das DEFINE-Konstrukt das Prüfergebnis, um zu entscheiden, ob nur der Wert eines existierenden Symbols zu ändern oder zunächst ein entsprechendes Symbol zu erzeugen und dann in der Umgebung mit seinem Wert einzutragen ist. eval> eval> eval>

FOO = = > ERROR . . . ( D E F I N E FOO 6) = = > FOO ( D E F I N E FOO ' ( A B = = > FOO

;In

der

Umgebung n i c h t

definiert

;FOO g e n e r i e r t und Wert z u g e w i e s e n , C)) ;FOO neuen Wert z u g e w i e s e n .

Diese Prüfung nimmt üblicherweise Bezug auf eine Symboltabelle. Dabei werden neue Symbole erzeugt und in die Tabelle eingetragen. Diesen Vorgang nennt man auch „Internmachen". Über das Einlesen des Namens des Symbols können daher nur intern gemachte Symbole wieder erreicht werden. Erzeugt man ein Symbol, ohne es „intern zu machen", d.h. ohne Eintragung in die Symboltabelle, dann ist es später durch die READ-Phase nicht erreichbar. Obwohl ein „nicht interngemachtes" Symbol über das Einlesen seines Namens nicht referenzierbar ist, kann es sehr nützlich sein. Es ist keinesfalls mit Symbolen zu verwechseln, die überhaupt nicht mehr erreichbar sind und als Platzver-

7. Abbildungsoption: Zeichenkette und Symbol

203

schwendung (Müll) zu betrachten sind. Erreichbar ist ein solches „nicht internes" Symbol (engl.: uninterned symbol) z.B. wenn es als Wert eines internen Symbols dient. Ein nicht „interngemachtes" Symbol generiert das GENSYM-Konstrukt. Ein von GENSYM erzeugtes Symbol hat keine Gleichheit (im Sinne von EQ?) mit existierenden oder neu eingelesenen Symbolen. Geht es daher um die Vermeidung von Überschreibungen mit bestehenden oder noch entstehenden Symbolen, dann ist das GENSYM-Konstrukt angebracht. eval>

(GENSYM

{})

— >

mit:

::= < s t r i n g >



(DEFINE

F00

eval>

F00 = = >

GO

eval> eval>

(SYMBOL? (EQ? 'GO

eval>

(EQ?

eval>

(DEFINE

BAR

eval>

BAR ==>

Gl

eval>

(DEFINE

FOO

F00

eval > FOO = >

Cnonnegative-integer>

::= D i e Z e i c h e n k e t t e w i r d a l s P r ä f i x d e s Symbol namens v e r w e n d e t . ::= D i e Zahl s e t z t d e n Z ä h l e r . Das n ä c h s t e g e n e r i e r t e S y m b o l h a t d i e s e Zahl als l a u f e n d e Nummer. ::= Ein n e u e s n i c h t i n t e r n g e m a c h t e s S y m b o l . Ist k e i n < s t r i n g > a n g e g e b e n beginnt sein P R I N T - N a m e mit G gef o l g t von einer l a u f e n d e n Nummer. Jede GENSYM-Applikation erhöht die laufende Nummer.

eval>

|

(GENSYM))

F00) ==> F00) = = >

#T ()

F00) = = >

#T

==>

F00

¡Achtung! Keine Gleichheit ; gleichem PRINT-Namen

(GENSYM))

==>

BAR

(GENSYM))

==>

FOO

trotz

G2

eval>

(EVAL

(LIST

eval>

(EVAL

FOO) = = >

'DEFINE

FOO

13)) = = >

G2

13

Wollen wir ein nicht „interngemachtes" Symbol mit vorgegebenen Namen generieren, dann ist das in PC Scheme eingebaute STRING->UNINTERNEDSYMBOL-Konstrukt zu verwenden. eval> eval>

(DEFINE FOO = = >

FOO ( S T R I N G - > U N I N T E R N E D - S Y M B O L |M 0 R E!

"M 0 R E " ) ) = = >

FOO

204 eval> (EQ? F00

II. Konstruktionen (Analyse und Synthese) 1

IM 0 R E!) ==> ()

Im Vergleich dazu, zeigt das folgende Beispiel den Effekt des "Internmachens": eval> (DEFINE F00 (STRING->SYMBOL "M 0 R E")) ==> F00 eval> F00 ==> ¡ M O R E ! eval> (EQ? F00 '!M 0 R E!) ==> #T Beispiel: Pseudo-Code- Vorübersetzer In Kapitel I ist für die Alternative und die Iteration eine Notation angegeben, die häufig in den ersten Phasen des Lebenszyklus eines Software-Produktes (vgl. Bild 2-1) eingesetzt wird. Man spricht in diesem Zusammenhang von einer Pseudocode-Notation, weil die formulierten Konstrukte prinzipiell noch nicht „lauffähig" sind. Sie enthalten Formulierungen, die später noch zu präzisieren sind. Wir fassen hier jedoch die Pseudo-Code-Notation nur als eine syntaktische Erleichterung auf und unterstellen eine „lauffähige" Notation. Wir definieren mit Hilfe des Konstruktes MUSTERVERGLEICH einen Pseudocode-Vorübersetzer. Unser P-CODE-Konstrukt kann folgende PseudocodeNotationen in LISP-Konstrukte übersetzen: o Alternative (vgl. Abschnitt 2.2.2) (IF . . . THEN . . . ELSE . . . FI) (IF . . . THEN . . . FI) o Iteration (vgl. Abschnitt 2.2.3) (WHILE . . . DO . . . OD) (DO . . . UNTIL . . . OD) Diese Pseudocode-Angaben betrachten wir als eine Musterbeschreibung. Wir formulieren z.B. für die Alternative das Muster (IF ?P THEN *JA ELSE *NEIN). Paßt das Muster, dann sind die Mustervariablen an die „aktuellen" Werte gebunden. Unser P-CODE-Konstrukt braucht nur die JA- und NEIN-Werte an die entsprechenden Stellen des geeigneten LISP-Konstruktes zu setzen. Da eine Mustervariable mit einem Stern die abgedeckten Elemente zu einer Liste zusammenfaßt, befindet sich das erste abgedeckte Element in dieser Liste in funktionaler Stellung. Es würde als Operator interpretiert. Dies verhindern wir durch das Einfügen des BEGIN-Konstruktes in die JA- bzw. NEIN-Liste. eval> (P-CODE ' ( I F P THEN A B C ELSE D E FI)) ==> (IF P (BEGIN A B C )

(BEGIN D E F))

Für die beiden Iterationen formulieren wir die beiden Muster (WHILE ?P DO *BODY OD) und (DO *BODY UNTIL ?Q OD). Mit den Werten der Mustervariablen ?P bzw. ?Q und *BODY konstruieren wir eine rekursive LISP-Funk-

7. Abbildungsoption: Zeichenkette und Symbol

205

tion. Diese Funktion nutzt das LETREC-Konstrukt zur Definition einer lokalen, rekursiven Funktion. Benötigt wird ein Funktionsnamen (Symbol) für den Selbstbezug. Jedes Symbol, das wir dafür rein zufällig wählen, kann zu ungewollten Nebeneffekten führen. Im folgenden Beispiel haben wir unterstellt, wir hätten das Symbol AAA als Funktionsnamen gewählt. Tritt in der Pseudo-Code-Formulierung zufällig auch das Symbol AAA auf, dann kommt es zu Fehlern. Der erste Fall hat keine Namensgleichheit mit dem Symbol AAA; der zweite hat eine solche und führt zu einem ungewollten Effekt. Im 3. Fall verwenden wir ein Symbol, das mit dem Konstrukt GENSYM generiert wurde, und verhindern damit einen solchen Nebeneffekt. Fall 1: Keine zufällige Namensgleichheit mit der Funktion AAA eval> (DEFINE I 0) ==> I eval> (DEFINE J 'DM) ==> J eval> (DEFINE F00 (P-CODE '(DO (WRITELN I " " J) (SET! I (1+ I ) ) UNTIL (> I 3) OD))) ==> F00 eval> F00 ==>(LETREC ((AAA (LAMBDA () (WRITELN I " " J) (SET! I (1+ I ) ) (COND ((> I 3) ( ) ) (T (AAA)))))) (AAA)) eval> (EVAL F00) ==> 0 DM 1 DM 2 DM 3 DM () Fall 2: eval> eval> eval>

Zufällige Namensgleichheit mit der Funktion AAA (DEFINE I 0) ==> I (DEFINE AAA 'DM) ==> AAA ¡Namensgleiche g l o b a l e Variable (DEFINE F00 (P-CODE '(DO (WRITELN I " " AAA) (SET! I (1+ I ) ) UNTIL (> I 3) OD))) ==> F00 eval> F00 ==>(LETREC ((AAA (LAMBDA () (WRITELN I " " AAA) (SET! I (1+ I ) ) (COND ((> I 3) ( ) ) (T (AAA)))))) (AAA))

206 eval> (EVAL F00) ==> 0 # 1 # 2 # 3 # ()

II. Konstruktionen (Analyse und Synthese)

¡Achtung! Ungewollter Nebeneffekt! ; Gewünschte Lösung vgl. Fall 1

Im P-CODE-Konstrukt (vgl. Programm 7.4-1) ist das Symbol für die lokale, rekursive Funktion mit Hilfe des GENSYM-Konstruktes konstruiert. Selbst in dem ungünstigsten Fall, d.h. der PRINT-Name dieses generierten Symbols ist gleich mit dem PRINT-Namen eines eingelesen Symbols, besteht keine Referenz zu diesem anderen Symbol. Der Fall 3 zeigt eine solche, schwer durchschaubare Situation. Zu einem ungewollten Nebeneffekt kommt es jedoch nicht. Fall 3: Symbol für die Funktion mit GENSYM generiert eval> (DEFINE I 0) ==> I eval> (DEFINE G6 'DM) ==> G6 ¡ Z u f ä l l i g e PRINT-Namensgi e i c h h e i t ; mit dem anschließend g e n e r i e r t e n ; Symbol eval> (DEFINE F00 (P-CODE '(DO (WRITELN I " " G6) (SET! I (1+ I ) ) UNTIL (> I 3) OD))) ==> F00 eval> F00 ==>(LETREC ((G6 (LAMBDA () ¡Generiertes Symbol (WRITELN I " " G6) ¡Eingegebenes Symbol (SET! I (1+ I ) ) (COND ((> I 3) ( ) ) (T ( G 6 ) ) ) ) ) ) ¡Generiertes Symbol (G6)) ; Generiertes Symbol eval> (EVAL F00) ==> 0 DM 1 DM 2 DM 3 DM () Im Fall der Iteration setzt das P-CODE-Konstrukt seinen Rückgabewert (= LETREC-Konstrukt) mit Hilfe der wiederholten Anwendung des LIST-Konstruktes zusammen. Die geschachtelten LIST-Konstrukte sind nicht sehr übersichtlich (vgl. Programm 7.3-1). Mit Hilfe der Makros QUASIQUOTE, UNQUOTE und UNQUOTE-SPLICING wäre eine syntaktisch einfachere Notation möglich. Mit Makros befassen wir uns eingehend im Abschnitt 8.3.

7. Abbildungsoption: Zeichenkette und Symbol

Dokument 7.4-1 Titel: Programm P-CODE Erstellt: 31.12.89 ¡letzte Aenderung: AI A2 A2.1 A2.2 A3 A3.1 A3.2 T1

(DEFINE (COND

207

8.11.90

P - C O D E ü b e r f ü h r t s o g e n a n n t e P s e u d o c o d e - N o t a t i o n e n in ablauffähige LISP-Konstrukte. Implemtiert sind die A l t e r n a t i v e (vgl. A b s c h n i t t 2.2.2) (IF ... T H E N ... E L S E ... FI) (IF ... T H E N ... FI) und die Iteration (vgl. A b s c h n i t t 2.2.3) ( W H I L E ... DO ... O D ) (DO ... U N T I L ... O D )

Beispiel eval> (P-CODE ' ( W H I L E ( (LETREC ((Gl ( L A M B D A () ( C O N D ( ( < = I 5) ( P R I N T I) (T N I L ) ) ) ) ) (Gl))

I)

(SET!

(SET!

I (1+

P-CODE (LAMBDA (SEXPR) ( ( M U S T E R V E R G L E I C H '(IF ?X T H E N *Y E L S E *Z (LET ( ( P R A E D I K A T ( G E T P R O P 'X ' M A T C H - V A L U E ) ) (BODY - L I S T E - 1 ( G E T P R O P 'Y ' M A T C H - V A L U E ) ) (BODY-LISTE-2 ( G E T P R O P 'Z ' M A T C H - V A L U E ) ) ) ( L I S T 'IF PRAEDIKAT ( C O N S ' B E G I N BODY - L I S T E - 1 ) (CONS 'BEGIN B O D Y - L I S T E - 2 ) ) ) ) ( ( M U S T E R V E R G L E I C H '(IF ?X T H E N *Y FI) (LET ( ( P R A E D I K A T ( G E T P R O P 'X ' M A T C H - V A L U E ) ) (BODY-LISTE ( G E T P R O P 'Y ' M A T C H - V A L U E ) ) ) ( L I S T 'IF PRAEDIKAT (CONS 'BEGIN B O D Y - L I S T E ) NIL)))

I (1+

FI)

SEXPR)

I))

I))

OD))

(Gl))

SEXPR)

208

II. Konstruktionen (Analyse und Synthese) ( ( M U S T E R V E R G L E I C H ' ( W H I L E ?X DO * Y OD) S E X P R ) (LET ((SYMBOL (GENSYM) ) (PRAEDIKAT (GETPROP ' X ' M A T C H - V A L U E ) ) (BODY-LISTE (GETPROP ' Y ' M A T C H - V A L U E ) ) ) ( L I S T 'LETREC ( L I S T ( L I S T SYMBOL ( L I S T 'LAMBDA N I L ( L I S T 'COND (APPEND (CONS P R A E D I K A T BODY-LISTE) (LIST (LIST SYMBOL))) '(T NIL))))) (LIST SYMBOL)))) ( ( M U S T E R V E R G L E I C H ' ( D O *Y U N T I L ?X OD) S E X P R ) (LET ((SYMBOL (GENSYM)) (PRAEDIKAT (GETPROP ' X ' M A T C H - V A L U E ) ) (BODY-LISTE (GETPROP ' Y 'MATCH-VALUE))) ( L I S T 'LETREC ( L I S T ( L I S T SYMBOL (APPEND (CONS ' L A M B D A (CONS N I L B O D Y - L I S T E ) ) ( L I S T ( L I S T 'COND ( L I S T PRAEDIKAT N I L ) (LIST 'T (LIST SYMBOL))))))) (LIST SYMBOL)))) (T

(ERROR "Keine P-Code-Transformation SEXPR)))))

Programm 7 . 3 - 1 .

definiert

fuer:

"

P-CODE-Vorübersetzer

7.5 Zusammenfassung: EXPLODE, IMPLODE und GENSYM Die Zeichenkette (engl.: string) kann mit einer Vielzahl spezieller Konstrukte, z.B. MAKE-STRING, S U B S T R I N G oder STRING-REF, bearbeitet werden. In Bezug zur Liste tritt an die Stelle des Prädikates NULL? das eingebaute Prädikat STRING-NULL?. Das Prädikat STRING=? entspricht der EQUAL?-Prüfung. Ein Symbol, auch Literalatom genannt, ist eine „Einheit" mit eigener Identität. Der PRINT-Name ist eines der Elementarteilchen der „Einheit" Symbol. Er kann durch Nutzung von Fluchtzeichen (z.B in PC Scheme die Zeichen ! und \) auch mit Sonderzeichen konstruiert werden. Mit Hilfe der Konstrukte E X PLODE und IMPLODE ist der PRINT-Name als Informationsträger manipulierbar. Ein nicht „interngemachtes" Symbol (engl.: uninterned symbol) ist über den

7. Abbildungsoption: Zeichenkette und Symbol

209

PRINT-Namen nicht referenzierbar. Ein neues, nicht „interngemachtes" Symbol generiert das GENSYM-Konstrukt. Eine GENSYM-Applikation ist zweckmäßig, wenn ein Namenskonflikt mit existierenden oder später generierten Symbolen zu verhindern ist. Im Gegensatz zu klassischen LISP-Systemen hat das Symbol in Scheme keine Funktionszelle als besonderes Elementarteilchen. Damit werden Ungereimtheiten zwischen funktionalen und nichtfunktionalen Werten vermieden. Mit dem GENSYM-Konstrukt ist auch in Scheme eine besondere Funktionszelle mit Hilfe der Eigenschaftsliste realisierbar. eval> (DEFINE GET-F) ==> GET-F eval> (DEFINE SET-F1) ==> SET-F! eva1> (LET ((EIGENSCHAFT (GENSYM))) (SET! GET-F (LAMBDA (SYMBOL) (GETPROP SYMBOL EIGENSCHAFT))) (SET! SET-F! (LAMBDA (SYMBOL FUNKTION) (PUTPROP SYMBOL FUNKTION EIGENSCHAFT))) T) ==> #T eval> (SET-F! 'F00 (LAMBDA (X Y) (LIST X Y))) ==> # eval> (DEFINE F00 1) ==> 1 eval> ((GET-F 'F00) 'A 'B) ==> (A B) Charakteristische Beispiele für Abschnitt 7: ;;;; P a s c a l s c h e s Dreick a u s g e b e n . eva1> (DEFINE ¡ P a s c a l s c h e s D r e i e c k ! (LAMBDA (N_ENDZEILE) (LETREC ((PASCAL (LAMBDA (GRUNDSEITE I_ZEILE) (COND ( ( = N_ENDZEILE I_ZEILE) (AUSGABEGRUNDSEITE)) (T (AUSGABE GRUNDSEITE) (PASCAL (MAKE-NEUE-DREI ECK-SEITE GRUNDSEITE) (1+ I _ Z E I L E ) ) ) ) ) ) (MAKE-NEUE-DREIECK-SEITE (LAMBDA (L) (COND ( ( = 1 (LENGTH L)) (LIST 1 1 ) ) (T(APPENDC LIST 1) (APPEND (SUMME L) (LIST 1 ) ) ) ) ) ) )

210

II. Konstruktionen (Analyse und Synthese)

(SUMME (LAMBDA (COND

(L_ZAHLEN) ((=

(LENGTH

(LIST

(+

L_ZAHLEN)

(CAR

2)

L.ZAHLEN) (CADR

(T

L_ZAHLEN))))

(APPEND (LIST

(+

(CAR

L_ZAHLEN) (CADR

(SUMME

(CDR

(LAENGE-AUSGABE-ZEILE

L_ZAHLEN ) ) )

L_ZAHLEN)))))))

70)

(ANZAHL-ZIFFERN-GRUNDSEITE (LAMBDA (COND

(L) ((NULL?

L)

0) ;;

(T

(+

(LENGTH

Auf

Zahlen

(EXPLODE

(CAR

angewendet! L)))

(ANZAHL-ZIFFERN-GRUNDSEITE (CDR

L)))))))

(ANZAHL-SPACE-GRUNDSEITE (LAMBDA (-1+

(L) (LENGTH

L))))

(EINRUECKEN-AUSGABE-ZEILE (LAMBDA

(L)

(MAKE-STRING (FLOOR (/

(-

LAENGE-AUSGABE-ZEILE (+

(ANZAHL-ZIFFERN-GRUNDSEITE (ANZAHL-SPACE-GRUNDSEITE

L) L)))

2)) #\SPACE))) (AUSGABE (LAMBDA

(L)

(WRITELN (PASCAL

(LIST

(EINRUECKEN-AUSGABE-ZEILE

L)

1)

Dreieck!

0))))

==>

¡Pascalsches

L))))

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

eval>

(I P a s c a l s c h e s

Dreieck!

12)

211

==> (1) (1

(1

1)

2

1)

( 1 3 3 1) ( 1 4 6 4 1) ( 1 5 10 10 5 1 ) ( 1 6 15 20 15 6 1 ) (1 7 21 35 35 21 7 1) ( 1 8 2 8 56 7 0 5 6 2 8 8 1 ) (1 9 36 84 126 126 84 36 9 1) ( 1 10 4 5 1 2 0 2 1 0 2 5 2 2 1 0 1 2 0 4 5 10 1 ) ( 1 1 1 5 5 1 6 5 3 3 0 4 6 2 4 6 2 3 3 0 1 6 5 5 5 11 1 ) ( 1 1 2 6 6 2 2 0 4 9 5 7 9 2 9 2 4 7 9 2 4 9 5 2 2 0 6 6 12 1 ) ;;;;

Vergleich

eval>

(DEFINE

zweier ¡X

(LAMBDA (LET (DO

PRINT-Namen

ASCII

(CAR

Y-SYM))))

(SET!

WERT

T)

(SET!

WERT

NIL))))))

==>

(IX

(IX

C!X

#T

eval >

(GENSYM)

eval >

(IX

==> '60

==>

|X

eval >

#T

8. Abbildungsoption: Funktion mit zugeordneter Umgebung Der klassische LISP-Kern konzipiert von McCarthy, das sogenannte "Pure LISP", ist eine applikative Sprache, da die Applikation (Anwendung) von Funk-

II. Konstruktionen (Analyse und Synthese)

212

tionen das wesentliche Konstruktionsmittel ist. Dieses „Pure L I S P " ist gleichzeitig eine funktionale Sprache, da die Abstraktion auf der Komposition von Funktionen (= evaluierten LAMBDA-Konstrukten) beruht. Diese Schachtelung ermöglicht das Kombinieren primitiver Konstrukte zu komplexen anwendungsspezifischen Lösungen. "Pure L I S P " ist der Stammvater vieler Sprachen für das funktionale Programmieren (vgl. z.B. Henderson, 1980; Darlington u.a., 1982; Henson, 1987 oder Eisenbach, 1987). Zu nennen sind z.B. FP (vgl. Backus, 1978), HOPE (genannt nach „Hope Park Square", Adresse von Edinburgh's Department of Computer Science) oder M L (vgl. Gordon u.a., 1984). Leitidee der funktionalen Programmierung ist der Funktionswert, der nur durch Werte der Argumente bestimmt wird. Sooft wir auch eine Funktion mit den gleichen Argumenten aufrufen, stets hat sie den gleichen Wert. Diese Eigenschaft (engl.: referential transparency) erleichtert wesentlich das Durchschauen einer Konstruktion. Beschränken wir uns auf Konstrukte mit dieser Eigenschaft, dann ist eine Funktion problemlos durch eine effizientere Funktion, die den gleichen Wert bei gleichen Argumenten hat, austauschbar. Diesen Vorteil gibt es nicht kostenlos. Solche nebeneffektfreien Konstrukte erstellen neue Objekte statt modifizierte Versionen von ihren Argumenten. Die Neukonstruktion hat im Regelfall einen höheren Rechenzeit- und Speicherbedarf. Stets ist die Funktion im Zusammenhang mit ihrer Umgebung zu sehen. Erst diese Verknüpfung zum sogenannten CLOSURE-Konzept meistert Funktionen höherer Ordnung. Die folgende Definition, in TLC-LISP formuliert, zeigt explizit die Verknüpfung der Umgebung (ENVironemt) mit dem LAMBDA-Konstrukt durch das explizit notierte CLOSURE-Konstrukt. T-eval>

( D E ADON ( N ) ;; " A b s c h l i e ß u n g " f ü r das f o l g e n d e LAMBDA-Konstrukt (CLOSURE ;; H i e r i s t N e i n e f r e i e V a r i a b l e (LAMBDA (M) (ADD N M ) ) ; ; Umgebung s p e i c h e r t V a r i a b l e N (ENV ' N N ) ) ) = = > ADDN

T-eval>

(SETQ

T-eval>

P L U S 3 (ADDN 3 ) ) = = > (CLOSURE ( P L U S 3 7 ) = = > 10

(LAMBDA

(M)

(ADD

N M))

(ENV

'N

3))

Die Bindungsstrategie bestimmt, zu welchem Zeitpunkt die Variablen ihren Wert erhalten. Die jeweilige Implementation bestimmt, auf welche Art und Weise der Wert einer Variablen gespeichert und "nachgeschaut" wird. In Abschnitt 1.4.2 haben wir die „dynamische" und die „lexikalische" Bindungsstrategie erörtert. Die beiden wesentlichen Implementationskonzepte werden als „deep access" und „shallow access" gekennzeichnet. Die Implementation „deep

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

213

access" hat im Vergleich zu „shallow access" den Vorteil ohne großen Aufwand den Wechsel der aktuellen Umgebung vollziehen zu können. „Shallow access" hat demgegenüber den Vorteil auf den Wert der Variablen schnell zugreifen zu können. Im folgenden werden diese Implementationskonzepte nicht weiter diskutiert (Näheres dazu vgl. z.B. Allen, 1978). Wir unterstellen die lexikalische Bindungsstrategie und behandeln damit die Funktion und ihre Umgebung als Option, lokale Werte abbilden zu können. Zunächst vertiefen wir Funktionen höherer Ordnung (Abschnitt 8.1). Funktionen höherer Ordnung können Funktionen als Werte von LAMBDAVariablen haben. Dabei zeigen wir, daß es sinnvoll sein kann, sogar die Funktion selbst an ihre LAMBDA-Variable zu binden. Mit dem allgemeinen Kontrollstruktur-Konstrukt CALL-WITH-CURRENT-CONTINUATION läßt sich an die LAMBDA-Variable die Fortsetzung der Verarbeitung, d.h. die RestKonstruktion, binden. Das Continuation-Konzept von Scheme ermöglicht damit eine beliebige Fortsetzungen einer begonnen Abarbeitung. Es gestattet quasi Sprünge in ihre „Zukunft" und ihre „Vergangenheit". Wir erläutern diese allgemeine Kontrollstruktur und behandeln den Unterschied zu einem einem einfachen „GOTO"-Sprung (Abschnitt 8.2). Eine hierarchische Ordnung von Umgebungen ermöglicht das Arbeiten mit abgerenzten Paketen. Als Beispiel dient erneut die Kontenverwaltung (Abschnitt 8.4). Dabei werden Makros als syntaktische Verbesserungen genutzt. Wir befassen uns daher vorab mit der Definition von Makros (Abschnitt 8.3). Funktionsgeprägte Konstruktionen können (müssen aber nicht) im Vergleich zu imperativgeprägten weniger effizient sein. Eine Möglichkeit der Effizienzverbesserung ist das Compilieren. Wir skizzieren kurz die Möglichkeiten in PC Scheme mit einer mehrfach rekursiven Funktion (Abschnitt 8.5).

8.1 Funktionen höherer Ordnung In diesem Abschnitt vertiefen wir das Verständnis für Funktionen, die Funktionen als Argumente und/oder als Wert haben. Das Konstruieren mit solchen Funktionen höherer Ordnung (engl.: higher-order function) wird anhand von drei Beispielen erörtert. Das erste Beispiel bildet den Listen-Konstruktor CONS als Funktion ab (Abschnitt 8.1.1). Das zweite Beispiel definiert Y, den Fixpunktoperator für Funktionen. Die Y-Definition hat hier die Aufgabe, das Verständnis für rekursive Funktionen zu vertiefen. Sie ermöglicht die Definition rekursiver Funktionen ohne Verwendung des DEFINE- oder LETREC-Konstruktes (Abschnitt 8.1.2). Im dritten Beispiel konstruieren wir eine Funktion ALTERNATE. Sie bearbeitet die Teilaufgaben von zwei Prozessen abwechselnd (Abschnitt 8.1.3).

214

II. Konstruktionen (Analyse und Synthese)

8.1.1 Funktionale Abbildung der CONS-Zelle Die funktionale CONS-Abbildung nennen wir F-CONS, um eine Namensgleichheit und infolgedessen das Überschreiben des eingebauten CONS-Konstruktes zu vermeiden. Zu F-CONS definieren wir die Selektoren F-CAR , F-CDR, die Prädikate F-PAIR?, F-NULL? und die Mutatoren F-SET-CAR! und F-SET-CDR!. Die Konstruktionsbasis („Mutter Erde") einer Liste ist NIL, die leere Liste. Analog dazu ist eine funktionale Anfangsgröße, ein funktionales NIL, zu definieren. Wir nennen es *F-NIL*. Die Sternchen im Namen dienen dazu, eine versehentliche Namensgleichheit beim Programmieren zu erschweren, weil wir nur wichtigen globalen Variablen einen Namen mit Sternchen geben (vgl. Abschnitt 11.1). eva1>

(DEFINE * F - N I L *

(LAMBDA

())

= = > ERROR

... ;Kein

Funktionskörper

Das LAMBDA-Konstrukt erfordert zumindest einen symbolischen Ausdruck als Funktionskörper. Um Konflikte mit anderen symbolischen Ausdrücken zu vermeiden, könnte man das GENSYM-Konstrukt (vgl. Abschnitt 7.4) verwenden. Wir nutzen hier einfach das Symbol *F-NIL* selbst. eval>

(DEFINE * F - N I L *

(LAMBDA

()

*F-NIL*))

==>

*F-NIL*

/Exkurs: Funktionale Konstante. Die Funktion (LAMBDA (X) *F-NIL*) wäre kein zweckmäßiges Beispiel für einen konstanten Rückgabewert; denn ihre Applikation kann unter Umständen zum Fehler führen: e v a l > ((LAMBDA

(X)

*F-NIL*)

(/ 1 0 ) )

==>

ERROR... ;Divison

durch Null

]

Die Aufgabe eines Konstruktors ist das Zusammenfügen von Teilen. Beim CONS-Konstrukt wird der CAR-Teil mit dem CDR-Teil verknüpft. Diese Verknüpfung ist abbildbar, indem wir die beiden Teile als Werte in der Umgebung einer Funktion speichern. eval>

(DEFINE

F-CONS (LAMBDA

(CAR_TEIL CDR_TEIL)

...

) ==>

F-CONS

Beim Applizieren des Funktionskörpers von F-CONS, d.h. innerhalb des LAMBDA-Konstruktes, sind die LAMBDA-Variablen CAR_ TEIL und CDR_ TEIL an Werte gebunden. Diese Bindungen sind in der Funktions-Umgebung als Assoziationen gespeichert. Mit Hilfe des THE-ENVIRONMENT-Konstruktes ist diese Umgebung als Rückgabewert definierbar. Das ACCESS-Konstrukt ermöglicht die Selektion der Werte in der angegebenen Umgebung (vgl. Abschnitt 1.4.2).

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

215

eval> (DEFINE F-CONS (LAMBDA (CAFLTEIL CDR_TEIL) (THE-ENVIRONMENT))) ==> F-CONS eval> F-CONS ==> # eval> (ACCESS CAR_TEIL (F-CONS 'A 'B)) ==> A eval> (ACCESS C D R_ T EIL (F-CONS 'A 'B)) ==> B Statt die Umgebung explizit als Rückgabewert zu definieren, verändern wir das F-CONS-Konstrukt so, daß sein Wert eine LISP-Funktion ist. eval> (DEFINE F-CONS (LAMBDA (CAR-TEIL CDR_TEIL) (LAMBDA (OPERATION) . . . eval> (F-CONS 'A 'B) ==> #

))) ==> F-CONS

Diese (Rückgabe-)Funktion wurde in einer Umgebung erzeugt, in der CAR TEIL an den Wert A und CDR TEIL an den Wert B gebunden sind. Erzeugt heißt: Aus der Liste mit dem Symbol LAMBDA in Präfixnotation ist durch Evaluieren eine LISP-Funktion, nach außen durch # angezeigt, entstanden. Wird diese (Rückgabe-)Funktion angewendet, dann haben ihre freien Variablen, hier CAR_ TEIL und CDR_ TEIL die Werte der Definitionsumgebung, weil in Scheme als Standardfall die lexikalische Bindungsstrategie implementiert ist. Sie legt fest, daß die Definitionsumgebung einer LISP-Funktion maßgeblich für die Bindung von freien Variablen ist (vgl. Abschnitt 1.4.2). Wir definieren den Konstruktor F-CONS, wie folgt: eval> (DEFINE F-CONS (LAMBDA (C A R_ T EIL C D R_ T EIL) (LAMBDA (OPERATION) (COND ((EQ? OPERATION 'F-PAIR?) (LAMBDA () T)) ((EQ? OPERATION 'F-CAR) (LAMBDA () CAR_TEIL)) ((EQ? OPERATION 'F-CDR) (LAMBDA () C D R_ T EIL)) ((EQ? OPERATION 'F-SET-CAR!) (LAMBDA (X) (SET! CAR_TEIL X))) ((EQ? OPERATION 'F - S ET -CDR!) (LAMBDA (X) (SET! CDR_TEIL X))) (T (ERROR "Unbekannte Operation: " OPERATION)))))) ==> F-CONS Die Selektoren CAR und CDR erfordern eine Liste bzw. ein Punkt-Paar als Argument. Diese Voraussetzung ist mit dem Prädikat PAIR? prüfbar. Für die Selektoren F-CAR und F-CDR definieren wir ein entsprechendes Prädikat F-PAIR?. eval> (DEFINE F-PAIR? (LAMBDA (OBJEKT) (COND ((AND (PROCEDURE? OBJEKT) ((OBJEKT 'F-PAIR?))) T) (T (ERROR "Keine f u n k t i o n a l e CONS-Zelle: " OBJEKT))))) ==> F-PAIR? In LISP-Implementationen können die Selektoren CAR und CDR auf die leere Liste angewendet werden, obwohl ihre Werte dann prinzipiell nicht definiert

216

II. Konstruktionen (Analyse und Synthese)

sind. Der Rückgabewert ist in PC Scheme NIL. Ob NIL vorliegt, ist mit dem NULL?-Konstrukt prüfbar. eval> eval>

(NULL? (NULL?

(CDR (CAR ()))) ==> #T (CAR (CDR ()))) ==> #T

Entsprechend definieren wir ein F-NULL?-Konstrukt. Ist die „leere Liste" gegeben, hat F-NULL? den Wert *F-NIL*. Dieser Wert ist ungleich NIL und wird daher vom LISP-System als „wahr" interpretiert. Liegt nicht *F-NIL* vor, dann ist der Wert von F-NULL? gleich NIL als Repräsentation von „nicht wahr". *F-NIL* übernimmt nicht die Mehrfachfunktion von NIL (Wahrheitswert-Repräsentation, „bottom-element" einer Liste). *F-NIL* dient nur als „Urbaustein" für den funktionalen Konstruktor F-CONS. eval>

(DEFINE F-NULL? (LAMBDA (OBJEKT) (COND ((AND (PROCEDURE? OBJEKT) (T NIL)))) ==>

eval>

eval>

eval>

(EQ? OBJEKT

F-NULL?

(DEFINE F-CAR (LAMBDA (OBJEKT) (COND ( F-NULL? OBJEKT) OBJEKT) ( F - P A I R ? OBJEKT) ((OBJEKT ( NIL)))) ==> F-CAR (DEFINE F CDR (LAMBDA (OBJEKT) (COND ( F-NULL? OBJEKT) OBJEKT) ( F-PAIR? OBJEKT) ((OBJEKT ( NIL)))) ==> F-CDR

*F-NIL*)) *F-NIL*)

'F-CAR)))

'F-CDR)))

(DEFINE F SET-CAR! (LAMBDA (OBJEKT WERT) (COND ( F-NULL? OBJEKT) (ERROR "Objekt ist leer! " OBJEKT) F-PAIR? OBJEKT) ((OBJEKT 'F-SET-CAR!) WERT)) NIL)))) ==> F - S E T - C A R !

èva 1> (DEFINE F SET-CDR! (LAMBDA (OBJEKT WERT) (COND ( F-NULL? OBJEKT) (ERROR "Objekt ist leer! " OBJEKT) ( F-PAIR? OBJEKT) ((OBJECT 'F-SET-CDR!) WERT)) (T NIL)))) ==> F - S E T - C D R !

Das folgende F-CONS-Beispiel zeigt den (gewollten) Nebeneffekt des Mutators F-SET-CAR!. Seine Wirkung entspricht der von SET-CAR!. eval> eval> eval> eval> eva1> eval> eval> eva1>

(DEFINE F00 (F-CONS 'A *F-NIL*)) ==> F00 (DEFINE F00 (F-CONS 'B F00)) ==> F00 (DEFINE BAZ F00) ==> BAZ (F-CAR BAZ) ==> B (F-CDR BAZ) ==> # < P R O C E D U R E F-C0NS> (F-CAR (F-CDR (F-CDR BAZ))) ==> # < P R O C E D U R E *F-NIL*> (F-SET-CAR! BAZ (F-CONS 1 *F-NIL*)) ;BAZ-Modifikation ==> # < P R O C E D U R E F-C0NS> (F-CAR F00) ==> # < P R O C E D U R E F-C0NS>

8. Abbildungsoption: Funktion mit zugeordneter Umgebung eval>

(F-CAR

(F-CAR

F00))

==>

1

eval> eval>

(F-CAR (F-CAR

(F-CDR (F-CDR

F00)) ==> A (F-CDR F 0 0 ) ) )

217

; N e b e n e f f e k t ! F00 ; auch v e r ä n d e r t ==> #

Ausgangspunkt einer (noch stärker) funktionsgeprägten Abbildung der CONSZelle können Funktionen für die Wahrheitswert „true" und "false" sein. eval> eval>

(DEFINE (DEFINE

TRUE ( L A M B D A (W F) W ) ) = = > TRUE F A L S E ( L A M B D A (W F) F ) ) = = > F A L S E

Das F-CONS-Konstrukt ist wieder eine Funktion höherer Ordnung. Ihr Rückgabewert ist wieder eine Funktion, in deren Funktionskörper die CAR- und CDRWerte als Argumente dienen. eval>

(DEFINE F-CONS ( L A M B D A (X Y ) (LAMBDA ( C ) (C X Y ) ) ) )

==>

F-CONS

Mit Hilfe der TRUE- und FALSE-Funktionen können die Selektoren als Funktionen, wie folgt, definiert werden: eval>

(DEFINE

F-CAR

(LAMBDA

(X)

eval>

(DEFINE

F-CDR

(LAMBDA

(X)

(X T R U E ) ) ) ==> F-CAR (X F A L S E ) ) ) ==> F-CDR

;TRUE-Wert=Funktion!! ;FALSE-Wert=Funktion!!

Der Wert einer F-CONS-Applikation ist eine Funktion, die wiederum von den Selektoren appliziert wird. eval> eval> eval>

( F - C D R (F-CONS 2 (F-CONS 1 0 ) ) ) = = > # (F-CAR (F-CONS 2 (F-CONS 1 0 ) ) ) ==> 2 (F-CDR (F-CDR (F-CONS 1 0 ) ) ) = = > ERROR . . . ¡ V e r s u c h , e i n n i c h t f u n k t i o n a l e s O b j e k t ; a p p l i z i e r e n : (0 # )

zu

Zum besseren Verstehen eines Selektionsvorganges, „reduzieren" wir schrittweise die LAMBDA-Konstrukte, d.h. wir setzen die Werte ihrer Argumente im Funktionskörper an die Stelle der entsprechenden LAMBDA-Variablen. Die einzelnen Reduktionsschritte trennen wir mit dem Zeichen „=". eval>

(F-CDR (F-CONS 1 0 ) ) ( F - C D R ( ( L A M B D A (X Y ) ( L A M B D A ( C ) (C X Y ) ) ) 1 ( F - C D R ( L A M B D A ( C ) (C 1 0 ) ) ) ( ( L A M B D A ( X ) (X F A L S E ) ) ( L A M B D A ( C ) (C 1 0 ) ) ) ( ( L A M B D A ( C ) (C 1 0 ) ) F A L S E ) (FALSE 1 0) ( ( L A M B D A (W F ) F) 1 0 ) ==>0

0))

II. Konstruktionen (Analyse und Synthese)

218

8.1.2 Fixpunktoperator Y Wir betrachten jetzt Funktionen, die sich selbst als Argument haben. Der sogenannte Fixpunktoperator Y ist eine solche Funktion. Zu seiner Erläuterung nehmen wir als Beispiel an, daß die Summe der numerischen Elemente einer Liste zu berechnen ist. Die Beispielliste nennen wir ZAHLUNGEN. eval>

( D E F I N E ZAHLUNGEN

'(10.00

"DUBIOS"

5 . 0 0 55.00 "DUBIOS" 2 . 0 0 8 . 0 0 ) ) ==> ZAHLUNGEN

Mit dem Iterationskonstrukt FOR-EACH und einer Hilfsvariablen AKKUMULATOR ist die Summe einfach ermittelbar: eval>

(LET

((AKKUMULATOR 0 ) ) (FOR-EACH (LAMBDA ( X ) ( I F (NUMBER? X) ( S E T ! AKKUMULATOR ( + AKKUMULATOR X ) ) ) ) ZAHLUNGEN) AKKUMULATOR) ==> 8 0 .

An Stelle des iterativen FOR-EACH-Konstruktes mit dem eingebetteten Modifikator S E T ! („Zuweisungsoperator") definieren wir eine rekursive Funktion. eval>

eval>

( D E F I N E SUMME (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) 0 ) ((NUMBER? (CAR L I S T E ) ) ( + (CAR L I S T E ) (SUMME (CDR L I S T E ) ) ) ) ( T (SUMME (CDR L I S T E ) ) ) ) ) ) ==> SUMME (SUMME ZAHLUNGEN) ==> 8 0 .

Zur Vermeidung einer globalen Funktion ist S U M M E jetzt als lokale Funktion innerhalb eines LETREC-Konstruktes definiert. eval>

(LETREC

((SUMME (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) 0 ) ((NUMBER? (CAR L I S T E ) ) ( + (CAR L I S T E ) (SUMME (CDR ( T (SUMME (CDR L I S T E ) ) ) ) ) ) ) (SUMME ZAHLUNGEN)) ==> 8 0 .

LISTE))))

Unser Ziel ist eine rekursive Lösung ohne die Nutzung des LETREC-Konstruktes. Gesucht ist ein Mechanismus, der rekursive Lösungen konstruieren kann, die nur auf dem LAMBDA-Konstrukt bzw. dem LET-Konstrukt (als dessen syntaktische Vereinfachung) basieren, und kein SET!-Konstrukt verwenden. Hier wollen wir daher nicht das LETREC-Konstrukt entsprechend Abschnitt 2.2.1 diskutieren, da dieses auf dem SET!-Konstrukt aufbaut. Ein solcher Mechanismus ist der Fixpunktoperator Y (engl.: the applicative-

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

219

order fixed point operator for functionals). Der Fixpunktoperator Y erfüllt die folgende Bedingung: ((F (Y F)) x) - ((Y F) x) Anders formuliert: ((F f ) x) = (f x) . Dabei ist f der Fixpunkt von F, d.h. F „überführt" f in f . Für unser Probfem ist das F-Konstrukt, wie nach den weiteren Ausführungen deutlich wird, wie folgt, definiert: eval>

(DEFINE F (LAMBDA (SUMME) (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) 0) ((NUMBER? (CAR L I S T E ) ) ( + ( C A R L I S T E ) (SUMME ( C D R L I S T E ) ) ) ) ( T (SUMME ( C D R L I S T E ) ) ) ) ) ) ==> F

Der Fixpunktoperator Y ist eine Funktion, die eine Funktion nimmt, die als rekursive Funktion betrachtbar ist und eine andere Funktion zurückgibt, welche die rekursive Funktion implementiert. Die Befassung mit dem Fixpunktoperator Y zwingt zum funktionalen Denken, wie der vorherstehende Satz offensichtlich demonstriert. Zum Verstehen des Fixpunktoperators entwicklen wir schrittweise eine Y-Definition (vgl. Gabriel, 1988). Dazu nutzen wir die drei Überlegungen: o Einführung einer zusätzlichen LAMBDA-Variablen zur Vermeidung von rekursiven Scheme-Konstrukten, wie LETREC oder DEFINE. o Konvertierung einer Funktion mit mehreren LAMBDA-Variablen in geschachtelte Funktionen mit einer LAMBDA-Variablen (Curryfizierung). Ziel ist, die Manipulation der (neuen) LAMBDA-Variablen für den Selbstbezug von der Manipulation der bisherigen LAMBDA-Variablen zu trennen. o Definition gleichwertiger Funktionen durch Analyse eines Konstruktes (Abstraktion). Zum (Wieder-)Einfinden in die funktionale Denkwelt betrachten wir zunächst die folgende einfache Funktion FOO. Sie hat eine Funktion als Rückgabewert. eval>

(DEFINE

FOO

e v a l > ( ( F O O 2) 3) Wert von N : = 2 Wert von M : = 3 6

(LAMBDA ( N ) ( L A M B D A (M) (WRITELN "Wert (WRITELN "Wert ( * N M ) ) ) ) ==> ==>

von N : = von M : = FOO

") ")

Wenden wir uns nun der Definition der Funktion SUMME zu und nennen sie für die folgende Erörterung vorübergehend :

220

II. Konstruktionen (Analyse und Synthese) (LET

((

(LAMBDA (COND

(

(LISTE) ((NULL? L I S T E ) 0) ( ( N U M B E R ? (CAR L I S T E ) ) ( + (CAR L I S T E ) (SUMME ( C D R L I S T E ) ) ) ) (T (SUMME (CDR L I S T E ) ) ) ) ) ) ) ZAHLUNGEN))

Im Sinne der rekursiven Problemlösungsmethode, bei der angenommen wird, daß eine Teillösung (quasi) existiert, unterstellen wir auch hier, die Funktion S U M M E wäre verfügbar (woher auch immer). Wenn die Funktion S U M M E schon (gedanklich) existiert, dann könnte sie allerdings auch über die LAMBDA-Schnittstelle dem Funktionskörper von übergeben werden. Die Funktion hätte dann zwei LAMBDA-Variablen: FUNKTION für die zu übergebende Funktion S U M M E und LISTE, die bisherige Variable. Wenn wir im Funktionskörper die übergebene Funktion aufrufen, also SUMME, dann ist zu beachten, daß diese jetzt zwei Argumente benötigt. eval>

(LET

((SUMME

(SUMME

(LAMBDA (FUNKTION L I S T E ) (COND ( ( N U L L ? L I S T E ) 0 ) ( ( N U M B E R ? (CAR L I S T E ) ) ( + (CAR L I S T E ) (FUNKTION FUNKTION (T ( F U N K T I O N F U N K T I O N SUMME Z A H L U N G E N ) ) = = > 8 0 .

(CDR (CDR

LISTE)))) LISTE)))))))

Zunächst bindet das LET-Konstrukt in seiner Umgebung das Symbol S U M M E an eine Funktion mit den beiden LAMBDA-Variablen FUNKTION und LISTE. Diese Funktion hat keinen Selbstbezug zum Symbol SUMME. In ihrem Funktionskörper wird die LAMBDA-Variable FUNKTION einerseits appliziert und andererseits als Argument genutzt. Die Besonderheit ist das Zusammenfallen der Punkte "applizierte Funktion" und „Argument". Wird die LAMBDA-Variable FUNKTION durch die Notation als erstes Element einer Liste als Funktion appliziert, dann ist sie selbst ihr erstes Argument. Die Technik, sich selbst als Argument zu nutzen, ergibt den rekursiven Bezug. Etwas leger formuliert: Wir „überlisten" das LET-Konstrukt, indem wir die Rekursivität „durch die Hintertür" als Parameterübergabe realisieren. Die zusätzliche LAMBDA-Variable für die Selbstübergabe wollen wir von den anderen LAMBDA-Variablen trennen, mit dem Ziel, den SelbstübergabeMechanismus isoliert betrachten zu können. Für diese Trennung nutzen wir das sogenannte Curryfizieren von Funktionen. H. Curry hat nachgewiesen, daß zu jeder Funktion höherer Ordnung F eine Funktion F existiert, für die gilt (vgl. Curry u.a., 1958): (F X}

x2

x3

...

xn)

=

(...(((Fc

x^)

x2)

x3)

...

xn)

221

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

Das folgende Beispiel zeigt das Curryfizieren (engl.: currying) anhand von drei LAMBDA-Variablen: eval> eval>

(DEFINE (F00 'A

eval>

(DEFINE CURRYFIZIERTE-F00 (LAMBDA ( X ) (LAMBDA ( Y ) (LAMBDA ( Z ) (LIST X Y Z ) ) ) ) ) ==> CURRYFIZIERTE-F00 ( ( ( C U R R Y F I Z I E R T E - F 0 0 ' A ) ' B ) ' C ) = = > (A B C )

eval>

F 0 0 ( L A M B D A (X Y Z ) ' B ' C ) = = > (A B C)

(LIST

X Y Z)))

==>

F00

Bezogen auf die Definition von SUMME erhalten wir: eval>

(LET

((SUMME (LAMBDA ( F U N K T I O N ) (LAMBDA ( L I S T E ) (COND ( ( N U L L ? L I S T E ) 0 ) ( { N U M B E R ? (CAR L I S T E ) ) ( + (CAR L I S T E ) ( ( F U N K T I O N FUNKTION) (CDR (T ( ( F U N K T I O N F U N K T I O N ) ( C D R ( ( S U M M E SUMME) Z A H L U N G E N ) ) = = > 8 0 .

LISTE)))) LISTE))))))))

Das Curryfizieren hat eine Hierarchie von zwei LAMBDA-Konstrukten bewirkt und die LAMBDA-Variable FUNKTION auf die obere Ebene gehoben. Die Selbstübergabe (FUNKTION FUNKTION) ist jedoch noch tief in dem Konstrukt (LAMBDA ( L I S T E ) . . . ) enthalten. Der nächste Schritt gilt dem Herauslösen von (FUNKTION FUNKTION). Dazu definieren wir eine lokale Funktion SUM mit den beiden LAMBDA-Variablen: FKT und LST. Wir übergeben SUM unseren Selbstbezug (FUNKTION FUNKTION) als erstes Argument. eval>

(LET

((SUMME (LAMBDA (FUNKTION) (LAMBDA ( L I S T E ) ( L E T ((SUM (LAMBDA (FKT L S T ) (COND ( ( N U L L ? L S T ) 0 ) ( ( N U M B E R ? (CAR L S T ) ) ( + (CAR L S T ) (FKT (CDR (T ( F K T ( C D R L S T ) ) ) ) ) ) ) (SUM ( F U N K T I O N FUNKTION) LISTE)))))) ( ( S U M M E SUMME) Z A H L U N G E N ) ) = = > 8 0 .

LST))))

Da die lokale Funktion SUM hat zwei LAMBDA-Variablen (FKT und LST) hat, Curryfizieren wir SUM. Dabei ist zu beachten, daß auch der SUM-Aufruf anzupassen ist.

222 eval>

II. Konstruktionen (Analyse und Synthese) (LET

((SUMME (LAMBDA ( F U N K T I O N ) (LAMBDA ( L I S T E ) ( L E T ((SUM (LAMBDA ( F K T ) (LAMBDA ( L S T ) (COND ( ( N U L L ? L S T ) 0) ((NUMBER? (CAR L S T ) ) (+ (CAR L S T ) ( F K T (CDR L S T ) ) ) ) (T ( F K T (CDR L S T ) ) ) ) ) ) ) ) ((SUM (FUNKTION F U N K T I O N ) ) LISTE)))))) ( ( S U M M E SUMME) Z A H L U N G E N ) ) ==> 8 0 .

Analysiert man die bisher erreichte Lösung, so zeigt sich, daß es keinen Grund gibt, die lokale Funktion SUM auf einer so tiefen Ebene zu definieren. Wir können sie z.B. als eine globale Funktion SUM definieren, so daß sie der obigen F-Definition entspricht. Unsere Lösung besteht dann aus der SUM-Definition und dem Rest des LET-Konstruktes: eval>

(DEFINE

SUM ( L A M B D A ( F K T ) (LAMBDA ( L S T ) (COND ( ( N U L L ? L S T ) 0) ((NUMBER? (CAR L S T ) ) (+ (CAR L S T ) ( F K T (CDR L S T ) ) ) ) ( T ( F K T ( C D R L S T ) ) ) ) ) ) ) ==> SUM ((SUMME (LAMBDA ( F U N K T I O N ) (LAMBDA ( L I S T E ) ((SUM (FUNKTION F U N K T I O N ) ) LISTE))))) ( ( S U M M E SUMME) Z A H L U N G E N ) ) ==> 8 0 .

eval>

(LET

Die Analyse dieser Lösung ergibt: Für eine allgemeine Anwendung ist es ungünstig, daß in der lokalen Funktion SUMME die Funktion SUM explizit aufgerufen wird. Um diesen Mangel zu beheben, bauen wir die Definition von SUMME in eine Funktion YO ein, deren LAMBDA-Variable FUN dann an SUM gebunden wird, so daß FUN appliziert werden kann. Der explizite SUMAufruf wird durch einen FUN-Aufruf ersetzt. Bei der YO-Definition sorgen wir dafür, daß ihr Rückgabewert (SUMME SUMME) ist. Die Lösung hat dann folgende Struktur: (LET

C C S (YO SUM))) (S Z A H L U N G E N ) )

und YO folgende Definition: eval>

(DEFINE

YO

(LAMBDA ( F U N ) ( L E T ((SUMME (LAMBDA ( F U N K T I O N ) (LAMBDA ( L I S T E ) ((FUN (FUNKTION FUNKTION)) (SUMME S U M M E ) ) ) ) ==> YO

LISTE)))))

Die so abstrahierte Definition YO stellt den Fixpunktoperator Y dar. Für seine allgemeine Anwendung, benennen wir die LAMBDA-Variablen von YO um,

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

223

und zwar: FUN in F, SUMME in G, FUNKTION in H und LISTE in X. Damit erhalten wir das folgende Y-Konstrukt: eval> (DEFINE Y (LAMBDA (F) (LET ((G (LAMBDA (H) (LAMBDA (X) ((F (H H)) X))))) (G G)))) ==> Y Das Erläuterungsbeispiel, die Summe der numerischen Elemente einer Liste, ergibt mit dem Fixpunktoperator Y und der eingesetzten SUM-Definition damit folgende Lösung: eval> (LET ((S (Y (LAMBDA (FKT) (LAMBDA (LST) (COND ((NULL? LST) 0) ((NUMBER? (CAR LST)) (+ (CAR LST) (FKT (CDR LST)))) (T (FKT (CDR L S T ) ) ) ) ) ) ) ) ) (S ZAHLUNGEN)) ==> 80. Diese Y-Definition hat die oben geforderte Eigenschaft eines Fixpunktoperators. Y erfüllt die folgende Gleichung: eval> (EQUAL? ((F (Y F)) ZAHLUNGEN) ((Y F) ZAHLUNGEN)) ==> #T Der bisherige Y-Operator ist definiert, um eine rekursive Funktion einzurichten. Damit eine Erweiterung auf zwei gegenseitig rekursive Funktionen möglich wird, ändern wir die Y-Definition, wie folgt: eval> (DEFINE Y (LAMBDA (F) (LET C CG (LAMBDA (H R) (LAMBDA (X) ((R (H H F)) X))))) (G G F)))) ==> Y Es wurde eine zusätzliche LAMBDA-Variable R eingeführt, damit F stets als Argument verwendet wird. Diese Y-Definition hat denselben Effekt. Allerdings hat G eine zusätzliche LAMBDA-Variable. So ist es möglich, daß G mit mehr als einer Funktion auf einmal umgehen kann. Zum leichteren Verstehen benennen wir in Y die Funktionen um, und zwar H in G: eval> (DEFINE Y (LAMBDA (F) (LET ((G (LAMBDA (G R) (LAMBDA (X) (CR (G G F)) X))))) (G G F)))) ==> Y

224 eval>

II. Konstruktionen (Analyse und Synthese) (DEFINE

Y-2

(LAMBDA (F (LET ((G

H) ( L A M B D A (G R) (LAMBDA (N) ( ( R (G G F) (G G F ) ) ) ) = = > Y - 2

(G G H ) )

N)))))

Ein einfaches Beispiel für die Y-2-Nutzung ist die Prüfung, ob eine vorgegebene Zahl gerade oder ungerade ist (vgl. Gabriel, 1988). eval>

((Y-2

( L A M B D A ( F H) (LAMBDA ( N ) ( L A M B D A ( F H) (LAMBDA (N)

(IF

(


(LETREC ( ( F (LAMBDA (H ( L A M B D A

(N) (N)

(IF (IF

(< (
" U n g e r a d e "

8.1.3 Funktion ALTERNATE Mit einer abwechselnden Abarbeitung der Teilaufgaben zweier Prozesse zeigen wir erneut die Möglichkeit, die Umgebung einer Funktion als Repräsentation von lokalen Variablen zu nutzen, die selbst wiederum Funktionen darstellen. Ein Prozeß ist als Kellerspeicher (engl.: Stack) abgebidelt. Er hat beim Aufruf die jeweils als nächste abzuarbeitende Teilaufgabe als Rückgabewert. Der Stack ist eine Funktion, deren (Definitions-)Umgebung mit dem SET'.-Konstrukt modifiziert wird. Zur Konstruktion dieser Funktion und ihrer Umgebung dient das folgende PROCESS-STACK-Konstrukt: eval>

(DEFINE PROCESS-STACK ( L A M B D A ( T A S K_ L I S T ) (LAMBDA ( ) (COND ( ( N U L L ? T A S K _ L I S T ) N I L ) (T ( B E G I N O (CAR T A S K _ L I S T ) ( S E T ! T A S K _ L I S T (CDR TASK_ L I S T ) ) ) ) ) ) ) ) ==> PROCESS-STACK

In PC Scheme können wir die Symbol-Wert-Assoziationen der Definitionshülle mit dem ENVIRONMENT-BINDINGS-Konstrukt ausgeben. eval> eval>

(CLOSURE? (PROCESS-STACK ' ( T A S K - A TASK-B T A S K - C ) ) ) ==> (ENVIRONMENT? (PROCESS-STACK ' ( T A S K - A TASK-B T A S K - C ) ) ) = = >

eval>

(ENVIRONMENT-BINDINGS (PROCESS-STACK '(TASK-A TASK-B T A S K - C ) ) ) ==> ((TASK_LIST TASK-A TASK-B

#T ( )

TASK-C))

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

225

Das Abwechseln zwischen den beiden Prozessen ist ebenfalls als Modifikation der Umgebung einer Funktion ALTERNATE abgebildet. Wird diese Funktion ALTERNATE angewendet, dann entsteht eine Funktion, deren Umgebung die lokalen Variablen E X E C U T E , PROCESS und WAIT_ PROCESS aufweist. Das Vertauschen der Werte dieser lokalen Variablen simuliert das Alternieren. eval>

( D E F I N E ALTERNATE (LAMBDA ( E X E C U T E _ P R O C E S S W A I T _ P R O C E S S ) (LAMBDA ( ) (LET ( ( A C T I V EXECUTE.PROCESS)) (SET! EXECUTE_PROCESS WAIT.PROCESS) (SET! WAIT_PROCESS ACTIV) ( A C T I V ) ) ) ) ) ==> ALTERNATE

Als Beispiel dient die globale Variable PROZESSWECHSEL, wobei als Startwert E X E C U T E . PROCESS an einen Stack mit den Teilaufgaben TASK-A, T A S K - B und TASK-C gebunden wird. WAIT_ PROCESS ist zu Beginn an einen Stack mit den Teilaufgaben TASK-1, TASK-2, TASK-3 und TASK-4 gebunden. PROZESSWECHSEL ist eine Funktion, in deren Umgebung die lokalen Variablen E X E C U T E . PROCESS und WAIT_ PROCESS jeweils an Funktionen gebunden sind, die einen Stack abbilden. eval>

( D E F I N E PROZESSWECHSEL (ALTERNATE (PROCESS-STACK '(TASK-A (PROCESS-STACK ' ( T A S K - 1

TASK-B TASK-2

TASK-C)) TASK-3 T A S K - 4 ) ) ) ) ==> PROZESSWECHSEL

Die Werte in den geschachtelten Umgebungen werden durch die Anwendung des ENVIRONMENT-BINDINGS-Konstruktes in Verbindung mit dem AListen-Selektor ASSOC deutlich: eval>

(ENVIRONMENT-BINDINGS PROZESSWECHSEL) ==> ((EXECUTE_PROCESS . #) (WAIT_PROCESS . #

(ENVIRONMENT-BINDINGS

(CDR

(ENVIRONMENT-BINDINGS

(ASSOC

'EXECUTE_PROCESS

PROZESSWECHSEL)))) ((TASK_LIST

TASK-A

==> TASK-B

TASK-C))

Die obige PRINT-Repräsentation # < P R O C E D U R E PROCESS-STACK> führt leicht zu Mißverständnissen, weil sie für zwei unterschiedliche Fälle verwendet wird, wie die folgende FOO- und BAZ-Definitionen zeigen.

226

II. Konstruktionen (Analyse und Synthese)

eval> eval>

( D E F I N E F00 P R O C E S S - S T A C K ) = = > F00 ( D E F I N E BAZ ( P R O C E S S - S T A C K ' ( T A S K - A

eval> eval>

F00 = = > # #

;; " P r e t t y - P r i n t " - K o n s t r u k t (PP F 0 0 ) = = > (LAMBDA (TAS K_ L I S T ) (LAMBDA ( ) (COND ( ( N U L L ? T A S K _ L I S T ) N I L ) (T ( B E G I N O (CAR T A S K _ L I S T ) ( S E T ! TASK_ L I ST (CDR T A S K _ L I S T ) ) ) ) ) ) )

eval>

(PP BAZ) = = > (LAMBDA ( ) (COND ( ( N U L L ? TASK_ L I S T ) N I L ) (T (BEGINO (CAR T A S K _ L I S T ) ( S E T ! TASK_ L I ST (CDR T A S K _ L I S T ) ) ) ) ) )

PROCESS-STACK> PR0CESS-STACK>

TASK-B

TASK-C))) = = > BAZ ;LAMBDA-Abstraktion ;Appli kation

Zur Verdeutlichung der Abarbeitungsschritte definieren wir die folgende Ausgabefunktion: eval>

(DEFINE ABARBEITUNGS-SCHRITTE (LAMBDA (N) (LETREC ( ( S T E P (LAMBDA (M) (COND ( ( > M N) ' F E R T I G ) (T (WRITELN M " . S c h r i t t : (PROZESSWECHSEL)) (STEP (1+ M ) ) ) ) ) ) ) (STEP 1 ) ) ) ) ==> ABARBEITUNGS-SCHRITTE

e v a l > (ABARBEITUNGS-SCHRITTE 1. S c h r i t t : T A S K - A 2. S c h r i t t : T A S K - 1 3. S c h r i t t : TASK-B 4. S c h r i t t : TASK-2 5. S c h r i t t : T A S K - C 6. S c h r i t t : T A S K - 3 7. S c h r i t t : ( ) FERTIG

7)

"

==>

8.2 Kontrollstruktur: Continuation Kennzeichnend für funktionsgeprägte Konstruktionen ist die Komposition von Funktionen (= evaluierte LAMBDA-Konstrukte). Die EVAL-Regeln legen ihre Abarbeitungs-Reihenfolge („Kontrollstruktur", vgl. Abschnitt 2.2) fest, d.h sie bestimmen, welche Funktion wann auszuwerten ist. Kern der Kontrollstruktur ist die Sequenz: 1. Bestimmung der Werte der Argumente und 2. Ermittlung des Funktionswertes mit den übernommenen Werten der Argumente (vgl. EVAL-Regel 2; vgl. Abschnitt 1.2).

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

227

Beispielsweise hat die Komposition (F (G (H FOO))) die folgende Kontrollstruktur: S^ Wert von F ermitteln. Da dieser Wert eine Funktion ist, ist zunächst sein Argument (G (H FOO)) zu evaluieren, daher: S 2 : Wert von G ermitteln. Da dieser Wert eine Funktion ist, ist zunächst sein Argument (H FOO) zu evaluieren, daher: S 3 : Wert von H ermitteln. Da dieser Wert eine Funktion ist, ist zunächst sein Argument FOO zu evaluieren, daher: S 4 : Wert von FOO ermitteln. Dieser sei V. S5: V in H Ubernehmen und Funktionswert H berechnen. Dieser Wert sei W. Sfi: W in G übernehmen und Funktionswert G berechnen. Dieser Wert sei X. S ? : X in F übernehmen und Funktionswert F berechnen. Dieser Wert sei Y . S g : Y ist der Wert der Komposition. Bei jedem Schritt S. der Folge S ( bis S g steht fest, welcher Schritt S ist, d.h die Fortsetzung (engl.: continuation) der Abarbeitung ist bekannt. Befinden wir uns beispielsweise beim Schritt S 5 , dann besteht die zukünftige Abarbeitung in der Applikation der Funktionen G und F. Dieses „Kontrollwissen" über die Zukunft hätte man gern beim Abarbeiten von S 5 direkt verfügbar. Man könnte dann z.B. entscheiden, ob es sich lohnt die „Zukunft" überhaupt abzuarbeiten. Ist das „Kontrollwissen" als Wert einer Variable speicherbar, dann kann man die Abarbeitung später fortsetzen. Außerdem ist sie dann beliebig oft wiederholbar. Scheme stellt mit dem Konstrukt CALL-WITH-CURRENT-CONTINUATION, kurz: CALL/CC, einen entsprechenden Mechanismus bereit. Als Variable, die an die „Zukunft" gebunden ist, dient die LAMBDA-Variable des LAMBDA-Konstruktes, das mit CALL/CC appliziert wird. Die Funktionsweise des CALL/CC-Konstruktes erläutern wir anhand der obigen Komposition (F (G (H FOO))). Darauf aufbauend wird gezeigt, daß das CALL/CC-Konstrukt als eine allgemeine Kontrollstruktur betrachtbar ist, die beliebige Sprünge in die „Zukunft" und „Vergangenheit" einer Abarbeitung ermöglicht. Mit dem CALL/CC-Konstrukt ist daher das klassische LISP-Srung-Paar C A T C H und THROW leicht abbildbar (vgl. Abschnitt 8.6). Vorab definieren wir für unsere Kompostion (F (G (H FOO))) ein simples Beispiel, wie folgt: eval>

(DEFINE

eval > ( D E F I N E

eval>

(DEFINE

FOO

7) = = >

FOO

H ( L A M B D A (N) (WRITELN "Funktion (1+ N ) ) ) = = > H

H:

" N)

G ( L A M B D A (N) (WRITELN "Funktion (1+ N))) = = > G

G:

" N)

II. Konstruktionen (Analyse und Synthese)

228

F (LAMBDA ( N ) (WRITELN "Funktion ( 1 + N ) ) ) ==> F

eval>

(DEFINE

eval>

( F ( G (H F 0 0 ) ) ) F u n k t i o n H: 7 Funktion G Funktion F

F:

10

Die „Zukunft", gesehen vom Zeitpunkt der Abarbeitung von H aus, speichern wir als globale Variable *KONTROLLWISSEN-BEI-H*. Diese Variable erhält den Wert über das CALL/CC-Konstrukt mit Hilfe des SET!-Konstruktes. Bei unserem CALL/CC-Konstrukt ist die „Zukunft" an die LAMBDA-Variable FORTSETZUNG gebunden, so daß wir sie beim Abarbeiten von CALL/CC an die globale Variable binden können. eval > ( D E F I N E EVAL>

*K0NTR0LLWISSEN-BEI-H*

()) ==>

(DEFINE H (LAMBDA (N) (CALL/CC (LAMBDA ( F O R T S E T Z U N G ) (SET! *K0NTR0LLWISSEN-BEI-H* ( W R I T E L N " F u n k t i o n H : " N) ( 1 + N ) ) ) ) ) ==> H Anwendung

*K0NTR0LLWISSEN-BEI-H*

FORTSETZUNG)

eval>

; ; E n t s p r i c h t der obigen ( F ( G (H F 0 0 ) ) ) ==> F u n k t i o n H: 7 Funktion G Funktion F 10

ohne

CALL/CC

eval>

*KONTROLLWISSEN-BEI-H* Der D a t e n t y p hat k e i n e aussage==> # < C 0 N T I N U A T I 0 N > fähige externe Darstellung, daher diese E r s a t z d a r s t e l l u n g analog z u r #

Die gespeicherte # kann nun erneut ausgeführt werden, d.h. wir setzten wieder bei H auf. Der Wert von H, also das Resultat der bisherigen Verarbeitung, ist als Argument angebbar. eval>

(*KONTROLLWISSEN-BEI-H* F u n k t i o n G: 8 Funktion F: 9 10

8)

==>

Die Continuation *KONTROLLWISSEN-BEI-H* kann mit einem anderen Wert als 8 appliziert werden, d.h die ausstehende Berechnung ist von der Stelle

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

229

H mit einem neuen Wert durchführbar. Wir springen quasi in die Berechnung mit einem neuen Startwert zurück. eval>

(*KONTROLLWISSEN-BEI-H* F u n k t i o n G: 13 F u n k t i o n F: 14 15

13)

==>

Der Contiunation-Mechanismus ermöglicht einerseits Sprünge aus einer Berechnung heraus, andererseits Sprünge in eine Berechnung hinein. Etwas salopp formuliert: Berechnungen sind jederzeit einfrierbar und jederzeit auftaubar. Legen wir eine Berechnung auf Eis, dann sind die schon vollzogenen Bindungen von Variablen miteinzufrieren. Erst die korrekte Behandlung dieser aktuellen Bindungen macht den Continuation-Mechanismus zu einer nützlichen Kontrollstruktur. Das einfache Heraus- und Hereinspringen in eine Folge von Anweisungen ermöglicht ein GO-TO-Konstrukt, das viele Programmiersprache bereitstellen. Davon zu unterscheiden ist der Rücksprung mit einer Aktivierung einer eingefrorenen, vormals aktuellen Umgebung. Wir verdeutlichen diese Eigenschaft des CALL/CC-Konstruktes anhand des folgenden Beispiels. Es prüft, ob in einer Liste von Zahlen eine negative Zahl vorkommt. Zur Iteration über die Liste nutzen wir das MAP-Konstrukt, wie folgt: eval>

(MAP (LAMBDA ( X ) ( I F •(1 2 -3 4 - 5 ) ==> -3 -5

(()

() ()

()

( > = 0 X)

(WRITELN

X)))

())

Dieses MAP-Konstrukt notieren wir in geschachtelte LAMBDA-Konstrukte, um Bindungswert innerhalb und außerhalb des MAP-Konstruktes zeigen zu können. eval>

eval>

( D E F I N E F00 (LAMBDA (N) (LET ( ( V A R N ) ) ( S E T ! VAR ( * 2 N ) ) (LAMBDA ( L ) (MAP (LAMBDA ( X ) ( I F ( > = 0 X) (WRITELN X ) ) ) (WRITELN " M A P - V o l 1 z u g " ) (WRITELN " 2 . S c h r i t t m i t B i n d u n g e n " " A u s s e n : " VAR " I n n e n : " L) (WRITELN " n . S c h r i t t " ) ) ) ) ) = = > F00 ( ( F 0 0 6) ' ( 1 2 - 3 4 - 5 ) ) = = > -3 -5 MAP-Vol1zug 2. S c h r i t t m i t B i n d u n g e n A u s s e n : n. S c h r i t t ()

12 I n n e n :

( 1 2 - 3

L)

4

-5)

230 eval>

II. Konstruktionen (Analyse und Synthese) ( ( F 0 0 6) ' ( 1 2 3 4 5 ) ) = = > MAP-Vol1zug 2. S c h r i t t m i t B i n d u n g e n A u s s e n : n. S c h r i t t ()

12 I n n e n :

(12

3 4 5)

Bei der ersten negativen Zahl sei die Analyse der Zahlenfolge zu beenden. Ist X negativ, dann arbeiten wir im MAP-Konstrukt die Fortsetzung des MAP-Konstruktes ab. Damit wir später von dieser Situation erneut die Abarbeitung starten können, wird sie an die globale Variable *KONSTRUKTIONS-REST* gebunden. Dazu applizieren wir das MAP-Konstrukt nicht direkt, sondern über das CALL/CC-Konstrukt. eval>

( D E F I N E F00 (LAMBDA (N) (LET ((VAR N)) ( S E T ! VAR ( * 2 N ) ) (LAMBDA ( L ) (CALL/CC (LAMBDA (FORTSETZUNG) (MAP (LAMBDA ( X ) ( I F ( > = 0 X) (BEGIN (WRITELN X) ( S E T ! *KONSTRUKT I O N S - R E S T * FORSETZUNG) ; ; DUMMY w e i l d i e S c h n i t t s t e l l e ;; e i n Argument e r f o r d e r t (FORTSETZUNG ' D U M M Y ) ) ) )

L) (WRITELN (SET!

"Vollzug")

KONSTRUKT-REST

(WRITELN

"2.

Schritt

"Aussen: (WRITELN

"n.

(DEFINE *K0NSTRUKTI0NS-REST*

eval>

((FOO 6)

2-3

4 -5)

" VAR "

Schritt")))))

eval>

'(1

NIL))) mit Bindungen

NIL)

Innen:

"

" L)

= = > FOO

= = > *KONSTRUKT I O N S - R E S T *

==>

-3 2.

Schritt

n.

Schritt

mit

Bindungen Aussen:

12 I n n e n :

( 1 2 - 3

4

-5)

() An die LAMBDA-Variable FORTSETZUNG ist die ausstehende Abarbeitung der beiden Konstrukte (WRITELN „2. Schritt mit Bindungen " "Aussen: " VAR „ Innen: " L) und (WRITELN „n. Schritt") incl. ihrer zugehörenden Umgebung gebunden, so daß VAR und L ihre bisher aktuellen Werte haben. Da diese „Zukunft" als * K O N S T R U K T I O N S - R E S T * gespeichert ist, können wir

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

231

sie erneut ausführen. Die Ausgabe von VAR und L zeigt wieder diese Werte, selbst wenn * KONSTRUKTIONS-REST* in einer entsprechend geänderten Umgebung ausgeführt wird. eval > ( CONTI NUATION? * KONSTRUKTION- REST*) ==> T eval> (*KONSTRUKTIONS-REST* 'DUMMY) ==> 2. S c h r i t t mit Bindungen Aussen: 12 Innen: ( 1 2 - 3 4 -5) n. S c h r i t t () eval> (LET ((VAR 7) (L '(A B C D))) (*K0NSTRUKTI0NS-REST* 'DUMMY)) ==> 2. S c h r i t t mit Bindungen Aussen: 12 Innen: ( 1 2 - 3 4 -5) n. S c h r i t t () Enthält die Folge keine negativen Zahlen, dann entspricht die FOO-Definition mit CALL/CC-Konstrukt der ursprünglichen Fassung. eval> ((F00 2) ' ( 1 2 3)) ==> MAP-Vol1zug 2. S c h r i t t mit Bindungen Aussen: 4 Innen: (1 2 3) n. S c h r i t t () eval> (CONTINUATION? *KONSTRUKT IONS-REST*) ==> () Der Continuation-Mechanismus erzeugt „Einheiten" im Sinne von "first-classObjekten" (vgl. Abschnitt 2.2). Sie sind daher auch als Argument einsetzbar. Wir können eine Continuation mit sich selbst als ein Argument aufrufen. Einen solchen Fall zeigt das folgende Konstrukt SUMME-M->N. Es ermittelt die Summe der Integerzahlen von der unteren Grenze M bis zur oberen Grenze N. Zum Verständnis dieser Selbstübergabe bei Continuations diskutieren wir vorab folgendes einfache Beispiele: eval> (DEFINE F00 (LIST (CALL/CC (LAMBDA (-C-) #T)))) ==> F00 eval> F00 ==> (#T) Beim Auswerten dieses CALL/CC-Konstruktes sind an die LAMBDA-Variable -C- die zu diesem Zeitpunkt noch ausstehenden Abarbeitungsschritte gebunden. Es sind die Schritte: Ausführung von LIST, Bindung von FOO an den Wert von LIST sowie Rückgabe des Symbols FOO als Wert von DEFINE. Nach dem Auswerten hat das CALL/CC-Konstrukt den Wert #T. Die Bindung von -C- ist wieder aufgelöst. Sie wurde hier nicht genutzt. Wir haben eine Situation, als wäre folgende Formulierung auszuwerten:

232

II. Konstruktionen (Analyse und Synthese)

eval> (DEFINE F00 (LIST #T)) ==> F00. In der folgenden Formulierung nutzen wir die Bindung von -C-. eval> (DEFINE F00 (LIST (CALL/CC (LAMBDA (-C-) - C - ) ) ) ) ==> F00 Der Rückgabewert des CALL/CC-Konstruktes ist der Wert von -C-, also die noch ausstehende Abarbeitungsschritte in Form einer Continuation. Mit dieser Continuation bildet LIST eine Liste und DEFINE bindet FOO an diese Liste und gibt FOO zurück. eval> FOO ==> (#) Wir greifen auf diese Continuation zurück und veranlassen die Ausführung der zunächst nicht vollzogenen Abarbeitungsschritte. eval> (CAR FOO) ==> # eval> ((CAR FOO) #T) ==> FOO eval> FOO ==> (#T) Es sei die Summe einer Integerzahlenfolge mit den Grenzwerten M und N zu bestimmen. Die Lösung bedingt die Abbildung einer Wiederholung. Eine solche Wiederholung ist als Rekursion realisierbar. Die Rekursion können wir simulieren, indem wir einer Funktion sich selbst als Argument übergeben. Diese Technik haben wir beim Fixpunktoperator Y genutzt (vgl. Abschnitt 8.1.2). Jetzt übergeben wir einer Continuation sich selbst als Argument. Anders formuliert: Die Continuation repräsentiert die Zukunft, d.h. die (noch) abzuwickelnden Schritte. Ihr Argument repräsentiert den Startwert dafür, d.h. den Wert der vollzogenen Schritte („Vergangenheit"). eval> (DEFINE SUMME-M->N (LAMBDA (M N) ;; Fal1unterscheidüngen 1 (COND ((< M N) (LET* ((SUMME 0) (VERARBEITUNG (CALL/CC (LAMBDA (-C-) - C - ) ) ) ) ;; Fal1unterscheidüngen 2 (COND ((= NM) (+ M SUMME)) (T (SET! SUMME (+ N SUMME)) (SET! N (-1+ N)) (WRITELN VERARBEITUNG " N: " N " SUMME : " SUMME (VERARBEITUNG VERARBEITUNG))))) (T (WRITELN "Von-Wert: " M " nicht groesser bis-Wert: " N)) ))) ==> SUMME-M->N

8. Abbildungsoption: Funktion mit zugeordneter Umgebung eval>

( S U M M E - M - > N 2 5) ==> # < C 0 N T I N U A T I 0 N > N : 4 SUMME # < C 0 N T I N U A T I 0 N > N : 3 SUMME # < C 0 N T I N U A T I 0 N > N : 2 SUMME 14

: : :

233

5 9 12

Zum Verstehen des Konstruktes SUMME-M->N ist die Bindung der L A M B DA-Variablen -C- bedeutsam. Ihr Wert repräsentiert die ausstehenden Abarbeitungsschritte, die das COND-Konstrukt (Fallunterscheidungen 2) definiert. Aufgrund des LET*-Konstruktes gehört die Bindung der lokalen Variablen S U M M E nicht zu den offenen Arbeitsschritten zum Zeitpunkt der Bindung von -C-. Definiert man SUMME-M->N allerdings mit LET, dann umfaßt die Continuation -C- die Bindung von S U M M E an den Wert 0. Man erhält damit das folgende, falsche Ergebnis: eval>

;; Mit LET s t a t t mit ( S U M M E - M - > N 2 5) ==> # < C 0 N T I N U A T I 0 N > N: 4 # < C 0 N T I N U A T I 0 N > N: 3 # < C 0 N T I N U A T I 0 N > N: 2 2

LET* SUMME SUMME SUMME

definiert : : :

5 4 3

8.3 Syntaxverbesserung durch Makros Das Makro ist ein Konstruktionsmittel zur Verbesserung der Syntax. Der Begriff „Makro" entstand im Rahmen der maschinennahen (Assembler-)Programmierung. Kommen Zeilen z.B. Anweisungen, Befehle oder Deklarationen in einer bestimmten Reihenfolge mehrmals vor, so ist es zweckmäßig, diese „Einheit" eindeutig und mnemotechnisch geschickt zu benennen. Im Quellcodetext wird dann an den einzelnen Stellen nur der eindeutige Bezeichner notiert. Makrobefehle verkürzen den Text wesentlich. Erst bei der Interpretation bzw. Compilation werden Makros aufgelöst, d.h. der jeweils ersetzte Text regeneriert. Diese sogenannte Makroexpansion ist eine rein textuelle Umformung. In LISP sind zwei Arten von Makros zu unterscheiden: („normale") Makros und READ-Makros. Makros expandieren in der EVAL-Phase. READ-Makros expandieren in der READ-Phase des READ-EVAL-PRINT-Zyklus. Das Hochkomma als Kurzschreibweise für das QUOTE-Konstrukt (vgl. Abschnitt 1.3) ist eines von zahlreichen eingebauten READ-Makros. In manchen LISP-Systemen (z.B. in Common LISP oder TLC-LISP) kann der Benutzer selbst READ-Makros definieren. Wir konzentrieren uns im folgenden auf die allgemein verfügbaren READ-Makros QUASIQUOTE (Kurzzeichen: ' ) , UNQUOTE (Kurzzeichen: , ) und UNQUOTE-SPLICING (Kurzzeichen: @ ). Als Beispiel für die Verbesserung der Übersichtlichkeit durch READ-Makros dient das Erweitern oder Modifizieren einer bestehenden Umgebung im Rahmen einer Kontenverwaltung.

234

II. Konstruktionen (Analyse und Synthese)

Wir definieren eine Umgebung KONTEN-MANAGEMENT mit dem THE-ENVIRONMENT-Konstrukt (vgl. Abschnitt 1.4.2; Näheres vgl. Abschnitt 8.4). eval> eval>

(DEFINE KONTEN-MANAGEMENT ((LAMBDA O ( T H E - E N V I R O N M E N T ) ) ) ) ==> K O N T E N - M A N A G E M E N T ==> # < E N V I R 0 N M E N T >

KONTEN-MANAGEMENT

Die Umgebung KONTEN-MANAGEMENT ergänzen wir um die Variablen FOO und BAZ. eval> eval> eval> eval>

( E V A L ' ( D E F I N E FOO ' ( + 1 2 ) ) K O N T E N - M A N A G E M E N T ) ==> ( E V A L ' ( D E F I N E BAZ FOO) K O N T E N - M A N A G E M E N T ) ==> BAZ ( A C C E S S FOO K O N T E N - M A N A G E M E N T ) ==> (+ 1 2) ( A C C E S S BAZ K O N T E N - M A N A G E M E N T ) ==> (+ 1 2)

FOO

Ist ein Teil des ersten Argumentes von EVAL jedoch zu evaluieren, hier (+ 1 2), dann ist mit Hilfe des LIST-Konstruktes erst ein auswertungsfahiges Argument zu konstruieren. eval>

(EVAL

eval>

(EVAL

'(LIST

'DEFINE

'BAZ

FOO)

KONTEN-MANAGEMENT) ==> ( D E F I N E BAZ (+ ( E V A L ' ( L I S T ' D E F I N E BAZ FOO) KONTEN-MANAGEMENT) K O N T E N - M A N A G E M E N T ) ==> BAZ

1

2)

oder eval> eval> eval>

(EVAL

(LIST 'DEFINE 'BAZ (EVAL 'FOO KONTEN-MANAGEMENT)) K O N T E N - M A N A G E M E N T ) ==> BAZ ( A C C E S S FOO K O N T E N - M A N A G E M E N T ) ==> ( + 1 2) ( A C C E S S BAZ K O N T E N - M A N A G E M E N T ) ==> 3

Bei einem umfangreicheren Argument wirken die dann erforderlichen vielen LIST und Q U O T E Formulierungen wenig übersichtlich. Eine syntaktische Vereinfachung bietet Q U A S I Q U O T E in Verbindung mit dem UNQUOTE-Konstrukt. Die Kurzschreibweise für das QUASIQUOTE-Konstrukt ist das Backquotezeichen '. Die Kurzschreibweise für das UNQUOTE-Konstrukt ist das Komma. eval> eval>

(EVAL

' ( D E F I N E BAZ . ( E V A L ' F O O K O N T E N - M A N A G E M E N T ) ) K O N T E N - M A N A G E M E N T ) ==> BAZ ( A C C E S S BAZ K O N T E N - M A N A G E M E N T ) ==> 3

Innerhalb des QUASIQUOTE-Konstruktes hebt ein UNQUOTE-Konstrukt die Wirkung als QUOTE-Konstrukt auf, d.h. der symbolische Ausdruck nach dem Komma ist nicht vom Q U O T E betroffen. Da es sich beim Backslash und beim Komma um Makros handelt, ist mit dem EXPAND-MACRO-Konstrukt der Zwischenschritt „Expandierter Zustand" anzeigbar.

8. Abbildungsoption: Funktion mit zugeordneter Umgebung eval>

(EXPAND-MACRO

' (DEFINE

BAZ

,(+ 1 2))

==>

235

( D E F I N E BAZ 3)

Manchmal ist das Einspleißen (engl.: splicing) eines Wertes erforderlich. Eine Liste ist als Folge ihrer Elemente, also ohne Klammern in eine andere Liste einzufügen. Dazu dient das UNQUOTE-SPLICING-Konstrukt. Es ist nur in Zusammenhang mit einem UNQUOTE-Konstrukt anwendbar. Man beachte, daß unmittelbar nach dem Komma das Zeichen „@" (spöttisch „Klammeraffe") notiert ist. eval>

;; A S C I I M m e r i c a n S t a n d a r d ( A S C I I->SYMB0L 64) ==> @

eval>

( D E F I N E BAR

'(0

12

eval>

( D E F I N E BAZ

'(5

6 ) ) ==>

eval> eval> eval>

(CONS ' + (APPEND ' ( + ,@BAR ,@BAZ) ; ; E i n QUASIQUOTE ;; des Argumentes (EXPAND-MACRO "(+

eval> ' ( + eval > ' (+

,@BAR

3 4))

Code f o r

Information

/ntergage)

= = > BAR

BAZ

BAR BAZ) = = > ( + 0 1 2 3 4 5 6 ) = = > ( + 0 1 2 3 4 5 6 ) gegen das E v a l u i e r e n von EXPAND-MACRO

,@BAZ)) = = >

(CONS

(QUOTE + )

(APPEND BAR

BAZ))

BAR BAZ) = = > ( + 0 1 2 3 4 5 6) BAR , (s BAZ) = = > ERROR . ¡Symbol @ n i c h t d e f i n i e r t i n aktueller Umgebung. A c h t u n g ! L e e r z e i c h e n z w i s c h e n Komma und " K l a m m e r a f f e n " macht d i e s e n zu e i n e m s e l b s t ä n d i g e n S y m b o l .

Mit dem QUASIQUOTE-Konstrukt drehen wir die übliche LISP-Notation um. Jetzt wird kein Ausdruck ausgewertet, der nicht besonders gekennzeichnet ist (durch das UNQUOTE-Konstrukt). Normalerweise wird jeder Ausdruck ausgewertet, es sei denn, er ist besonders (durch das QUOTE-Konstrukt) gekennzeichnet. Makros, die in der EVAL-Phase expandieren, sind in PC Scheme mit dem folgenden MACRO-Konstrukt zu definieren: eval>

(MACRO < e x p a n d i e r u n g s - v o r s c h r i f t > )

==>

mit:

: : = Name des

neuen s p e z i e l l e n

:= LAMBDA-Konstrukt mit e i n e r

Konstruktes LAMBDA-Variablen

Das MACRO-Konstrukt deklariert einen Namen als spezielles Schlüsselwort. Ist beim Evaluieren ein solches Schlüsselwort in funktionaler Stellung (erstes Ele-

236

II. Konstruktionen (Analyse und Synthese)

ment einer Liste), dann wird zunächst die Expandierungsvorschrift ausgewertet und anschließend das entstandene Resultat evaluiert. Zur Ausführung der Expandierungsvorschrift wird die LAMBDA-Variable an die gesamte Liste einschließlich des Schlüsselwortes gebunden. Mit Hilfe des Konstruktes EXPANDMACRO ist das Resultat der Expandierungsvorschrift darstellbar. eval>

(MACRO R E V E R S E - C O N S (LAMBDA ( S E X P R ) '(CONS .(LIST-REF .(LIST-REF

eval>

(EXPAND-MACRO

eval>

(DEFINE

eval> eval> eval>

F00

SEXPR SEXPR

2) 1))))

'(REVERSE-CONS

(LAMBDA

==>

A B))

REVERSE-CONS

==>

(ANFANG R E S T ) (REVERSE-CONS

(CONS

ANFANG

B A) REST)))

==>

F00

(DEFINE A 'ARBEITEN!) ==> A (DEFINE B 'HEUTE) ==> B ( F 0 0 A B) = = > ( H E U T E . A R B E I T E N )

Die Makro-Option ist einerseits ein mächtiges Konstruktionsmittel andererseits in der Praxis eine häufige Fehlerquelle. Sorgfältig zu beachten sind der Zeitpunkt und die Umgebung des Textersatzes. Bei den Normierungsbemühungen für Scheme ist die Makro-Option deshalb bisher nicht enthalten (vgl. Rees/Clinger, 1986). In PC Scheme sind Makros stets vor ihrer ersten Nennung in einer Funktion zu definieren, wie das folgende Beispiel zeigt: eval>

(DEFINE

eval>

(MACRO A D D - 2 (LAMBDA ( S E X P R ) ' ( + 2 ,@(CDR S E X P R ) ) ) )

eval>

(F00

4)

F00

(LAMBDA

==>

ERROR

(N)

...

(ADD - 2 N ) ) )

==>

ADD-2

¡Symbol

ADD-2

; nicht eval>

(DEFINE

F00

(LAMBDA

eval>

(F00

==>

6

4)

(N)

(ADD-2

==>

in

F00

aktueller

Umgebung

definiert, N)))

==>

F00

Einem Symbol als Schlüsselwort einer Makrodefinition können wir nicht unmittelbar einen anderen Wert zuweisen. eval>

(DEFINE

ADD-2

7)

==>

ERROR

...

¡Makro

als

Variable

benutzt.

Erst mit einer neuen „leeren" Makrodefinition wird das Symbol wieder allgemein verfügbar. eval> eval> eval>

(MACRO A D D - 2 ( ) ) (DEFINE ADD-2 7) ADD-2 ==> 7

==> ==>

ADD-2 ADD-2

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

237

Eine etwas umfangreichere Makrodefinition zeigt das Programmfragment 8.3.1. Das dortige DEFINE-P-Konstrukt ist in der Lage, wie ein LET-Konstrukt (vgl. Abschnitt 2.2.1), beliebig viele Symbole an Werte zu binden. eval> eval> eval> eval> eval>

(DEFINE F00 10) ==>F00 (DEFINE-P F00 (* 2 F00) BAR F00 BAZ) ==> #T F00 ==> 20 BAR ==> 10 ¡Achtung: 10 nicht 20 !!! BAZ ==> ()

Ein wesentliches Kriterium ist die richtige Umgebung, in der das einzelne DEFINE-Konstrukt evaluiert wird. Erst sind alle Werte zu ermitteln, ehe eine Zuweisung zu den angebenen Symbolen erfolgen kann. Die Lösung nutzt daher neue, nicht „interngemachte" Symbole (vgl. Abschnitt 7.4). Da das LET-Konstrukt in der Lösung eine neue Umgebung aufbaut, ist das DEFINE-Konstrukt in der vorhergehenden Umgebung auszuwerten. Diese Umgebung liefert das ENVIRONMENT-PARENT-Konstrukt (Näheres dazu vgl. Abschnitt 8.4). Die Lösung hat folgende Struktur: (LET ( ( g l ) (g2 ) . . . ) (BEGIN (EVAL (LIST 'DEFINE ' (EVAL gl (THE-ENVIRONMENT) ) ) (ENVIRONMENT-PARENT (THE-ENVIRONMENT))) T)) ;Rückgabewert Das Makro-Konstrukt DEFINE-P expandiert zu folgendem symbolischen Ausdruck: eval> (PP (EXPAND-MACRO-1 '(DEFI NE-P F00 (* 2 F00) BAR F00 BAZ))) (LET ((VARS-L '(F00 BAR BAZ)) (TEMP-SYMBOLS '(G127 G128 G129)) (G127 (* 2 F00 ) ) (G128 F00) (G129 ( ) ) ) (BEGIN (EVAL (LIST 'DEFINE 'BAZ (EVAL G129 (THE-ENVIRONMENT))) (ENVIRONMENT-PARENT (THE-ENVIRONMENT))) (EVAL (LIST 'DEFINE 'BAR (EVAL G128 (THE-ENVIRONMENT))) (ENVIRONMENT-PARENT (THE-ENVIRONMENT))) (EVAL (LIST 'DEFINE 'F00 (EVAL G127 (THE-ENVIRONMENT))) (ENVIRONMENT-PARENT (THE-ENVIRONMENT))) #T))

238

II. Konstruktionen (Analyse und Synthese)

; ; ; ; Dokument 8 . 3 . - 1 ; ; ; ; T i t e l : Makro DEFINE-P ; ; ; ; E r s t e l l t am: 2 0 . 1 0 . 8 9 ;;; ;;;

AI

zum B i n d e n von m e h r e r e n ¡ l e t z t e Änderung: -

Symbolen.

DEFINE-P b i n d e t mehrere Symbole. Die A b a r b e i t u n g e n t s p r i c h t dem L E T - K o n s t r u k t ( v g l . A b s c h n i t t 2 . 2 . 1 ) .

(MACRO D E F I N E - P (LAMBDA ( S E X P R ) (LETREC ((GET-VARS (LAMBDA ( L ) (COND ( ( N U L L ? L) N I L ) (T (CONS (CAR L) ( G E T - V A R S (CDDR L ) ) ) ) ) ) ) (GET-ARGS (LAMBDA ( L ) (COND ( ( N U L L ? (CDR L ) ) N I L ) (T (CONS (CADR L) ( G E T - A R G S (CDDR L ) ) ) ) ) ) ) (MAKE-SYMBOLS (LAMBDA ( L ) (COND ( ( N U L L ? L) N I L ) (T (CONS (GENSYM) (MAKE-SYMBOLS (CDR L ) ) ) ) ) ) ) (MAKE - L E T - L I S T E (LAMBDA (TEMP-SYM ARGS) (COND ( ( N U L L ? T E M P - S Y M ) N I L ) (T (CONS ( L I S T (CAR T E M P - S Y M ) (CAR A R G S ) ) ( M A K E - L E T - L I S T E (CDR T E M P - S Y M ) (CDR A R G S ) ) ) ) ) ) ) ( V A R S - L ( G E T - V A R S (CDR S E X P R ) ) ) ( A R G S - L (GET-ARGS (CDR S E X P R ) ) ) ( T E M P - S Y M B O L S (MAKE-SYMBOLS V A R S - L ) ) ( M - L (CONS ( L I S T ' V A R S - L ( L I S T 'QUOTE V A R S - L ) ) (CONS ( L I S T ' T E M P - S Y M B O L S ( L I S T 'QUOTE T E M P - S Y M B O L S ) ) ( M A K E - L E T - L I S T E TEMP-SYMBOLS A R G S - L ) ) ) ) ) '(LET

,M-L ,(DO ( ( V A R S V A R S - L (CDR V A R S ) ) ( V A L U E S TEMP-SYMBOLS (CDR V A L U E S ) ) (AKKU N I L ) ) ( ( N U L L ? VARS) (APPEND (CONS ' B E G I N AKKU) ( L I S T T ) ) ) ( S E T ! AKKU (CONS ' ( E V A L (LIST 'DEFINE ' , ( C A R VARS) (EVAL .(CAR VALUES) (THE-ENVIRONMENT))) (ENVIRONMENT-PARENT (THE-ENVIRONMENT))) AKKU)))) ) ) ) ==> DEFINE-P

Programmfragment

8 . 3 . 1 Makro

DEFINE-P

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

239

8.4 Lokaler Namensraum (Pakete) Eine Umgebung stellt Symbol-Wert-Assoziationen bereit (vgl. Abschnitt 1.4.2). Sie ist als ein lokaler Namensraum betrachtbar. Der gleiche Name, d.h. das gleiche Symbol, kann in unterschiedlichen Umgebungen zu verschiedenen Werten führen. Die Umgebung ist daher ein zweckmäßiges Konstruktionsmittel, um Namenskonflikten vorzubeugen. Werden fremde Konstrukte importiert oder arbeiten mehrere Programmierer gemeinsam an einer Problemlösung, dann besteht die Gefahr, daß für verschiedene Konstrukte die gleichen Namen verwendet werden. Das Einbetten jeder Teillösung in eine eigene Umgebung verhindert das Überschreiben einer Symbol-Wert-Assoziation. Die Umgebung übernimmt eine Abschottungsaufgabe. Sie „verpackt" eine (Teil)Lösung zu einem „Paket". Ein Paketname bezeichnet somit eine Sammlung von Symbol-Wert-Assoziationen. Der Paketname ist ein Abstraktionsmittel (vgl. Abschnitt 4). Er ermöglicht, diese Sammlung als eine „Einheit" zu benutzen. Pakete sind mit Paketen kombinierbar. Sie können aus schon existierenden Paketen konstruiert werden kann. Dazu kann ein Paket mit anderen Paketen „kommunizieren". Diese Kommunikation bedingt, daß Pakete über gemeinsame Namen verfügen. Wir können drei Arten von Namen unterscheiden: o Importnamen, Dies sind Namen, die in anderen Paketen definert sind und im vorliegenden Paket genutzt werden. o Exportnamen und Dies sind Namen, die, falls Bedarf besteht, von anderen Paketen genutzt werden können. o Interne Namen Dies sind Namen, nur für den internen Gebrauch im vorliegenden Paket. Die Import- und Exportnamen bilden die Schnittstelle des Paketes. Sie sind die Grundlage um die Modularisierung einer komplexen Aufgabe zu spezifizieren (Näheres vgl. Abschnitt 12.2). Umgebungen können in einer Hierarchie angeordnet werden. Entsprechend dieser Struktur sind ihre Namen verfügbar. Nicht zugreifbar sind Namen für Umgebungen auf höherer Ebene, während umgekehrt der Zugriff von tieferen Ebenen entlang der Hierarchie erfolgen kann. Umgebungen bilden damit sogenannte Blockstrukturen, wie sie erstmals in ALGOL (Akronym für ALGOrithmic Language) realisiert wurden. Anhand des Beispiels Kontenverwaltung erörtern wir das „Verpacken" von Symbolen.

240

II. Konstruktionen (Analyse und Synthese)

Beispiel: Kontenverwaltung Die bisherige Kontenverwaltung (vgl. Abschnitt 1.4.2) umfaßt jetzt zusätzlich das Anlegen, Modifizieren und Löschen von Konten. Auf ein angelegtes Konto können Ein- und Auszahlungen gebuchen werden, wobei der Kontostand fortgeschrieben und die Mittelverfügbarkeit im Fall einer Abbuchung kontrolliert wird. Diese Kontenverwaltung nutzt den Verbund aus: o Konstruktoren: MAKE-KONTO-STRUKTUR und MAKE-KONTO, o Selektoren: NAME etc.,

GET-EINZAHLUNGEN,

GET-AUSZAHLUNGEN,

GET-

o Prädikaten: KONTO?, BETRAG?, ADRESSE? etc. und o Modifikatoren: SET-EINZAHLUNGEN!, ADD-EINZAHLUNG!, LOESCHE- KONTO!, AENDERE-KONTO-IDENTIFIZIERUNG! etc. Damit diese Konstrukte nicht in der allgemeinen Benutzerumgebung (in PC Scheme USER-INITIAL-ENVIRONMENT) zugreifbar sind, definieren wir sie in der eigenen Umgebung KONTO-MANAGEMENT. Als Symbole in der Umgebung KONTO-MANAGEMENT sind sie „versteckt", d.h. auf sie kann nicht direkt aus der hierarchisch höheren Umgebung USER-INITIAL-ENVIRONMENT zugegriffen werden. e v a l > MAKE-KONTO = = > ERROR

...

¡Symbol

an k e i n e n Wert

gebunden

Die einzelnen Konten grenzen wir ebenfalls in einer eigenen Umgebung, genannt KONTEN-DATENBANK, gegen andere Umgebungen ab. Alle Konten haben die Attribute: TYP, IDENTIFIZIERUNG, NAME-INHABER, ADRESSE-INHABER, EINZAHLUNGEN, AUSZAHLUNGEN und KONTOSTAND. Für jedes Konto sind die Attribut-Wert-Bindungen festzuhalten. Diese realisieren wir wieder mit der Definition einer eigenen Umgebungen. Ist eine Operation, die in der Umgebung KONTEN-MANAGEMENT gebunden ist, anzuwenden auf ein Konto (Operand), gebunden in der Umgebung KONTEN-DATENBANK, und dessen Werte, gebunden in der Umgebung, die dieses Konto darstellt, dann ist für das Evaluieren die explizite Angabe der einzelnen Umgebung erforderlich. Auf eine explizite Umgebungsnennung können wir in zwei Fällen verzichten: o Das Symbol ist in der aktuellen Umgebung gebunden, und es wird dieser Wert benötigt. o Das Symbol ist in hierarchisch höheren Umgebungen gebunden, und es wird der Wert benötigt, der auf dem Weg von der aktuellen Umgebung zur Hierarchie-Spitze (top level) als erster für das Symbol angetroffen wird. Bild 8.4-1 zeigt ein Beispiel einer Umgebungshierarchie. Ist dort z.B. die Umgebung U 4 die aktuelle Umgebung, dann sind direkt alle Symbole zugreifbar in

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

241

den Umgebungen U 4 , U 2 , und U . Nicht zugreifbar sind dann die Symbole von U 5 und U 3 sind. Bild 8.4-2 zeigt die „Abschirmung", d.h. die lokalen Namensräume, für die Kontenverwaltung. Die Umgebungen KONTEN-DATENBANK und KONTEN-MANAGEMENT definieren wir mit Hilfe des eingebauten Konstruktes THE-ENVIRONMENT, wie folgt: eval>

eval>

( D E F I N E KONTEN - DATENBANK (LET ((TYP 'OPERANDEN)) (THE-ENVIRONMENT)))

==>

KONTEN - DATENBANK

(DEFINE KONTEN-MANAGEMENT (LET ((TYP 'OPERATIONEN) (MAKE-KONTO-STRUKTUR (LAMBDA () (LET ((TYP 'KONTO) ( I D E N T I F I Z I E R U N G 0) (NAME-INHABER NIL) (ADRESSE-INHABER NIL) (EINZAHLUNGEN NIL) (AUSZAHLUNGEN NIL) (KONTOSTAND 0)) (THE-ENVIRONMENT))))) ( T H E - E N V I R O N M E N T ) ) ) ==> K O N T E N - M A N A G E M E N T

Die Umgebung KONTEN-MANAGEMENT verpackt die Symbole T Y P und MAKE-KONTO-STRUKTUR mit ihren Werten. eval>

(ENVIRONMENT-BINDINGS ((TYP . OPERATIONEN)

K O N T E N - M A N A G E M E N T ) ==> (MAKE-KONTO-STRUKTUR .

#))

242

II. Konstruktionen (Analyse und Synthese)

-USER-GLOBAL-ENVIRONMENTr — U S E R - I N I T I A L - ENVIRONMENTr—KONTEN - D A T E N B A N K -

c c

A001

A002-

—KONTEN-MANAGEMENT( ( M A K E - K O N T O .. . ) ( D E S C R I B E - K O N T O ...) ( K O N T O ? ... ) ( G E T - K O N T O ... )

Legende: USER-GLOBAL-ENVIRONMENT ::= G l o b a l e S y s t e m u m g e b u n g . Sie e n t h ä l t die " e i n g e b a u t e n " Konstrukte; z.B.: C(CAR . # < P R O C E D U R E > ) (CDR . # < P R O C E D U R E ) ...) USER-INITIAL-ENVIRONMENT ::= B e n u t z e r u m g e b u n g für die a l l g e m e i n g ü l t i g e n ( g l o b a l e n ) , selbstdefinierten Konstrukte; z.B.: ((KONTEN-DATENBANK . #) ( K O N T E N - M A N A G E M E N T . # < E N V I R O N M E N T > ) ...) KONTEN-DATENBANK ::= U m g e b u n g zur A b b i l d u n g der K o n t e n ; z . B . : ((A001 . # < E N V I R O N M E N T > ) (A002 . # < E N V I R O N M E N T > ) A001 ::= U m g e b u n g zur A b b i l d u n g der W e r t e e i n e s ( ( N A M E - I N H A B E R . "Otto") ( A D R E S S E - I N H A B E R . " B e r l i n " ) ...)

Kontos;

z.B.:

KONTEN-MANAGEMENT ::= U m g e b u n g zur A b b i l d u n g der O p e r a t i o n e n ; z . B . : ((MAKE-KONTO.#) (KONTO? . #) Bild 8 . 4 - 2 .

Kontenverwaltung

abgeschirmt

durch

...)

...)

Umgebungen

Eine schon bestehende Umgebung ist durch das DEFINE-Konstrukt erweiterbar, wenn es in dieser Umgebung ausgewertet wird.

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

243

e v a l > (EVAL ' ( D E F I N E F00 'BAR) K O N T E N - M A N A G E M E N T ) = = > F00 eval > ( E N V I R O N M E N T - B I N D I N G S K O N T E N - M A N A G E M E N T ) = = > ((FOO . B A R ) ( T Y P . O P E R A T I O N E N ) (MAKE-KONTO-STRUKTUR . #)) Die Modifikation der Bindung eines bestehenden Symbols erfordert das Evaluieren des SET'.-Konstruktes in der entsprechenden Umgebung. e v a l > (EVAL '(SET! FOO 'BAZ) K O N T E N - M A N A G E M E N T ) = = > BAZ eval> (ENVIRONMENT-BINDINGS KONTEN-MANAGEMENT) ==> ((FOO . B A Z ) ( T Y P . O P E R A T I O N E N ) (MAKE-KONTO-STRUKTUR . #)) Eine Symbol-Wert-Assoziation wird aus der Umgebung mit dem UNBINDKonstrukt entfernt. Das UNBIND-Konstrukt erfordert stets die explizite Angabe der Umgebung. e v a l > ( U N B I N D '+ ) = = > ERROR ... ; 2 A r g u m e n t e e r f o r d e r l i c h e v a l > ( U N B I N D 'FOO K O N T E N - M A N A G E M E N T ) = = > # < E N V I R 0 N M E N T > eval> (ENVIRONMENT-BINDINGS KONTEN-MANAGEMENT) ==> ((TYP . O P E R A T I O N E N ) ( M A K E - K O N T O - S T R U K T U R . # < P R O C E D U R E > ) )

Unter Verwendung der Konstruke QUASIQUOTE und UNQUOTE (vgl. Abschnitt 8.3) erweitern wir die definierte Umgebung KONTEN-MANAGEMENT um das MAKE-KONTO-Konstrukt. MAKE-KONTO hat in KONTENMANAGEMENT eine Funktion mit der LAMBDA-Variablen K_ IDENT als Wert. Diese Funktion enthält in ihrem Funktionskörper die lokalen Funktionen MAKE-OBJEKT und SET-IDENT!. Die Anwendung der Funktion MAKE-OBJEKT erweitert die Umgebung KONTEN-DATENBANK um das Konto IDENT. Dabei ist der Wert von IDENT die Umgebung, die durch MAKE-KONTO-STRUKTUR erzeugt wird. Der Wert von MAKE-OBJEKT ist der Wert von IDENT. e v a l > (EVAL ' ( D E F I N E M A K E - K O N T O ( L A M B D A ( K _ I D E N T ) (LET ( ( M A K E - O B J E K T ( L A M B D A (IDENT) (EVAL ' ( D E F I N E .IDENT ,(MAKE-KONTO-STRUKTUR)) KONTEN-DATENBANK) ;; D a m i t d e r R ü c k g a b e w e r t d e r ;; I D E N T - W e r t i s t . (EVAL IDENT K O N T E N - D A T E N B A N K ) ) ) ( S E T - I D E N T ! ( L A M B D A (KONTO IDENT) (EVAL '(SET! I D E N T I F I Z I E R U N G ',K_IDENT) KONTO)))) (SET-IDENT! (MAKE-OBJEKT K_IDENT) K_IDENT)))) KONTEN-MANAGEMENT) ==> MAKE-KONTO

244

1

II. Konstruktionen (Analyse und Synthese)

X^A

mallOl Kennt VI EO_LE I C M T OEMANT: H e r r n ^Foo, ) n H Hll E f ? IN " D I E S E R E T A Q l

Da MAKE-KONTO-STRUKTUR ein Symbol in KONTEN-MANAGEMENT ist, kann es ohne explizite Umgebungsangabe evaluiert werden, wenn die aktuelle Umgebung durch die definierte Hierarchie auf KONTEN-MANAGEMENT zugreifen kann. Mit der Definition von MAKE-OBJEKT als LAMBDA-Konstrukt wird eine Umgebung an diese Funktion gebunden. Dies geschieht innerhalb der Funktion MAKE-KONTO. Deren hierarchisch höhere Umgebung übernimmt die Rolle einer „Elternschaft". Die Umgebung der Eltern ist mit dem ENVIRONMENT-PARENT-Konstrukt zugreifbar, wie das folgende Beispiel skizziert. Dieses M-K-Konstrukt orientiert sich an der Struktur von MAKEKONTO. eval> (DEFINE M-K (LAMBDA (K_IDENT) (LET ((M-K-0 (LAMBDA (IDENT) (WRITELN "Fuehre Nebeneffekte aus!") (THE-ENVIRONMENT)))) (M-K-0 'A001)))) ==> M-K eval> (ENVIRONMENT-BINDINGS (M-K 'ABC)) ==> Fuehre Nebeneffekte aus! ((IDENT . A001)) eval> (ENVIRONMENT-BINDINGS (ENVIRONMENT-PARENT (M-K 'ABC))) ==> Fuehre Nebeneffekte aus! ((K_IDENT . ABC)) Entsprechend unserem MAKE-KONTO-Konstrukt erweitern wir KONTENMANAGEMENT um ein DESCRIBE-KONTO-Konstrukt. Ein Konto erhalten wir durch Zugriff mittels ACCESS in der Umgebung KONTEN-DATEN-

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

245

BANK. Das COPY-Konstrukt dient als Schutz vor dem destruktiven SORT!Konstrukt (vgl. Abschnitt 5.1). eval> (EVAL '(DEFINE D E S C R I B E - K O N T O (LAMBDA (K_I DENT) (NEWLINE) (WRITELN " Inhalt des Kontos: " K_I DENT "

" )

(PP (SORT! (COPY ( E N V I R O N M E N T - B I N D I N G S (EVAL '(ACCESS ,K_IDENT KONTEN - D A T E N B A N K ) ) ) ) ) ) (NEWLINE) *THE-NON-PRINTING-OBJECT*)) KONTEN-MANAGEMENT) ==> DESCRIBE-KONTO Beim Benutzen der Kontenverwaltung ist USER-INITIAL-ENVIRONMENT die aktuelle Umgebung. Um das MAKE-KONTO-Konstrukt aus dieser Umgebung aufrufen zu können, definieren wir ein gleichnamiges Konstrukt in der USER-INITIAL-ENVIRONMENT. Dieses MAKE-KONTO-Konstrukt legt das Konto an und gibt es mit DESCRIBE-KONTO auf dem Bildschirm aus. eval> (DEFINE M A K E - K O N T O (LAMBDA (K_IDENT) (EVAL '(MAKE-KONTO ',K_IDENT) K O N T E N - M A N A G E M E N T ) (EVAL '(DESCRIBE-KONTO ',K_IDENT) KONTEN - M A N A G E M E N T ) ) ) ==> M A K E - K O N T O eval> (MAKE-KONTO 'A001) = = > Inhalt des Kontos: A001 ((ADRESSE-INHABER) (AUSZAHLUNGEN) (EINZAHLUNGEN) (IDENTIFIZIERUNG . A001) (KONTOSTAND . 0) (NAME-INHABER) (TYP . KONTO)) Bei mehreren zu definierenden Operationen ist die bisherige Formulierung: (EVAL '(DEFINE FOO ... ) KONTEN-MANAGEMENT) umständlich. Wir definieren eine Syntaxverbesserung in Form eines Makros (vgl. Abschnitt 8.3). eval> (MACRO D E F I N E - O P E R A T I O N (LAMBDA (SEXPR) '(EVAL \ ( C 0 N S 'DEFINE (CDR SEXPR)) KONTEN-MANAGEMENT))) ==> DEFINE-OPERATION eval>

(EXPAND-MACRO '(DEFINE-OPERATION FOO (LAMBDA (X) "... ==> (EVAL (QUOTE (DEFINE FOO (LAMBDA (X) "... KONTEN-MANAGEMENT)

..."))) ...")))

II. Konstruktionen (Analyse und Synthese)

246

eval>

(DEFINE-OPERATION DESCRIBE-KONTO-STRUKTUR (LAMBDA ( ) (NEWLINE) (WRITELN " Kontostruktur ") (PP ( E N V I R O N M E N T - B I N D I N G S (MAKE-KONTO-STRUKTUR))) (NEWLINE) *THE-NON-PRINTING-OBJECT*)) ==> DESCRIBE-KONTO-STRUKTUR

eval>

(DEFINE-OPERATION DESCRIBE-KONTEN (LAMBDA ( ) (NEWLINE) (WRITELN " Angelegte Konten ") ( P P ( S O R T ! (MAP ( L A M B D A ( X ) ( C A R X ) ) ( E N V I R O N M E N T - B I N D I N G S KONTEN - D A T E N B A N K ) ) ) ) (NEWLINE) *THE-NON-PRINTING-OBJECT*)) ==> DESCRIBE-KONTEN

eval>

( D E F I N E - O P E R A T I O N D E S C R I B E - O P E R A T I ON EN (LAMBDA ( ) (NEWLINE ) (WRITELN " O p e r a t i o n e n der K o n t e n v e r w a l t u n g ") ( P P ( S O R T ! (MAP ( L A M B D A ( X ) ( C A R X ) ) (ENVIRONMENT-BINDINGS KONTEN-MANAGEMENT)))) (NEWLINE) * T H E - N 0 N - P R I N T I N G - O B J E C T * ) ) = = > D E S C R I B E - O P E R A T I ON EN

Um diese Operationen aus der USER-INITIAL-ENVIRONMENT heraus aufrufen zu können, müßten entsprechend der obigen Definition für MAKE-KONTO dort Symbole definiert werden. Mit Hilfe eines Makros erleichtern wir uns solche Definitionen. Ein SEND-Makro übernimmt die Operation mit ihren jeweiligen Argumenten und erzeugt einen Aufruf: (EVAL KONTEN-MANAGEMENT). eval>

eval>

(MACRO S E N D (LAMBDA ( S E X P R ) '(EVAL ' , ( C D R SEXPR)

KONTEN-MANAGEMENT)))

(SEND DESCRIBE-KONTO ' A 0 0 1 ) I n h a l t des K o n t o s : A001 ((ADRESSE-INHABER) (AUSZAHLUNGEN) (EINZAHLUNGEN) (IDENTIFIZIERUNG . A001) (KONTOSTAND . 0) (NAME-INHABER) (TYP . KONTO))

==>

==>

SEND

247

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

;;;; ;;;; ;;;; :;;:

Dokument 8 . 4 - 1 T i t e l : VerwaltungvonKontenaufdenenEin-und gebucht werden. E r s t e l l t : 17.11.89 ;1etzte Aenderung : -

;;;;

Syntaxhilfen

;;;

Auszahlungen

(Makros)

DEFINE-OPERATION

und

;; ;; ;; ;

KMoAnKsEt-rKuOkNt To Or e - SnT R U K T U R

;;;;

Praedi kate

SEND

(siehe

obigen

und M A K E - K O N T O

Text)

(siehe

obigen

Text)

( D E F I N E - O P E R A T I O N KONTO? (LAMBDA ( X ) ( L E T ( ( W E R T ( E V A L " ( A C C E S S ,X K O N T E N - D A T E N B A N K ) ) ) ) (AND ( E N V I R O N M E N T ? WERT) ( E Q ? ' K O N T O ( A C C E S S TYP W E R T ) ) ) ) ) ) ( D E F I N E - O P E R A T I O N BETRAG? (LAMBDA ( X ) (AND (NUMBER?

X)

(>=

X

0))))

( D E F I N E - O P E R A T I O N BUCHUNGSDATUM? ( L A M B D A ( X ) (AND ( N U M B E R ? X ) ( > =

X

890101))))

( D E F I N E - O P E R A T I O N NAME? (LAMBDA ( X ) ( S T R I N G ? X ) ) ) (DEFINE-OPERATION ADRESSE? (LAMBDA ( X ) ( S T R I N G ? X ) ) ) ;;:;

Selektoren

( D E F I N E - O P E R A T I O N GET-KONTO (LAMBDA ( K _ I D E N T ) (COND ( ( K O N T O ? K _ I D E N T ) ( E V A L K _ I D E N T K O N T E N - D A T E N B A N K ) ) (T (ERROR " K e i n K o n t o : " K _ I D E N T ) ) ) ) ) (DEFINE-OPERATION GET-NAME-INHABER (LAMBDA ( K _ I D E N T ) ( A C C E S S NAME-INHABER (DEFINE-OPERATION GET-ADRESSE-INHABER (LAMBDA ( K _ I D E N T ) ( A C C E S S A D R E S S E - I N H A B E R (GET-KONTO

(GET-KONTO

K_IDENT))))

K_IDENT))))

(DEFINE-OPERATION GET-EINZAHLUNGEN (LAMBDA ( K _ I D E N T ) ( A C C E S S EINZAHLUNGEN

(GET-KONTO

K_IDENT))))

( D E F I N E - O P E R A T I O N GET-AUSZAHLUNGEN (LAMBDA ( K _ I D E N T ) ( A C C E S S AUSZAHLUNGEN

(GET-KONTO

K_IDENT))))

( D E F I N E - O P E R A T I O N GET-KONTOSTAND ( L A M B D A ( K _ I D E N T ) ( A C C E S S KONTOSTAND

(GET-KONTO

; ; ; ; Modi f i k a t o r e n (DEFINE-OPERATION SET-IDENTIFIZIERUNG! (LAMBDA ( K _ I D E N T I _ N E U ) (EVAL ' ( S E T ! I D E N T I F I Z I E R U N G ',I_NEU) (GET-KONTO K _ I D E N T ) ) ) )

K_IDENT))))

248

II. Konstruktionen (Analyse und Synthese)

( D E F I N E - O P E R A T I O N SET - NAME - 1 N H A B E R ! (LAMBDA ( K _ I D E N T N_NEU) (EVAL ' ( S E T ! NAME-INHABER \ N _ N E U )

(GET-KONTO

( D E F I NE-OPERAT ION S E T - A D R E S S E - I N H A B E R ! (LAMBDA ( K _ I D E N T A_NEU) (EVAL ' ( S E T ! ADRESSE-INHABER \ A _ N E U )

K_IDENT))))

(GET-KONTO

K_IDENT))))

(DEFINE-OPERATION SET-EINZAHLUNGEN! ( L A M B D A ( K_ I DENT E_ N EU ) (EVAL ' ( S E T ! EINZAHLUNGEN \ E _ N E U )

(GET-KONTO

K_IDENT))))

( D E F I N E - O P E R A T I O N SET-AUSZAHLUNGEN ! (LAMBDA ( K _ I D E N T A_NEU) ( E V A L ' ( S E T ! AUSZAHLUNGEN \ A _ N E U )

(GET-KONTO

K_IDENT))))

( D E F I NE-OPERAT ION SET-KONTOSTAND ! ( L A M B D A ( K_ I DENT K_ N E U ) ( E V A L ' ( S E T ! KONTOSTAND ' , K _ N E U )

(GET-KONTO

K_IDENT))))

(DEFINE-OPERATION ADD-EINZAHLUNG! (LAMBDA ( K _ I D E N T E.DATUM BETRAG) (COND ( ( A N D ( K O N T O ? K _ I D E N T ) (BUCHUNGSDATUM? E _ D A T U M ) (BETRAG? BETRAG)) (SET-EINZAHLUNGEN! K_IDENT (CONS ( L I S T E_DATUM B E T R A G ) (GET-EINZAHLUNGEN K _ I D E N T ) ) ) (SET-KONTOSTAND! K_IDENT ( + BETRAG ( G E T - K O N T O S T A N D K _ I D E N T ) ) ) ) ( T (ERROR " K e i n e E i n z a h l u n g h i n z u g e f u e g t ! " K _ I D E N T E_DATUM B E T R A G ) ) ) ) ) (DE F I NE-OPERAT ION ADD-AUSZAHLUNG! ( L A M B D A ( K _ I D E N T A_DATUM B E T R A G ) (COND ( ( A N D ( K O N T O ? K _ I D E N T ) (BUCHUNGSDATUM? A _ D A T U M ) (BETRAG? BETRAG)) (LET ((SALDO (GET-KONTOSTAND K _ I D E N T ) ) ) (COND ( ( < = BETRAG S A L D O ) (SET-AUSZAHLUNGEN! K_IDENT (CONS ( L I S T A_DATUM B E T R A G ) (GET-AUSZAHLUNGEN K _ I D E N T ) ) ) (SET-KONTOSTAND! K_IDENT ( - SALDO B E T R A G ) ) ) ( T (ERROR "Keine Deckung f u e r : " BETRAG))))) ( T (ERROR " K e i n e A u s z a h l u n g m o e g l i c h ! " K _ I D E N T A_DATUM B E T R A G ) ) ) ) ) ( D E F I N E - O P E RAT I O N N E U E R - I N H A B E R ! (LAMBDA ( K _ I D E N T I _ N E U ) (COND ( ( A N D ( K O N T O ? K _ I D E N T ) (NAME? I _ N E U ) ) (SET-NAME-INHABER! K_IDENT I _ N E U ) ) ( T (ERROR " K e i n e N a m e n s a e n d e r u n g v o l l z o g e n : K_IDENT I_NEU) ) ) ) )

"

249

8. Abbildungsoption: Funktion mit zugeordneter Umgebung (DEFINE-OPERATION NEUE-ADRESSE! (LAMBDA ( K _ I D E N T A_NEU) (COND ( ( A N D ( K O N T O ? K _ I D E N T ) (ADRESSE? A_NEU)) (SET-ADRESSE-INHABER! K_IDENT A_NEU)) (T ( E R R O R " K e i n e A d r e s s e n a e n d e r u n g v o l l z o g e n : K_ I DENT A_NEU ) ) ) ) )

"

( D E F I N E - O P E R A T I O N LOESCHE-KONTO! (LAMBDA ( K . I D E N T ) (COND ( ( K O N T O ? K _ I D E N T ) (UNBIND K_IDENT KONTEN-DATENBANK)) (T ( E R R O R " K e i n K o n t o : " K _ I D E N T ) ) ) ) ) ( D E F I N E - O P E R A T I O N A E N D E R E - KONTO - I D E N T I F I Z I E R U N G ! (LAMBDA ( K _ I D E N T _ A L T K _ I D E N T _ N E U ) (COND ( ( K O N T O ? K _ I D E N T _ N E U ) (ERROR "Neue Kontonummer i s t b e l e g t : " K_ I D E N T _ N E U ) ) ((KONTO? K_IDENT_ALT) (EVAL ' ( D E F I N E ,K_IDENT_NEU (SEND GET-KONTO ',K_IDENT_ALT)) KONTEN-DATENBANK) ( S E T - I D E N T I F I Z I E R U N G ! K_IDENT_NEU K_IDENT_NEU) (LOESCHE-KONTO! K_IDENT_ALT)) (T ( E R R O R " A l t e K o n t o n u m m e r e x i s t i e r t n i c h t : " K_ I D E N T _ A L T ) ) ) ) ) Programmfragment

8.4-1.

Verwaltung von Konten (Abbildungsbasis: Umgebungen)

Anhand einiger Beispielen verdeutlichen wir die Kontenverwaltung: eval> eval> eval> eval> eval> eval> eval> eval> eval> eval> eval>

(SEND MAKE-KONTO ' A O O l ) = = > A 0 0 1 (SEND MAKE-KONTO ' A 0 0 2 ) = = > A002 (SEND MAKE-KONTO ' A 0 0 3 ) = = > A003 (SEND NEUER-INHABER! 'AOOl "H. B o n i n " ) ==> "H. B o n i n " (SEND NEUE-ADRESSE! 'AOOl " V o l g e r s h a l l 1 D - 2 1 2 0 L u e n e b u r g " ) ==> " V o l g e r s h a l l 1 D-2120 Lueneburg" (SEND ADD-EINZAHLUNG! 'AOOl 891116 1 2 0 . 1 0 ) ==> 1 2 0 . 1 (SEND ADD-EINZAHLUNG! 'AOOl 891117 80.20) ==> 200.3 (SEND ADD-EINZAHLUNG! 'AOOl 891118 1 0 0 . 7 0 ) ==> 301. (SEND ADD-AUSZAHLUNG! 'AOOl 8 9 1 1 1 8 2 0 0 . 0 0 ) = = > 101. (SEND AENDERE-KONTO-1DENTIFI ZIERUNG! 'AOOl 'A007) ==> # (SEND DESCRIBE-KONTO 'A007 ) ==>

I n h a l t des K o n t o s : A007 ((ADRESSE-INHABER . " V o l g e r s h a l l (AUSZAHLUNGEN ( 8 9 1 1 1 8 2 0 0 . ) ) (EINZAHLUNGEN (891118 100.7) (891117 80.2) (891116 120.1)) (IDENTIFIZIERUNG . A007) (KONTOSTAND . 1 0 1 . ) (NAME-INHABER . "H. B o n i n " ) (TYP . KONTO))

1 D-2120

Lueneburg")

250 eval>

II. Konstruktionen (Analyse und Synthese) (SEND

DESCRIBE- OPERATIONEN)

==>

Operationen der Kontenverwaltung (ADD-AUSZAHLUNG! ADD-EINZAHLUNG! ADRESSE? AENDERE-KONTO-IDENTIFIZIERUNG! BETRAG? BÜCHUNGSDATUM? DESCRIBE-KONTEN DESCRIBE-KONTO DESCRIBE-KONTO-STRUKTUR DESCRIBE-OPERATIONEN GET-ADRESSE-INHABER GET-AUSZAHLUNGEN GET-EINZAHLUNGEN GET-KONTO GET-KONTOSTAND GET-NAME-INHABER KONTO? LOESCHE-KONTO! MAKE-KONTO MAKE-KONTO-STRUKTUR NAME? NEUE-ADRESSE! NEUER-INHABER! SET-ADRESSE-INHABER! SET-AUSZAHLUNGEN! SET-EINZAHLUNGEN! SET-IDENTIFIZIERUNG! SET-KONTOSTAND! SET-NAME-INHABER! TYP)

Die Kontenverwaltung zeigt, daß wir bei dem Verbund von Konstruktor, Selektor, Prädikat und Mutator für jedes Attribut eines Kontos entsprechende Konstrukte definieren müssen. Etwas salopp formuliert: Es wimmelt bald von GET--, SET-- und ?-Definitionen. Es bietet sich daher an, diese Konstrukte unmittelbar vom LISP-System definieren zu lassen. Eine solche Möglichkeit bietet das DEFINE-STRUCTURE-Konstrukt (vgl. Abschnitt 9).

8.5 Übersetzen von Funktionen Die Zeit, die ein Rechner benötigt, um eine LISP-Funktion auszuführen, ist häufig zu lang. Eine Steigerung der Effizienz bedingt eine Reduktion des Aufwandes für den Rechner. Der Ausführungsaufwand ist reduzierbar, indem der Rechner nicht die Interpretation der Funktion ausführt, sondern ihr compiliertes Äqui-

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

251

valent. Ein Übersetzer (engl.: Compiler) transformiert das in LISP formulierte Konstrukt in eine maschinennähere Form, so daß deren Ausführung denselben Effekt hat wie die Ausführung des ursprünglichen Konstruktes. Zu fordern ist von übersetzten Konstrukten, daß sie beliebig mit zu interpretierenden Konstrukten kombinierbar sind. Diese Anforderung an den Compiler steht in Konkurrenz zur Anforderung, möglichst effizienten Code zu erzeugen. Beispielsweise sind Referenzen zu Variablen abzubilden, die der Interpreter kennt, damit ein interpretiertes Konstrukt darauf Bezug nehmen kann. Zusätzlich ist bei die Fehlersuche hilfreich, wenn compilierte Konstrukte ein Stück zurückübersetzt (engl.: discompiliert) werden können. Erst ihre Rückübersetzung macht sie wieder durchschaubar. Zur Zeitmessung definieren wir ein Makro mit dem RUNTIME-Konstrukt (vgl. PC Scheme Manual). Das RUNTIME-Konstrukt gibt die Uhrzeit als Integerzahl zurück. eval>

(MACRO Z E I T M E S S U N G (LAMBDA ( S E X P R ) 'C LET ( ( A N F A N G ( R U N T I M E ) ) (ENDE 0 ) ) ,(CADR SEXPR) ( S E T ! ENDE ( R U N T I M E ) ) ;; F a l l s M i t t e r n a c h t d u r c h l a u f e n (COND ( ( < ENDE A N F A N G ) ( / ( + ( - ( * 24 60 60 1 0 0 ) ANFANG) ENDE) (T

(/

(-

100))

ENDE A N F A N G )

wird

100)))))) =->

ZEITMESSUNG

Zur Beurteilung der Effizienz hat Richard P. Gabriel Funktionen vorgeschlagen, die in der LISP-Welt allgemein Verwendung finden (vgl. Gabriel, 1985). Einige seiner rekursiven Meß-Funktionen basieren auf einem Vorschlag von Takeuchi. Ihm zu Ehren hat die folgende Funktion die Kurzbezeichnung TAK: eval>

eval>

( D E F I N E TAK ( L A M B D A (X Y Z ) ( I F (NOT ( < Y X ) ) Z (TAK (TAK ( - 1 + X) (TAK ( - 1 + Y) (TAK ( - 1 + Z) (TAK

18 12 6 )

Y Z) Z X) X Y)))))

==>

TAK

==> 7

Eine weitere Meß-Funktion von R.P. Gabriel generiert die ungeraden Zahlen in einem Intervall. Sie kann in Scheme, wie folgt, definiert werden:

252

II. Konstruktionen (Analyse und Synthese)

eval> (OEFINE GENERATOR-ZAHLEN-LISTE (LAMBDA (N) (DO ( ( I N (-1+ I ) ) (LISTE () (CONS I LISTE))) ((= I 0) LISTE)))) ==> GENERATOR-ZAHLEN-LISTE eval> (DEFINE FILTER-UNGERADE-POSITION (LAMBDA (L) (COND ((NULL? L) ( ) ) (T (CONS (CAR L) (FI LTER-UNGERADE-POSITION (CDDR L ) ) ) ) ) ) ) ==> FI LT ER-UNGERADE-POSITION eval> (FILTER-UNGERADE-POSITION (GENERATOR-ZAHLEN-LISTE 5000)) = = > ( 1 3 5 7 . . .

4999)

Unsere rechenintensive Funktion UMDREHEN (vgl. Abschnitt 3.4) ist ebenfalls geeignet für einen Leistungsvergleich. eva1> (DEFINE UMDREHEN (LAMBDA (X) (COND ((NULL? X) NIL) ((NULL? (CDR X)) X) (T (CONS (CAR (UMDREHEN (CDR X))) (UMDREHEN (CONS (CAR X) (UMDREHEN (CDR (UMDREHEN (CDR X ) ) ) ) ) ) ) ) ) ) ) ==> UMDREHEN Aufgrund der Abhängigkeit vom jeweiligen Rechner ist im folgenden bewußt auf eine Zeitangabe verzichtet worden. In PC Scheme (Version 3.03 für MS-DOS) bringt das Compilieren der Funktion UMDREHEN keine Verbesserung. In TLC-LISP (Version 1.51 für MS-DOS) konnte ein Verbesserungsfaktor von 1:4 gemessen werden. eval> (ZEITMESSUNG (UMDREHEN ' ( 0 1 2 3 4 5 6 7 8 9 ) ) ) ==> ? eval> (C0MPILE UMDREHEN) ==> (PCS-C0DE-BL0CK 1 4 (#) ( 1 4 0 59)) eval> (ZEITMESSUNG (UMDREHEN ' ( 0 1 2 3 4 5 6 7 8 9 ) ) ) ==> ?

8.6 Zusammenfassung: Closure, Continuation, Makros und Pakete Die Verknüpfung der Funktion mit ihrer Definitionsumgebung (Closure-Konzept) ermöglicht problemloses Konstruieren mit Funktionen höherer Ordnung. Eine Funktion kann an ihre eigene LAMBDA-Variable gebunden werden. Auf diese Weise entstehen selbstbezügliche Funktionen (ohne DEFINE- oder LETREC-Konstrukt). Das CALL/CC-Konstrukt bindet an die LAMBDA-Variable seiner applizierten Funktion, die noch nicht vollzogene Abarbeitung als sogenannte Continuation („Fortsetzung"). Da eine Continuation die vollzogenen Bindungen mit umfaßt, können Berechnung abgebrochen und später (auch mehrfach) wieder aufge-

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

253

nommen werden. Das CALL/CC-Konstrukt ist eine Konstrollstruktur, die Sprünge in die „Zukunft" und „Vergangenheit" einer Berechnung ermöglicht. Die Umgebung einer Funktion ist als ein lokaler Namensraum betrachtbar. Die hierarchische Anordnung von Umgebungen ist eine Technik zur Vermeidung von Namenskonflikten. Makros dienen zur Syntaxverbesserung. Zu unterscheiden sind „normale" Makros von READ-Makros. READ-Makros sind z.B das QUASIQUOTE (Zeichen: ' ), das QUOTE (Zeichen: ' ), das UNQUOTE (Zeichen: , ) und das UNQUOTE-SPLICING (Zeichen: @ ). Sie expandieren in der READ-Phase des READ-EVAL-PRINT-Zyklus. „Normale" Makros expandieren in der EVAL-Phase. Sie können in PC Scheme mit dem Konstrukt MACRO definiert werden. Einerseits ist das Makro ein mächtiges Konstruktionsmittel, andererseits verursacht das Makro im Programmieralltag häufig Fehler, weil der Expansionszeitpunkt und die Expansionsumgebung nicht beachtet werden. Charakteristische ; ; ; ; Funktion eval> (DEFINE eval> (DEFINE

Beispiele für Abschnitt 8: und Umgebung ( l e x i k a l i s c h e Bindung) ZAEHLER 5) ==> ZAEHLER F00 (LAMBDA () (SET! ZAEHLER (1+ ZAEHLER))))

eval> (LET ((ZAEHLER 0)) (F00) ZAEHLER) ==> 0 eval> ZAEHLER ==> 6

==> F00

eval> (DEFINE F00 (LAMBDA (FKT X Y) (LET ((+ (LAMBDA (X Y) (APPLY + (LIST X Y ) ) ) ) ) (LIST (+ (FKT X) (FKT Y)) (+ (FKT (FKT X)) (FKT (FKT Y ) ) ) ) ) ) ) ==> F00 eval> (DEFINE BAZ (LAMBDA (Z) (+ Z Z))) ==> BAZ eval> (F00 BAZ 1 2) ==> (6 12) eval> (LET ((FKT (LAMBDA (FUN X) (COND ((ZERO? X) (FUN)) (T (LAMBDA () X ) ) ) ) ) ) (FKT (FKT NIL 6) 0)) ==> 6 ;;;; ;;; ;;; ;;;

Klassisches LISP-Sprung-Paar: CATCH und THROW h i e r r e a l i s i e r t mit der allgemeinen K o n t r o l l s t r u k t u r CALL-WITH-CURRENT-CONTINUATION, kurz: CALL/CC CATCH s e t z t eine Marke; THROW s p r i n g t zur Marke.

eval> (DEFINE *CATCHER-C0NTINUATI0NS* ( ) ) ==> *CATCHER-CONTI NUAT IONS*

II. Konstruktionen (Analyse und Synthese)

254

eval>

(MACRO

CATCH

(LAMBDA

(SEXPR)

(LET ((-C-

(GENSYM)))

'(CALL/CC

(LAMBDA

( ,-C-)

(SET!

*CATCHER-CONTINUATIONS* (CONS (LIST

,(CADR SEXPR)

,-C-)

*CATCHER-CONTINUATIONS*)) (BEGINO ,(CONS

'BEGIN

(SET!

(CDR ))))) ==> eval>

(DEFINE THROW (LETREC

(LAMBDA

SEXPR))

*CATCHER-CONTINUATIONS*)))

CATCH

(MARKE

((MEMBER-RESTLISTE (COND

(CDDR

*CATCHER-CONTINUATIONS*

((NULL?

SEXPR) (LAMBDA

(KEY

C(EQ? KEY

(CAAR L)) L)

(T ( M E M B E R - R E S T L I S T E (CONTINUATIONS

L)

L) NIL) KEY

(CDR

L))))))

(MEMBER-RESTLISTE MARKE *CATCHER-CONTINUATIONS*))

(GET-C-

(LAMBDA

(COND ((NULL?

() (CADR (CAR

CONTINUATIONS)))))

CONTINUATIONS)

(ERROR "Keine C A T C H - M a r k e : (T (SET!

(CDR

CONTINUATIONS))

((GET-C-) SEXPR)))))) ==> eval>

(BEGIN

(+ 1 (CATCH

(CATCH

"1.

Schritt")

'BAR (WRITELN (THROW (CATCH

"2.

Schritt")

'FOO (+ 2 8)) 'BAZ (WRITELN (THROW 5)))

2.

11

Schritt

THROW

' FOO (WRITELN

1. Schritt

" MARKE))

*CATCHER-CONTINUATIONS*

"3.

Schritt")

'BAR 20))) ==>

8. Abbildungsoption: Funktion mit zugeordneter Umgebung

;;;; eval>

Sich

selbst

(DEFINE

(SEXPR)

(LIST

SEXPR

SEXPR))

(LAMBDA

(SEXPR)

(LIST

SEXPR

SEXPR))))

F00 = = >

eval>

(EVAL

(#

(EVAL

==> ;;;;

Konstrukt (MACRO

(EVAL

zur

F00) ) ) )

#)

Berechnung

der

Länge

einer

Liste

(SEXPR) ,(CADR

SEXPR)

(LAMBDA

(X)

(,(CADDR (DEFINE

(F

(LAMBDA (F

X)))))

==>

DE F I N E - F U N KT I ON

G) (X)

(G X ) ) ) ) )

(DEFINE

SEXPR)

COMPOSE

(LAMBDA

==>

COMPOSE

CONDITIONAL

(LAMBDA

(P

(LAMBDA

F G) (X)

eval>

(DEFINE

F-ADD

eval>

(DEFINE

ALPHA

(LAMBDA (MAP

(IF

(P

(LAMBDA

X)

(F

(X)

X)

(APPLY

(G X ) ) ) ) ) + X)))

==>

==>

CONDITIONAL

F-ADD

(F)

(LAMBDA

eval>

F00

DEFINE-FUNKTION

"(DEFINE

eval>

==>

#)

(EVAL

(#

(LAMBDA

eval>

Konstrukt

F00

((LAMBDA

eval>

eval>

reproduzierendes

255

(X) F X))))

(DEFINE-FUNKTION (CONDITIONAL

==>

ALPHA

F-LENGTH

NULL? (LAMBDA

(X)

(COMPOSE

0)

F-ADD

(ALPHA

(LAMBDA

(X) ==>

eval>

(F-LENGTH

'(A

B C D )

==>

4

1))))) F-LENGTH

256

II. Konstruktionen (Analyse und Synthese)

;;;

Das

;;;

entspricht

eval>

expandierte

(DEFINE

Makro

DEFINE-FUNKTION

folgendenem

Konstrukt:

F-LENGTH

(LAMBDA

(X)

((CONDITIONAL NULL? (LAMBDA

(X)

0) (COMPOSE X))) Ersetzt

==>

man d i e

F-ADD,

das

F-LENGTH-Konstrukt:

(DEFINE

(ALPHA

Konstrukte

und eval>

dann

F-ADD

(LAMBDA

(X)

1))))

F-LENGTH

ergibt

CONDITIONAL,

sich

folgende

COMPOSE,

Definition

ALPHA für

F-LENGTH

(LAMBDA

(X)

(((LAMBDA

(P

F G)

(LAMBDA

(X)

(IF

X)

(P

(F

X)

(G

X))))

(X)

1)

X))))

NULL? (LAMBDA

(X)

0) ((LAMBDA

(F

(LAMBDA (F

(G

(LAMBDA (APPLY (MAP

;;;; eval>

==>

Konstruktion (DEFINE (LET

X))))

(X)

(LAMBDA X)))

G) (X)

+

X))

(X) (LAMBDA F-LENGTH

einer

Umgebung,

die

sich

selbst

enthält,

MEINE-UMGEBUNG ((SELBST (X

NIL)

13))

(THE-ENVIRONMENT))) eval>

(ENVIRONMENT-BINDINGS

eval>

(EVAL

eval>

(ENVIRONMENT-BINDINGS

eval>

(ACCESS

eval>

(SET!

==>

MEINE-UMGEBUNG

MEINE-UMGEBUNG) ==>

'(DEFINE

Y 6)

MEINE-UMGEBUNG)

(ACCESS

MEINE-UMGEBUNG) SELBST

(X

.

13))

(X

.

12))

MEINE-UMGEBUNG) ==>

SELBST

((SELBST)

==> Y

((Y ==>

. 6)

(SELBST)

NIL

MEINE-UMGEBUNG)

MEINE-UMGEBUNG) ==>

NIL

9. Generierte Zugriffskonstrukte

eval>

(ENVIRONMENT-BINDINGS ==>

eval> ;;;;

257

(ACCESS

((Y

X (ACCESS

MEINE-UMGEBUNG)

. 6)

(SELBST

SELBST

. #)

MEINE-UMGEBUNG))

==>

(X

.

13))

13

Makro/Funktions-Gegenüberstellung

eval>

(DEFINE

F00 6 )

eval>

(DEFINE

CALL-BY-VALUE-DEMO

(LAMBDA

6

(X)

(SET! (-

==>

X (*

X

X FOO)))

X)) ==>

eval>

(CALL-BY-VALUE-DEMO

eval>

FOO = = >

CALL-BY-VALUE-DEMO FOO) = = >

30

6

e v a l X MACRO C A L L - B Y - R E F E R E N C E - D E M O (LAMBDA

(SEXPR)

'(BEGIN (SET! (-

,(CADR

,(CADR

eval>

(DEFINE

eval>

(EXPAND-MACRO

BAZ

6)

SEXPR)

SEXPR) ==>

(BEGIN

(CALL-BY-REFERENCE-DEMO

eval>

BAZ = = >

eval>

(CALL-BY-REFERENCE-DEMO FOO = = >

==>

SEXPR)

,

(CADR

SEXPR)))

CALL-BY-REFERENCE-DEMO

6

eval>

eva1>

,(CADR

'(CALL-BY-REFERENCE-DEMO ==>

==>

(*

FOO))))

(SET! BAZ)

BAZ ==>

(*

BAZ))

BAZ

BAZ))

(-

BAZ

FOO))

30

36 0

;Name d e r

FOO)

freien

Variablen

benutzt

!

36

9. Generierte Zugriffskonstrukte Dieser Abschnitt behandelt das automatische Generieren von Zugriffskonstrukten. Für die Liste, die A-Liste oder die P-Liste, konnten wir die primitiven, eingebauten Konstruktoren, Selektoren, Prädikate und Mutatoren nutzen, um damit unseren anwendungsspezifischen Verbund zu konstruieren. War auf ein bestimmtes Feld einer A-Liste zuzugreifen z.B. auf das Feld NAME-DES-KONTOINHABERS, dann konnte mit dem ASSQ-Konstrukt eine entsprechenden Selektor, wie folgt, definiert werden (vgl. Abschnitt 5.2).

258

II. Konstruktionen (Analyse und Synthese)

eval> (DEFINE NAME-DES-KONTOINHABERS (LAMBDA (A_LISTE) (ASSQ 'NAME-DES-KONTO INHABE RS A.LISTE))) ==> NAME-DES-KONTOINHABERS Neben den Selektoren sind die Prädikate und Mutatoren ebenfalls aus den eingebauten Grundfunktionen selbst zu konstruieren. Solche Definitionen können direkt vom LISP-System generiert werden. Zum Zeitpunkt der Definition einer Datenstruktur sind unter Angabe einiger Steuerungsparameter die Konstrukte des Verbundes generierbar. Dazu dient in LISP-Sytemen das DEFINE-STRUCTURE-Konstrukt (Abschnitt 9.2). Vorab betrachten wir das Konzept der „passiven" Daten primär aus der Sicht „aktiver" Zugriffskonstrukte. Erörtert wird das Konzept abstrakter Datentypen (Abschnitt 9.1). Wesentlicher Vorteil ist die Rückgriffsmöglichkeit auf existierende Datentypen bei der Definition neuer Datentypen. Es werden Eigenschaften von existierenden Datentypen auf neue „vererbt". Wir zeigen die einfache statischen Vererbung (Abschnitt 9.3). Die multiple dynamische Vererbung wird im Zusammenhang mit Klassen-Instanz-Konzepten behandelt (Abschnitt 10.2).

9.1 Abschirmung von Weiten Definieren wir ein Konstrukt, dann bemühen wir uns mit den gewählten Symbolen und Strukturen eine gedankliche Verknüpfung zwischen realen und formalen „Einheiten" (Objekten) herzustellen. Entsprechend dem jeweiligen Denkrahmen (Paradigma, vgl. Abschnitt 4) und den Möglichkeiten seiner Umsetzung betonen wir eine „passive" (daten-/wert-bezogene) oder „aktive" (operations-bezogene) Sicht (vgl. Abschnitt 2). Lösen wir eine kleine Programmieraufgabe wie das Verwalten einigen Postanschriften, dann werden wir im imperativgeprägten Denkrahmen frühzeitig die benötigten Speicherplätze benennen und ordnen. Wir definieren eine passive Datenstruktur. Eine solche Datenstruktur zeigt Bild 9.1-1. Sie ist in COBOL, einer der Programmiersprache für das imperativgeprägte Paradigma, formuliert. Wir haben früh Angaben über die Wertbereiche der einzelnen Felder bereitgestellt. Aufgrund der PICTURE-Angabe ist die Variable ZUNAME maximal 30 Zeichen lang, während die POSTLEITZAHL eine Zahl mit 4 Ziffern ist. Der Wertebereich eines Feldes ist hier mit der PICTURE-Klausel durch eine Längenangabe und einen Verweis auf einen eingebauten Datentyp definiert. Mit den Namen dieser Datenstruktur werden Schritt für Schritt benötigte Operationen durchdacht und spezifiziert. Eine Operation DRUCKE-ADRESSAUFKLEBER enthält dann beispielsweise eine Formulierung: „BILDEDRUCKZEILE aus TITEL, VORNAME und ZUNAME. Falls die Zeilenlänge gößer als 25 Zeichen ist, dann nimm vom Feld TITEL die ersten drei Zei-

9. Generierte Zugriffskonstrukte

259

01 ADRESSE. 05 NAME. 10 ZUNAME 10 VORNAME 10 T I T E L 0 5 WOHNORT. 10 S T R A S S E 10 P O S T L E I T Z A H L 10 ORT 05 KOMMUNIKATION. 10 T E L E F O N 10 T E L E F A X 10 E - M A I L 05 S O N S T I G E S . 10 STOCKWERK 10 POSTFACH

PICTURE PICTURE PICTURE

X(30 ). X(30 ). X(10).

PICTURE X(20 ). PICTURE 9 ( 4 ) . PICTURE X(30 ). PICTURE PICTURE PICTURE

X(15). X(15). X ( 15 ) .

PICTURE PICTURE

99. 9(5).

Legende: 01

. . . 10

PICTURE PICTURE Bild

: : = Gruppennummern

zur S t r u k t u r i e r u n g

X(30)

::=

Feld

f ü r 30 a l p h a n u m e r i s c h e

9(4)

::=

Feld

für eine

9 . 1 - 1.

Zahl

mit 4

Zeichen

Ziffern.

COBOL-Datendefinition

chen ...." Jetzt wird erkannt, daß man eine Operation KURZ-TITEL, die vom Feld TITEL die ersten drei Zeichen selektiert, benötigt. Im Kontext „passive" Datenstruktur bietet sich eine Änderung der TITEL-Definition, wie folgt, an: 10

TITEL. 15 K U R Z T I T E L 15 R E S T T I T E L

PICTURE PICTURE

X(3). X(7).

Mit dieser modifizierten TITEL-Definition kann man TITEL oder KURZTITEL drucken. Als Alternative wäre die Definition einer Operation KURZTITEL möglich, die im COBOL-Programm auf einer MOVE-Operation (assign Statement) beruhen würde. Im funktionsgeprägten Denkrahmen benennen wir frühzeitig Operation. Ihr schrittweises Durchdenken und Spezifizieren führt schließlich ebenfalls zu den abzubildenden „passiven" Einheiten (Daten). Wir hätten beispielsweise eine Funktion ADRESS-AUFKLEBER mit einem Argument ADRESSE definiert. Beim Konstruieren des Nebeneffektes WRITELN benötigen wir die Operationen GET-TITEL und GET-KURZTITEL. Auch jetzt können wir wieder für GET-KURZTITEL eine operationale Sicht umsetzten, d.h. in LISP ein LAMBDA-Konstrukt wählen. Dieses enthält die Operationen GET-TITEL und eine Verkürzungsoperation. Diese ist abhängig vom Typ des Wertes, den GETTITEL liefert. Ist es ein String, dann käme zum Verkürzen das SUBSTRING-

260

II. Konstruktionen (Analyse und Synthese)

Konstrukt in Betracht (vgl. Abschnitt 7.2). Ist es eine Symbol, wäre ein EXPLODE-Konstrukt notwendig (vgl. Abschnitt 7.3). Im imperativgeprägten Denkrahmen wurden frühzeitig die Wertebereiche der Felder beschrieben. Wir haben in den Kategorien wie Länge und primitiven Beschreibungstyp der Wertebereichsspezifikation gedacht. Holzschnittartig formuliert: Die Speicherplatzkonditionen prägen diese Denkwelt. Ausgangspunkt für die Problemdurchdringung ist die Frage: Wie werden die anwendungsspezifischen Daten repräsentiert? Im funktionsgeprägten Denkrahmen kannten wir zum Zeitpunkt der Operation ADRESS-AUFKLEBER weder die Länge des Feldes noch mußte schon der Wertebereich mit eingebauten bzw. bekannten Datentypen präzisiert werden. Erst mit der Definition von GET-KURZTITEL sind Angaben über den Wertebereich entsprechend zu präzisieren. Mit einem Denken in der Kategorie Zugriffskonstrukt verschieben wir eine solche, implementationsabhängige Beschreibung. Wir können zunächst davon abstrahieren, ob die Daten z.B. vom Typ STRING, VECTOR oder SYMBOL sind. Wir durchdenken und spezifizieren unsere Konstruktion in der Kategorie Zugriffskonstrukte. Ausgangspunkt für die Problemdurchdringung ist die Frage: Welche anwendungsspezifischen Operationen sind mit Daten notwendig? Beide Ansätze sind voneinander abhängig. Immer dann, wenn ein Problem wenig durchschaut wird, ist ein Wechselspiel zwischen beiden Ansätzen zur Korrektur der ersten Lösungsentwürfen erforderlich. Änderungen der „passiven" Datenstruktur werden durch Änderungen der „aktiven" Konstrukte (Operationen) hervorgerufen und umgekehrt. Die Definition von Zugriffskonstrukten bildet dabei eine Schnittstelle zwischen der Implementations- und der Verwendungs-Perspektive. Mit den Zugriffskonstrukten versuchen wir die Implementations-Anforderungen (Wertebeschreibungen in den Kategorien der eingebauten Konstrukte) von den Verwendungs-Anforderungen (anwendungsspezifischen Operationen) abzuschirmen. In LISP kann diese Schnittstelle „verheimlichen", ob nur auf die Wertzelle eines Symbols zugegriffen oder ein LAMBDA-Konstrukt appliziert wird. Im ersten Fall haben wir es mit dem Zugriff auf ein „passives" Datum zu tun. Im zweiten Fall geht es um eine Funktionsanwendung, d.h. um ein „aktives" Datum. Beide Arten von Zugriffskonstrukten sind mit der Datenstruktur-Definition automatisch generierbar. Das DEFINE-STRUCTURE-Konstrukt erzeugt „passive" Zugriffskonstrukte (Abschnitt 9.2). Das Generieren von „aktiven" Zugriffskonstrukten („aktiven Slots") ist Bestandteil des Klassen-Instanz-Konzeptes. Wir behandeln es daher nach SCOOPS (Abschnitt 10.3.). Zum Verständnis des DEFINE-STRUCTURE-Konstruktes betrachten wir erneut unsere Konten Verwaltung (Abschnitt 8.4). Dabei konstruieren wir die neue Struktur VERWAHRKONTO aus der definierten Struktur KONTO. Verdeut-

261

9. Generierte Zugriffskonstrukte

licht wird damit der „Vererbungsmechanismus" des DEFINE-STRUCTUREKonstruktes (vgl. Abschnitt 9.3).

9.2 DEFINE-STRUCTURE-Konstrukt Mit dem DEFINE-STRUCTURE-Konstrukt (auch DEFSTRUCT genannt, z.B. in Common LISP) definieren wir eine (Datensatz-)Struktur aus Feldern (engl.: slots) mit gegebenenfalls voreingestellten Werten (engl.: default values) gemeinsam mit ihren Selektoren, Prädikaten und Mutatoren. Das DEFINE-STRUCTURE-Konstrukt ermöglicht den Zugriff auf bereits definierte Struturen. Neue Strukturen lassen sich aus bestehenden zusammenbauen. Vorteilhaft ist dabei, daß jeweils die Operationen für das Zugreifen und Ändern der Feldwerte unmittelbar vom LISP-System bereitgestellt werden. Sie müssen nicht erst selbst definiert werden. Das DEFINE-STRUCTURE-Konstrukt hat ohne Vererbungsoption die folgende Syntax. Die Vererbungsoption behandeln wir anschließend (vgl. Abschnit 9.3). eval>

(DEFINE-STRUCTURE

{}) ==> < s t r u c t u r e - n a m e >

mit:



::= Ein Symbol, das die Struktur

benennt.

::= ( | < d e f a u l t - v a l u e > ) ::= Ein Symbol, das das Feld

benennt.

::= Ein symbolischer A u s d r u c k , dessen Evaluierung den v o r e i n g e s t e l l t e n Wert für das Feld ergibt.

Als Nebeneffekt werden bei der Applikation des DEFINE-STRUCTUREKonstruktes folgende Operatoren generiert: o Ein Konstruktor: MAKE-, o ein Prädikat:

?,

o für jedes Feld einen Selektor: -

und

o für jedes Feld einen Mutator, d.h. die Möglichkeit seinen Wert mit Hilfe des SET!-Konstruktes zu ändern. (SET!

(-

)

;

/Hinweis: DEFINE-STRUCTURE-Makro. In PC Scheme ist das DEFINESTRUCTURE-Konstrukt als Makro implementiert. Seine „interne" Arbeitswei-

262

II. Konstruktionen (Analyse und Synthese)

se zeigt der expandierte Wert dieses Makros. Es basiert auf den Abbildungsoptionen Vektor und Eigenschaftsliste. eval> (EXPAND-MACRO ' ( D E F I N E - S T R U C T U R E F00 (A 1) (B 2))) = = > (BEGIN (PUTPROP 'F00 '((|#!STRUCTURE| . F00)) '%TAG) (PUTPROP 'FOO * ((B 2 . 2) (A 1 . 1)) '7.SL0T-VALUES) ( D E F I N E - I N T E G R A B L E FOO-B (LAMBDA (OBJ) ( V E C T O R - R E F O B J 2 ) ) ) ( D E F I N E - I N T E G R A B L E FOO-A (LAMBDA (OBJ) ( V E C T O R - R E F O B J 1))) (DEFINE F00? (LAMBDA (OBJ) ( % S T R U C T U R E - P R E D I C A T E O B J '(!#1 S T R U C T U R E I . F00)))) (DEFINE M A K E - F 0 0 (LAMBDA %DS0002% (LET ((%DS0001% (MAKE-VECTOR 3 '()))) (VECTOR-SET! %DS0001% 0 (GETPROP 'F00 '%TAG)) (VECTOR-SET! %DS0001% 1 1) (VECTOR-SET! %DS0001% 2 2) (IF (NULL? % D S 0 0 0 2 % ) %DS0001% ( % M A K E - S T R U C T U R E 'FOO 'MAKE-FOO %DS0001% %DS0002%))))) •FOO) Das %STRUCTURE-PREDICATE-Konstrukt ist eine LISP-Funktion, gebunden in USER-GLOBAL-ENVIRONMENT. Das DEFINE-INTEGRABLEKonstrukt ist ein Makro, das zu folgendem Ausdruck expandiert: eval> (EXPAND-MACRO

' ( D E F I N E - I N T E G R A B L E FOO-A (LAMBDA (OBJ) ( V E C T O R - R E F O B J 1))) = = >

(BEGIN (PUTPROP 'FOO-A (CONS ' D E F I N E - I N T E G R A B L E '(LAMBDA (OBJ) ( V E C T O R - R E F O B J 1))) 'PCS*PRIMOP-HANDLER) 'FOO-A)

Die obige Eigenschaft PCS*PRIMOP-HANDLER wirkt bei der Auswertung wie eine Bindung von FOO-A an (LAMBDA (OBJ) (VECTOR-REF OBJ 1)); vgl. Abschnitt 5.3, Hinweis PCS*PRIMOP-HANDLER)J Für unsere Kontenverwaltung (vgl. Abschnit 8.4) formulieren wir folgende Struktur: eval> ( D E F I N E - S T R U C T U R E KONTO ( I D E N T I F I Z I E R U N G 0) (NAME-INHABER NIL) ( A D R E S S E - I N H A B E R NIL) (EINZAHLUNGEN N I L ) (AUSZAHLUNGEN N I L ) (KONTOSTAND 0)) = = > KONTO

9. Generierte Zugriffskonstrukte

263

Konstruktor:

Mit Hilfe des Konstruktors MAKE-KONTO legen wir die beiden Konten A001 und A002 an. Die generierte MAKE-KONTO-Funktion kann die voreingestellten Werte überschreiben. Dazu sind und als Argumente anzugeben. eval> (DEFINE A001 (MAKE-KONTO)) ==> A001 eval> (DEFINE A002 (MAKE-KONTO •IDENTIFIZIERUNG 'A002 'NAME-INHABER "H. Bonin" 'ADRESSE-INHABER "D-2120 Lueneburg")) ==> A002 Das MAKE-KONTO-Konstrukt erzeugt in Scheme einen Vektor. Das erste Vektorfeld speichert entsprechend einer A-Liste den Namen der Struktur. eval> A001 ==> #(((!#!STRUCTURE¡ . KONTO)) 0 O O O () 0) eval> A002 ==> #(((!#!STRUCTURE¡ . KONTO)) A002 "H. Bonin" "D-2120 Lueneburg" O () 0) Prädikat:

Das generierte Prädikat KONTO? erkennt Objekte, die mit dem MAKEKONTO-Konstrukt erzeugt wurden. eval> (KONTO? A001) ==> #T eval> (DEFINE F00 (VECTOR 'IDENTIFIZIERUNG 'NAME -1NHABER)) ==> F00 eval> (KONTO? F00) ==> () eval> (KONTO? #(((ÜSTRUCTURE¡ . KONTO)) A002 O () 0)) ==> #T ¡Achtung! Umgehen des MAKE-Konstruktes Selektor:

Für den Zugriff auf die einzelnen Felder hat das DEFINE-STRUCTUREKonstrukt Selektoren generiert. Ihr Name setzt sich aus dem Präfix Strukturnamen, gefolgt von einem Bindestrich und dem Feldnamen, zusammen. eval> (KONTO-ADRESSE-INHABER A002) ==> "D-2120 Lueneburg" eval> (KONTO-KONTOSTAND A001) ==> 0 Diese generierten Selektoren benutzen wir zum Definieren der Funktion DESCRIBE-KONTO. Sie stellt die aktuellen Werte eines Kontos dar. eval> (DEFINE DESCRIBE - KONTO (LAMBDA (K_IDENT) (COND ((KONTO? K_IDENT) (NEWLINE) (WRITELN " Inhalt des Kontos: " (KONTO-IDENTIFIZIERUNG K_IDENT)

264

II. Konstruktionen (Analyse und Synthese) (WRITELN "Name-Inhaber: ( K O N T O - N A M E - I N H A B E R K_IDENT)) (WRITELN "Adresse-Inhaber: " ( K O N T O - A D R E S S E - I N H A B E R K_IDENT)) (WRITELN "Einzahlungen: ") (PP ( K O N T O - E I N Z A H L U N G E N K_IDENT)) (NEWLINE) (WRITELN "Auszahlungen: ") (PP ( K O N T O - A U S Z A H L U N G E N K_IDENT) ) (NEWLINE) (WRITELN "Kontostand: ( K O N T O - K O N T O S T A N D K_IDENT)) *THE-NON-PRINTING-OBJECT*) (T (ERROR "Kein Konto: " K _ I D E N T ) ) ) ) ) ==> D E S C R I B E - K O N T O

Die folgenden Konstrukte zum Buchen von Ein- und Auszahlungen unterscheiden sich gegenüber der Lösung in Abschnitt 8.4 nur durch die generierten Selektoren und die zugehörenden Mutatoren auf der Basis des SET!-Konstruktes. Sie bedürfen daher keiner weiteren Erläuterung. eval> (DEFINE BETRAG? (LAMBDA (X) (AND (NUMBER? X) (>= X 0)))) = = > BETRAG? eva1> (DEFINE B U C H U N G S D A T U M ? (LAMBDA (X) (AND (NUMBER? X) (>= X 8 9 0 1 0 1 ) ) ) ) ==> B U C H U N G S D A T U M ? eval> (DEFINE ADD - EINZAHLUNGi (LAMBDA (K_ID E N T E_DATUM BETRAG) (COND ((AND (KONTO? K_IDENT) ( B U C H U N G S D A T U M ? E.DATUM) (BETRAG? BETRAG)) (SET! ( K O N T O - E I N Z A H L U N G E N K_IDENT) (CONS (LIST E.DATUM BETRAG) ( K O N T O - E I N Z A H L U N G E N K_IDENT))) (SET! ( K O N T O - K O N T O S T A N D K_IDENT) (+ BETRAG ( K 0 N T 0 - K 0 N T 0 S T A N D K_IDENT))) ( K 0 N T 0 - K 0 N T 0 S T A N D K_IDENT)) (T (ERROR "Keine Einzahlung h i n z u g e f u e g t ! " K_IDENT E.DATUM B E T R A G ) ) ) ) ) = = > A D D - E I N Z A H L U N G ! eval> (DEFINE A D D - A U S Z A H L U N G ! (LAMBDA (K_IDENT A_DATUM BETRAG) (COND ((AND (KONTO? K_IDENT) (BUCHUNGSDATUM? A_DATUM) (BETRAG? BETRAG)) (COND (( A D D - A U S Z A H L U N G !

9. Generierte Zugriffskonstrukte eval>

265

(DEFINE A E N D E R E - K O N T O - 1 D E N T I F I Z I E R U N G ! (LAMBDA (K_IDENT_ALT K_IDENT_NEU) (COND ((KONTO? (EVAL '(ACCESS , K_ID E N T_ N E U USER-INITIAL-ENVIRONMENT))) (ERROR "Neue Kontonummer ist belegt: " K_IOENT_NEU)) ((KONTO? (EVAL '(ACCESS ,K_IDENT_ALT USER-INITIAL-ENVIRONMENT))) (EVAL "(DEFINE .K_IDENT_NEU (EVAL ,K_IDENT_ALT))) (EVAL '(SET! ( K O N T O - I D E N T I F I Z I E R U N G ,K_IDENT_NEU) ' , K_ I DENT_NEU )) (EVAL '(UNBIND ',K_IDENT_ALT USER-INITIAL-ENVIRONMENT))) (T (ERROR "Alte Kontonummer e x i s t i e r t nicht: " K_IDENT_ALT))))) ==> A E N D E R E - K O N T O - I D E N T I F I Z I E R U N G

Wir nehmen an, daß neben den Konten der bisherigen Kontenstruktur andere Konten mit den beiden zusätzlichen Eigenschaften BUCHUNGSGRUND und BEARBEITER benötigt werden. Ein solches erweitertes Konto sei z.B. ein Verwahrkonto, d.h. ein Konto auf dem dubiose Vorgänge zwischengebucht werden. Zur Definition der Struktur VERWAHRKONTO sind nicht alle Felder (slots) neu zu beschreiben. Die Struktur VERWAHRKONTO kann auf der definierten Struktur KONTO aufbauen. Oder aus der entgegengesetzten Blickrichtung formuliert: Die Struktur VERWAHRKONTO erbt die Felder der Struktur KONTO.

9.3 Einfache statische Vererbung Vererbung ist die Übertragung von körperlichen und seelischen Merkmalen der Eltern auf die Nachkommen. Angelehnt an diese biologische Betrachtung wäre für LISP-Systeme die „Genetik" von der "Klassifikation" zu unterscheiden. Genetische Vererbung führt nicht zur Weitergabe jeder Eigenschaft eines Objektes. Holzschnittartig formulierte: „Wenn die Mutter eine schmale Nase hat, kann die Tochter eine dicke haben." Die Klassifikation entspricht der Wiederanwendbarkeit einer Beschreibung beim Nachkommen (zur mathematischen Betrachtung der Vererbung vgl. z.B. Touretzky, 1986). Außerdem ist mit dem Begriff Vererbung noch ein Modus "letzter Wille/Testament" assoziierbar. Dieser steht für (fast) völlig freies Weitergeben. Der Mechanismus des DEFINE-STRUCTURE-Konstruktes vererbt alle Felder mit ihren voreingestellten Werten. Er hat folgende Syntax: eval>

(DEFINE-STRUCTURE (

(INCLUDE < p a r e n t - n a m e > ) ) { KLASSE-I eval> (KLASSE-I-SLOT-3 F00) ==> OTTO ¡Achtung! FunKtioniertin PC Scheme ; Version 3.03 n i c h t .

Für das Propagieren einer solchen Änderung bedarf es der dynamischen Vererbung. Zunächst erörtern wir den Aspekt „multiple Vererbung" (Abschnitt 10.1) und dann den Aspekt „dynamische Vererbung" (Abschnitt 10.2).

9.4 Zusammenfassung: Zugriffskonstrukte als Schnittstelle Das DEFINE-STRUCTURE-Konstrukt generiert den Verbund von Konstruktor, Selektor, Prädikat und Mutator. Der Konstruktor MAKE- bildet ein Objekt mit den Feldern (engl.: slots) und initialisiert diese mit voreingestellten Werten (engl.: default values). Ein generierter Selektor besteht aus dem Strukturnamen und dem Feldnamen, verbunden durch einen Bindestrich. Das Prädikat hat als Namen den Strukturnamen ergänzt um ein Fragezeichen am Namensende. Ein Feldinhalt einer mit MAKE- gebildeten Struktur ist mit dem SET!-Konstrukt modifizierbar. Das erste Argument des SET!-Konstruktes ist die Applikation des entsprechenden Sclcktors Das DEFINE-STRUCTURE-Konstrukt ermöglicht mit der INCLUDE-Angabe eine einfache statische Vererbung. Eine Struktur kann auf einer vorher definierten Struktur aufbauen.

II. Konstruktionen (Analyse und Synthese)

270

Charakteristisches ;;;; ;;;; ;;;;

Beispiel für Abschnitt 9:

E i n f a c h e r Bestimmungs-Baum ( e n g l . : d i s c r i m i n a t i o n t r e e ) ( N ä h e r e s z u r K o n s t r u k t i o n von "discrimination nets" v g l . z.B. Charniak u . a . , 1987)

eval>

(DEFINE-STRUCTURE

BAUM-BLATT

eval>

(DEFINE-STRUCTURE

KNOTEN T E S T

eval>

(DEFINE (COND

BESTIMMUNG

(LAMBOA

((BAUM-BLATT? ((KNOTEN?

WERT) JA

(SEXPR

BAUM)

==>

NEIN)

BAUM-BLATT ==>

KNOTEN

BAUM)

(BAUM-BLATT-WERT

BAUM))

BAUM)

(BESTIMMUNG SEXPR (NAECHSTER-KNOTEN ((KNOTEN-TEST

BAUM)

SEXPR)

BAUM))) (T eval>

(DEFINE (IF

NIL))))

==>

NAECHSTER-KNOTEN

(LAMBDA

(TEST-ERGEBNIS

BAUM)

TEST-ERGEBNIS (KNOTEN-JA

BAUM)

(KNOTEN-NEIN eval>

BESTIMMUNG

(DEFINE

BAUM))))

==>

NAECHSTER-KNOTEN

*LISP-TYPEN*

(MAKE-KNOTEN 'TEST •JA

VECTOR?

(MAKE-BAUM-BLATT

'WERT

"Vektor")

'NEIN (MAKE-KNOTEN 'TEST 'JA

PAIR?

(MAKE-BAUM-BLATT

'WERT

"Paar")

'NEIN (MAKE-KNOTEN 'TEST 'JA

SYMBOL?

(MAKE-BAUM-BLATT

'WERT

"Symbol")

'NEIN (MAKE-KNOTEN 'TEST 'JA

NUMBER?

(MAKE-BAUM-BLATT

'WERT

"Zahl")

'NEIN (MAKE-BAUM-BLATT

eval>

(BESTIMMUNG

))))

==

'FOO

* L I SP-TY PEN*)

'WERT

"Unbekannt"))

*LISP-TYPEN* ==>

"Symbol"

10. Klasse-Instanz-Modell

271

10. Klasse-Instanz-Modell Die Realisierung von Klassen-Instanz-Modellen hat in LISP eine lange Tradition. Als charakteristische Vertreter gelten die beiden Systeme „Common LOOPS" und „Flavors" (vgl. Bonin, 1989): o CommonLOOPS (Common LISP Object-Oriented Programming System, vgl. Bobrow u.a., 1986) CommonLOOPS, implementiert in Common LISP, realisiert die Objektorientierung mit generischen Funktionen, so daß normale LISP-Funktionen und Methoden syntaktisch einheitlich gehandhabt werden können. Meta-Objekte sind eine charakteristische CommonLOOPS-Eigenschaft. o (New) Flavors (vgl. Weinreb/Moon, 1981; Moon, 1986) Das Flavor-System wurde ursprünglich für die LISP-Maschine entwickelt (vgl. Anhang B). Im Mittelpunkt steht ein „Mixen" von Teilkomponenten durch multiple Vererbung. Dieser „mixin style" begründet den außergewöhnlichen Namen Flavor. Durch das Mischen von verschiedenen Flavors erhält man einen neuen Flavor. Dabei schmeckt man beim Zusammenmischen die einzelnen Komponenten bis hin zur Systemwurzel „Vanilla-flavor". Selbst kleine PC-orientierte LISP-Implementationen ermöglichen den Umgang mit Klassen und Instanzen. Ohne großen Aufwand kann ein LISP-System für eine objektgepräget Programmierung erweitert werden (vgl. z.B. DiPrimo/Christaller, 1983; Beckstein, 1985, Brewka u.a., 1987; Kessler, 1988 oder FISCH, 1988). Entstanden ist daher eine Vielfalt von LISP-Erweiterungen. Sie weisen wesentliche Unterschiede in ihren Konstrukten und in ihrer Terminologie auf. Begriffe wie Objekt, Klasse, Instanz, Methode oder Funktion werden unterschiedlich gehandhabt. Diese Sprach- und Konstrukte-Vielfalt war Veranlassung einen leistungsfähigen Standard zu schaffen. Die amerikanischen Standardisierungsbemühungen haben zum „Common LISP Object System", kurz CLOS, geführt (vgl. ANSI X3J13; Bobrow/Moon u.a., 1988). In Bild 10-1 sind die CLOS-Bausteine genannt. Die CLOS-Charakteristika zeigt Bild 10-2. Mit dem DEFINE-STRUCTURE-Konstrukt ist eine „Klasse" (Struktur) auf der Basis einer existierenden Klasse definierbar (vgl. Abschnitt 9.3). Vererbt werden dabei die „slots" einer Klasse. Ein wesentliches Leistungsmerkmal eines Klassen-Instanz-Modells ist die multiple Vererbung, d.h. die Möglichkeit neue Klassen durch Rückgriff auf die Eigenschaften von mehreren Klassen zu definieren (vgl. Bild 10-2). Ein weiteres Beurteilungskriterium ist der Zeitpunkt der Vererbung. Hierbei ist zwischen statischer und dynamischer Vererbung zu unterscheiden. Die multiple Vererbung verdeutlichen wir anhand der Erweiterung unsere Kontenverwaltung (vgl. Abschnitte 8.4 und 9.2). Die Klasse VERWAHRKONTO erbt zusätzlich zu den Eigenschaften der Klasse KONTO die Eigenschaften einer Klasse OFFENER-VORGANG (vgl. Bild 10-3). Die Klasse OFFENER-

II. Konstruktionen (Analyse und Synthese)

272

Instanz

]

>

Eine K l a s s e b e s t i m m t die Struktur und das V e r h a l t e n einer M e n g e v o n O b j e k t e n , d i e Instanzen genannt werden.

Generi sehe F u n k t i on Methode

]

>

Eine M e t h o d e d e f i n i e r t die klassenspezifische Operation einer generischen Funktion ("Gattungsfunktion")

Kl a s s e

Bild

10-1.

Common

-,

"Common- LI SP -Object - Objekttypen -

•

> Deklarative

System

-

>

10-2.

(generische Funktionen)

Vererbung

Object

Bild

-Baus te i ne

> Gattungsfunktionen > Multiple

LISP

-System"

Methodenkombination

Meta-Objekt-Protokol1 "Common-LISP-Object-System"-Charakter!stika

V O R G A N G definiert z.B. für die Klasse V E R W A H R K O N T O das bisher nicht vorhandene Feld A K T E N Z E I C H E N .

10.1 Scheme Object-Oriented Programming System (SCOOPS) Im folgenden nutzen wir SCOOPS-Konstrukte von PC Scheme, um damit objektgeprägte Konstruktionen allgemein zu erläutern. Scheme Object-Oriented Programming System (kurz: SCOOPS) ist ein kleines Flavor-System. Seine multiple Vererbung basiert auf einer "mixin"-Option im Definitions-Konstrukt der Klasse. Instanzen werden analog zum DEFINE-STRUCTURE-Konstrukt mit einem MAKE-Konstrukt erzeugt. Der Zugriff auf die Slots einer Instanz, d.h. auf ihren lokalen Wert, erfolgt mit Hilfe des SEND-Konstruktes. Die von SCOOPS generierten Selektoren und Mutatoren sind an das jeweilige Objekt (Instanz oder Klasse) im Sinne einer Nachricht zu "senden". In der funktionsgeprägten Terminologie formuliert: Das SEND-Konstrukt hat als Argumente das Objekt, den Operationsnamen und gegebenenfalls Argumente für die Operation. Weil wir einen Selektor oder Mutator mit dem SEND-Konstrukt an ein Objekt „übermittelt", betrachten wir diese in der ob-

10. Klasse-Instanz-Modell

Legende: A > B

Bild

::= Vererbungsrichtung; (Anders f o r m u l i e r t :

O

::=

Klasse

•

::=

Instanz

10-3.

273

A v e r e r b t an B. B e r b t von A)

Beispiel einer multiplen Vererbung: VERWAHRKONTO e r b t von KONTO und OFFENER-VORGANG

jektgeprägten Terminologie als eine "Nachricht" (engl.: message), die das Objekt empfängt und verarbeitet. Aus der Kommunikationsicht (Nachrichtenübermittlung) können wir formuliern: Empfängt ein Objekt eine Nachricht, dann interpretiert es die Nachricht, d.h. es ermittelt die zu applizierenden (Teil-)Operationen und führt diese aus. Eine Nachricht kann mehrere (Teil-)Operationen betreffen. Wir sprechen in diesem Kontext eher von Methoden (engl.: methods) statt von Operationen oder Funktionen. Eine Methode ist eine Funktion, die als Reaktion auf eine zugehörende Nachricht ausgeführt wird. Sie ist einer Klasse zugeordnet. Die Vererbung bezieht sich daher sowohl auf die lokalen Zustandsbeschreibungen („slots") wie auf die generierten Selektions-/Mutations-Funktionen und die selbst definierten Funktionen („methods"). /Hinweis: SCOOPS.FSL. Die SCOOPS-Konstrukte sind in der Systemdatei SCOOPS.FSL gespeichert. Diese Datei ist vorab zu laden, damit die SCOOPS-

274

II. Konstruktionen (Analyse und Synthese)

Konstrukte in der USER-INITIAL-ENVIRONMENT zugreifbarsind. eval> (LOAD"SCOOPS.FSL")==>OK ] Das Klasse-Instanz-Modell o DEFINE-CLASS o MAKE-INSTANCE o DEFINE-METHOD und o SEND

basiert auf den folgenden Konstrukten: ;Definiert die Slots ;Kreiert lokale Zustände ;Definiert eine eigene Methode ¡"Versendet" eine Nachricht ; (engl.: message handling).

/Hinweis: Eine Modifikation des implementierten Vererbungsmechanismus ist in SCOOPS nicht vorgesehen. Das mächtige CLOS ermöglicht eine weitreichende Beeinflussung über die deklarative Methodenkombination und über das Meta-Objekt-Protokoll (vgl. z.B. Keene, 1989).7 Zunächst betrachten wir die Syntax dieser SCOOPS-Konstrukte. Anschließend definieren wir damit unsere Kontenverwaltung an. eval>

(DEFINE-CLASS {(INSTVARS < s l o t > { < s l o t > } )} {(CLASSVARS < s l o t > { < s l o t > } )} {(MIXINS { < c o m p o n e n t - c l a s s > } )} {(OPTIONS { < g e t t a b l e - v a r i a b l e s > } {) {} )} — >

mit:



: := E i n S y m b o l , d a s d i e Klasse benennt.

(zu

definierende)

::= | ( < i n i t - v a l u e > ) I ( (ACTIVE < i n i t - v a l u e >

)) : : = Ein Symbol, benennt.

d a s den S l o t

(das

Feld)

::=

Ein s y m b o l i s c h e r Ausdruck, dessen Eval u i e r u n g den v o r e i n g e s t e l l t e n Wert ( I n i t i a l i s i e r u n g s w e r t ) f ü r den S l o t ergi bt.

::=

Eine F u n k t i o n mit e i n e r LAMBDA-Variab l e n . W i r d m i t dem g e n e r i e r t e n S e l e k t o r G ET - < s 1 o t - n a m e > a u f den S l o t z u g e g r i f f e n , dann w i r d d i e L A M B D A - V a r i a b l e an den a k t u e l l e n Wert von < s l o t - n a m e > g e bunden und m i t d i e s e r B i n d u n g < g e t f u n c t i o n > a u s g e f ü h r t . Der Wert von < g e t - f u n c t i o n > i s t dann d e r R ü c k g a b e wert f ü r GET-.

275

10. Klasse-Instanz-Modell



::= E i n e F u n k t i o n m i t e i n e r L A M B D A - V a r i a blen. Wird mit dem g e n e r i e r t e n Mutator S E T - < s l o t - n a m e > ein < n e u e r - w e r t > für den Slot gesendet, dann wird die L A M B D A - V a r i a b l e an < n e u e r - w e r t > g e b u n den und mit d i e s e r Bindung a u s g e f ü h r t . Der W e r t v o n < s e t - f u n c t i o n > ist d a n n d e r n e u e W e r t von < s l o t - n a m e > . ::= E i n

Symbol,

das

eine

::= G E T T A B L E - V A R I A B L E S (GETTABLE-VARIABLES



eval>

Klasse

benennt.

|

(I

)

SETTABLE-VARIABLES I (SETTABLE-VARIABLES I 1 ) INITTABLE-VARIABLES I (INITTABLE-VARIABLES 11 ) ::= N a m e d e r e r z e u g t e n K l a s s e , an d e n als Wert die Repräsentation Vektor gebunden ist.

(MAKE-INSTANCE { }

) = >

mit:



eval > ( D E F I N E - M E T H O D

:= V g l .

DEFINE-CLASS

:= E i n e V a r i a b l e , d e r e n W e r t e i n g ü l t i g e r < s l o t - n a m e > ist. Diesem Slot wird der danach folgende Initialisierungswert zugewiesen, falls seine Initialisierungsoption definiert wurde. := V g l .

DEFINE-C LASS

:= E i n e I n s t a n z , repräsentiert

die durch wird.

eine

Umgebung

( ) ({}) ) — >

mit:

::= s i e h e

DEFINE-C LASS

::= Ein S y m b o l , d a s e i n e M e t h o d e Funktion) bezeichnet.

(LISP-

276

II. Konstruktionen (Analyse und Synthese)

eval>

(SEND

::= L A M B D A - V a r i a b l e ::= S y m b o l i s c h e r 1.4.1)

(vgl.

Ausdruck

{}

Abschnitt (vgl.

—=>

1.4.1)

Abschnitt

mit:



::= s i e h e

MAKE-INSTANCE

::= D e r N a m e e i n e r wird

zugreifbaren Methode. nicht evaluiert.

::= S y m b o l i s c h e r A u s d r u c k , d e r a u s g e w e r t e t wird. Die e n t s p r e c h e n d e L A M B D A - V a r i a b l e d e r zu a p p l i z i e r e n d e n M e t h o d e w i r d an d i e s e n W e r t g e b u n d e n . ( H i n w e i s : Es s i n d in S C O O P S d e r z e i t m a x i m a l 8 A r g u m e n t e

möglich.)

::= R ü c k g a b e w e r t

der

applizierten

Methode.

Für unsere Kontenverwaltung definieren wir als Ausgangsbasis zunächst die Klasse KONTO (vgl. auch Bild 10-3). Entsprechend der DEFINE-STRUCTURE-Lösung (vgl. Abschnitt 9.2) beschreibt die Klasse KONTO die Slots (Felder): IDENTIFIZIERUNG, NAME-INHABER, ADRESSE-INHABER; EINZAHLUNGEN, AUSZAHLUNGEN und KONTOSTAND. Jedem dieser Slots ist ein Initialisierungswert zugeordnet. Wir wollen ausschließen, daß über das SEND-Konstrukt mit Hilfe der generierten Mutatoren bestimmte Slots, hier: EINZAHLUNGEN, AUSZAHLUNGEN und KONTOSTAND, direkt verändert werden können. Daher ist das automatische Generieren dieser Mutatoren zu verhindern. Das DEFINE-CLASSKonstrukt bietet diese Möglichkeit. Im Rahmen der OPTIONS-Angabe ist festlegbar, ob Selektoren und/oder Mutatoren für einen bestimmten Slot zu generieren sind. Enthält die GETTABLE-VARIABLES- bzw. die SETTABLEVARIABLES-Angabe keine Slots, dann gilt sie für alle Slots. Ist ein Slot genannt, dann werden nur für genannte Slots die Methoden generiert. Ähnliches gilt für die INITTABLE-VARIABLES-Angabe. Die Option INITTABLES-VARIABLES generiert keine Methoden, sondern spezifiziert die Möglichkeit, beim Kreieren einer Instanz den voreingestellten Wert des Slots zu überschreiben. Mit der expliziten Nennung von Slots ist die Initialisierung beim MAKE-INSTANCE-Konstrukt nur für diese Slots möglich. eva1>

(DEFINE -CLASS KONTO ( I N S T V A R S ( I D E N T I F I Z I E R U N G 0) (NAME-INHABER NIL) ( A D R E S S E - I N H A B E R NIL) (EINZAHLUNGEN NIL)

10. Klasse-Instanz-Modell

277

(AUSZAHLUNGEN NIL) (KONTOSTAND 0)) (OPTIONS GETTABLE-VARIABLES (SETTABLE- VARIABLES IDENTIFIZIERUNG NAME-INHABER ADRESSE-INHABER) INITTABLE-VARIABLES)) ==> KONTO Konstruktor. Für das Kreieren eines Kontos ist das eingebaute Konstrukt MAKE-INSTANCE der Konstruktor im engeren Sinne. Da das MAKE-INSTANCE-Konstrukt vom DEFINE-CLASS-Konstrukt abhängig ist, verteilt sich die originäre Konstruktor-Aufgabe (Definition und Implementation) auf beide Konstrukte. Als Kontenbeispiele konstruieren wir A001 und A002, wie folgt: eval> (DEFINE A001 (MAKE-INSTANCE KONTO •IDENTIFIZIERUNG 'AOOl)) ==> A001 eval> (DEFINE A002 (MAKE-INSTANCE KONTO 'IDENTIFIZIERUNG 'A002 'NAME-INHABER "Hinrich Bonin")) ==> A002 Prädikat: Benötigt wird das Prädikat KONTO?. Unverständlicherweise generiert SCOOPS kein Prädikat, das festellen kann, ob ein Objekt vom Typ einer bestimmten Klasse ist. Um dieses Prädikat selbst zu definieren, wäre ein Prädikat CLASS? hilfreich. Das Prädikat CLASS? prüft z.B., ob dem MAKE-INSTANCE-Konstrukt ein korrektes Argument übergeben wird. Auch dieses Prädikat CLASS? ist in SCOOPS nicht eingebaut. Hilfsweise definieren wir ein eigenes Prädikat. Dieses Prädikat CLASS? muß auf die primitivere LISP-Repräsentation für die Klasse zurückgreifen. Da SCOOPS die Klasse als Vektor abbildet, basiert unser Prädikat CLASS? auf dem Prädikat VECTOR?. Da nicht jeder Vektor eine SCOOPS-Klasse repräsentiert, ist das Kennzeichen des KlassenVektors auszuwerten. Es steht im ersten Vektorfeld und hat den Wert :#!CLASS:. eval> (DEFINE CLASS? (LAMBDA (OBJEKT) (AND (VECTOR? OBJEKT) (EQ? *|#!CLASS| (VECTOR-REF OBJEKT 0 ) ) ) ) ) ==> CLASS? eval> (CLASS? KONTO) ==> #T Entsprechend dem Erkennungskonstrukt für den Typ Klasse ist ein Konstrukt zum Erkennen des Typs Instanz erforderlich. Auch hier müssen wir zur Definition einer Hilfslösung auf die primitivere LISP-Repräsentation zurückgreifen. Die Instanz ist in SCOOPS als Umgebung repräsentiert. Unser Prädikat IN-

II. Konstruktionen (Analyse und Synthese)

278

STANCE? basiert daher auf dem eingebauten Prädikat ENVIRONMENT?. Zur Erkennung einer Umgebung, die eine Instanz abbildet, dient das von SCOOPS verwendete Symbol % * I N S T V A R S * % . eval> eval>

( E N V I R O N M E N T ? A 0 0 1 ) = = > #T (ENVIRONMENT-BINDINGS A001) ==> ( ( I D E N T I F I Z I E R U N G . A 0 0 1 ) (NAME - 1 N H A B E R ) (ADRESSE-INHABER) (EINZAHLUNGEN) (AUSZAHLUNGEN) (KONTOSTAND) (%*INSTVARSn . -))

eval>

(DEFINE INSTANCE? (LAMBDA ( O B J E K T ) (AND ( E N V I R O N M E N T ? O B J E K T ) (NOT ( E Q ? '#!UNASSIGNED (ASSOC % * I N S T V A R S * %

eval> eval>

(INSTANCE? (INSTANCE?

OBJEKT)))))) ==>

INSTANCE?

A 0 0 1 ) = = > #T KONTO) = = > ( )

SCOOPS verfügt über einen Selektor CLASS-OF-OBJECT, der die Klasse einer Instanz als Rückgabewert hat. Das CLASS-OF-OBJECT-Konstrukt bedingt ein Argument vom Typ Instance. Ein Argument vom Typ Umgebung führt zum Fehler, so daß wir es nicht zur Konstruktion des Prädikates INSTANCE? verwenden können. eval> eval> eval> eval>

( C L A S S - O F - O B J E C T A 0 0 1 ) = = > KONTO ( D E F I N E F00 (LET ( ( X 1 ) ) ( T H E - E N V I R O N M E N T ) ) ) ( E N V I R O N M E N T ? F 0 0 ) = = > #T ( C L A S S - O F - O B J E C T F 0 0 ) = = > ERROR . . .

==>

F00

Mit den (hier ersatzweise selbstdefinierten) Prädikaten C L A S S ? und INSTANCE? ist das anwendungsspezifische Prädikat KONTO? konstruierbar. Eine Instanz ist vom Typ KONTO, wenn sie durch die Klasse KONTO entstanden ist. Anders formuliert, wenn sie Mitglied der Klasse KONTO ist. eval>

( D E F I N E KONTO? ( L A M B O A ( O B J E K T ) ( M E M B E R - O F - C L A S S ? KONTO O B J E K T ) ) )

==>

KONTO?

Das entsprechende MEMBER-OF-CLASS?-Konstrukt definieren wir mit Hilfe des eingebauten Selektors CLASS-OF-OBJECT. Ist ein Objekt vom Typ Klasse, dann ist in SCOOPS der Name der Klasse im 2. Vektorfeld gespeichert. Auch hier benötigen wir die Details der eigentlich zu verbergenden internen Vektorstruktur. eval>

(DEFINE MEMBER-OF-CLASS? (LAMBDA ( K L A S S E I N S T A N Z ) (AND ( C L A S S ? K L A S S E ) (INSTANCE? INSTANZ) ( E Q ? (VECTOR-REF KLASSE 1) (CLASS-OF-OBJECT INSTANZ))))) ==>

MEMBER-OF-CLASS?

279

10. Klasse-Instanz-Modell eval> eval> eval>

(KONTO? (KONTO? (CLASS?

A 0 0 1 ) = = > #T KONTO) ==> ( ) K O N T O ) ==> #T

Für unsere Kontenverwaltung benötigen wir wie im Fall der DEFINE-STRUCTURE-Lösung (vgl. Abschnitt 9.1) wieder die Prädikate B E T R A G ? und BUCHUNGSDATUM?. eval>

( D E F I N E BETRAG? (AND (NUMBER?

(LAMBDA (X) X) (>= X 0 ) ) ) )

eval>

( D E F I N E BUCHUNGSDATUM? (AND (NUMBER? X) (>=

==>

(LAMBDA ( X ) X 890101))))

BETRAG? ==>

BUCHUNGSDATUM?

Selektor. Aufgrund der optionalen Angabe GETTABLE-VARIABLES im DEFINECLASS-Konstrukt sind die gewünschten Selektoren für die einzelnen Slots generiert worden. Da für unsere Klasse KONTO nicht die Option „aktive Instanzvariable" genutzt wurde, greift der generierte Selektor direkt auf den Slotwert zu. Im Fall einer „aktiven Instanzvariablen" würde die zugehörende Zugriffsfunktion mit dem Slotwert appliziert, und ihr Rückgabewert wäre das Selektionsergebnis (vgl. z.B. Programmfragment 10.2-1). Die Namen der generierten Selektoren sind mit dem SEND-Konstrukt als Nachricht an die Instanzen zu „senden", wie die folgenden Beispiele zeigen: eval> eval> eval> eval>

(SEND (SEND (SEND (SEND

A001 A001 A002 A002

G E T - 1 D E N T I F I Z I E R U N G ) ==> A001 G E T - K 0 N T 0 S T A N D ) ==> 0 KONTOSTAND) ==> ERROR . . . ¡Undefinierte G E T - N A M E - I N H A B E R ) ==> " H i n r i c h B o n i n "

Methode

/Exkurs: "messagepassing". Im strengen Sinne des Nachrichtenversands verursacht das Senden einer Nachricht an jemanden ein (potentiell) asynchrones Anworten auf diese Nachricht. Beispiel: Der Sachbearbeiter sendet seinem Chef eine Nachricht. Wann er die Antwort erhält, bestimmt in der Regel der Chef. Zwischenzeitlich kann der Sachbearbeiter andere Aufgaben erledigen. Die SEND-Syntax suggeriert, daß ein solches „asynchrones" Antwortenverhalten vorliegt. In objekt-orientierten LISP-Erweiterungen bedeutet Nachrichtenversand das Heraussuchen einer Funktion und ihre Abarbeitung. Der Sender ist nicht in der Lage, zwischenzeitlich etwas anderes zu bearbeiten. Er wartet auf die Antwort. Senden einer Nachricht führt „nur" zur Applikation einer LISPFunktionJ Da in SCOOPS die Instanz eine Umgebung ist, in der die einzelnen Slot-Namen gebunden sind, kann innerhalb dieser Umgebung ohne den SEND-Mechanismus direkt auf die Slots zugegriffen werden. eval>

; ; Durchbrechen der S 1 o t - A b s c h i r m u n g ( E V A L N A M E - I N H A B E R A002) ==> " H i n r i c h

Bonin"

280

II. Konstruktionen (Analyse und Synthese)

Das Klasse-Instanz-Modell hat als ein wesentliches Merkmal die Abschirmung („Einkapselung") der internen Zustände ihrer Objekte (Klassen und Instanzen) gegen Zugriffe von außen, die nicht über die vorgesehene Schnittstelle laufen. /Exkurs: Einkapselung. Der gewünschte Objektzustand ist entscheidend für die Objektdefinition und für die Objektverwendung. Die Einkapselung (engl.: encapsulation) hat deshalb nur die Implementation zu verbergen und nicht den internen Objektzustand. Die Zusammenfassung aller Implementations-Informationen zu einem Objekt (Programmstück) und deren Abschirmung gegen direkte Zugriffe von anderen Programmteilen aus sichert die Modifizierbarkeit eines Objektes. Neben- und Fernwirkungen einer Objektänderung sind dadurch begrenzbar. Wäre jedoch eine Optimierung der Effizienz gefordert, dann hätte eine Streuung der Informationen über die Implementations-Details an viele Programmstellen Vorteile. Umwege über die Schnittstelle, d.h. hier über den Nachrichten Versandmechanismus, wären einsparbar.7 Ein Durchbrechen der Abschirmung der Implementationsdetails der Slots ist daher unbedingt zu vermeiden. Der Verweis auf die interne Repräsentation (Implementationsdetail) und damit auf die Umgehungsmöglichkeit der Schnittstelle dient hier ausschließlich zum Verstehen. Deutlich wird damit, warum wir bei der Definition von Methoden auf die Instanzvariablen ohne SEND-Mechanismus und ohne generierte GET-Selektoren direkt zugreifen können (vgl. die folgenden Beispiele für das DEFINE-METHOD-Konstrukt). Mutator. Wie Selektoren werden, abhängig von der optionalen SETTABLE-VARIABLES-Angabe, auch Mutatoren generiert, die über den SEND-Mechanismus anwendbar sind. eval>

eval>

(SEND A002 SET-ADRESSE-INHABER " F u h r e n k a m p 2a D - 2 8 5 8 S c h i f f d o r f " ) = = > " F u h r e n k a m p 2a D - 2 8 5 8 (SEND A002 SET-KONTOSTAND = = > ERROR . . . ¡ M u t a t o r

1000) SET-KONTOSTAND

nicht

Schiffdorf" definiert

!

Für unsere Konto Verwaltung werden die Mutatoren ADD-EINZAHLUNG! und ADD-AUSZAHLUNG! benötigt (vgl. Abschnitt 9.2). Wir definieren sie als Methoden, die der Klasse KONTO zugeordnet sind. Bevor eine Methode definiert werden kann, ist ihre Klasse mit DEFINE-CLASS zu definieren. Diese Beschränkung ist angebracht, da das System einerseits für die Methode einen zweckmäßigen Speicherplatz benötigt, um sie später wiederzufinden, und andererseits sollten der Methode aus Effizienzsgründen die Variablen bekannt sein, auf die sie direkt zugreifen kann (zumindest beim Compilieren). Bei der Definition der Methoden ADD-EINZAHLUNG! und ADD-AUSZAHLUNG! können wir direkt globale LISP-Konstrukte wie BETRAG? und

10. Klasse-Instanz-Modell

281

B U C H U N G S D A T U M ? verwenden; verfügbar sind alle Symbole der USER-INITIAL-ENVIRONMENT und der USER-GLOBAL-ENVIRONMENT. Zusätzlich sind diejenigen Instanz-Variablen direkt zugreifbar, die der Instanz gehören, auf die wir die Methode anwenden. Senden wir einer Instanz eine Nachricht, die unsere Methode zur Anwendung bringt, dann wird die Methode wie eine LISPFunktion in der Umgebung, die die Instanz repräsentiert, ausgeführt. Daher sind die Instanz-Variablen bei der Methodendefinition direkt verfügbar. eval>

(DEFINE-METHOD (COND

eval>

(KONTO A D D - E I N Z A H L U N G ! ) (E.DATUM BETRAG) ( ( A N D (BUCHUNGSDATUM? E.DATUM) (BETRAG? BETRAG)) ( S E T ! E I N Z A H L U N G E N (CONS ( L I S T E_DATUM B E T R A G ) EINZAHLUNGEN)) ( S E T ! KONTOSTAND ( + B E T R A G K O N T O S T A N D ) ) KONTOSTAND) ¡ P r o b l e m R ü c k g a b e w e r t ! ; Siehe Hinweis. (T ( E R R O R " K e i n e E i n z a h l u n g h i n z u g e f u e g t ! " E-DATUM B E T R A G ) ) ) ) = = > ADD-EINZAHLUNG!

(DEFINE-METHOD (COND

(KONTO A D D - A U S Z A H L U N G ! ) (A_DATUM B E T R A G ) ( ( A N D (BUCHUNGSDATUM? A_DATUM) (BETRAG? BETRAG)) (COND ( ( < = B E T R A G K O N T O S T A N D ) ( S E T ! AUSZAHLUNGEN (CONS ( L I S T A_DATUM B E T R A G ) AUSZAHLUNGEN)) ( S E T ! KONTOSTAND ( - KONTOSTAND B E T R A G ) ) KONTOSTAND) ¡ P r o b l e m R ü c k g a b e w e r t ! ; Siehe Hinweis. (T ( E R R O R " K e i n e D e c k u n g f u e r : " BETRAG)))) (T ( E R R O R " K e i n e A u s z a h l u n g m o e g l i c h ! " A_DATUM B E T R A G ) ) ) ) = = > A D D - A U S Z A H L U N G !

/Hinweis: Rückgabewert. Wird die Methode ADD-EINZAHLUNG! bzw. A D D - A U S Z A H L U N G ! angewendet, dann ist der hier definierte Rückgabewert der Wert des Slots K O N T O S T A N D . Falls wir Methoden wie Funktionen schachteln wollten, wäre es zweckmäßig, nicht den K O N T O S T A N D , sondern die ganze Instanz zurückzugeben. Notwendig wäre dazu die Kenntnis des Objektes, an das die Nachricht gesendet wurde. (SEND ' (SEND (SEND < o b j e c t > ) )

)

) eval> eval> eval>

(SEND (SEND (SEND

A002 A002 A002

ADD-EINZAHLUNG! ADD-AUSZAHLU-NG! GET-K0NT0STAND)

] 890713 500.00) 890801 400.00) = = > 100

==> ==>

500. 100.

282

II. Konstruktionen (Analyse und Synthese)

Zum Zeitpunkt des Kreierens der Instanz A002 (Anwendung von MAKE-INSTANCE) waren die Methoden ADD-EINZAHLUNG! und ADD-AUSZAHLUNG! noch nicht definiert. Wir können sie trotzdem auf A002 anwenden. Wenn das nachträgliche Modifizieren einer Klasse auf die von ihr abhängigen Objekte unmittelbar vererbt wird, dann sprechen wir von dynamischer Vererbung. Als abhängige Objekte gelten alle Klassen und Instanzen, die im Vererbungsgraph auf der modifizierten Klasse aufbauen; oder anders formuliert: alle Objekte die Nachfolgeknoten im Vererbungsgraphen sind. In SCOOPS bezieht sich die dynamische Vererbung auf die Methoden und nicht auf die Instanzvariablen bestehender Instanzen (vgl. Abschnitt 10.2). /Hinweis: In CLOS ist die Vererbung von Modifikationen, insbesondere der Instanzvariablen, anwendungsabhängig spezifizierbar. Z.B. kann auf den „alten" Wert einer Instanzvariablen im Rahmen der Vererbung der Modifikation zugegriffen werden (vgl. z.B. Keene, 1989)./ Wir ändern eine Kontonummer, indem das Konto als ein Objekt in der USERINITIAL-ENVIRONMENT eine neue Bindung erhält. Die neue Kontonummer wird an das Objekt gebunden, und die Bindung der alten Kontonummer wird aufgelöst. Vorab prüfen wir, ob die neue Kontonummer schon als Konto existiert und die alte Kontonummer wirklich an ein Objekt vom Typ KONTO gebunden ist. eva1> (DEFINE-METH00 (KONTO AENDERE-KONTO-IDENTIFIZIERUNG!) (K_IDENT_ALT K_IDENT_NEU) (COND ((KONTO? (EVAL '(ACCESS ,K_IDENT_NEU USER-INITIAL-ENVIRONMENT))) (ERROR "Neue Kontonummer i s t b e l e g t : " K_IDENT_NEU)) ((KONTO? (EVAL '(ACCESS ,K_IDENT_ALT USER-INITIAL-ENVIRONMENT))) (EVAL '(DEFINE ,K_IDENT_NEU (EVAL ,K_IDENT_ALT)) USER-INITIAL-ENVIRONMENT) (EVAL '(SEND ,K_IDENT_NEU SET-IDENTIFIZIERUNG ' , K_ I DENT_NEU ) USER-INITIAL-ENVIRONMENT) (EVAL '(UNBIND ',K_IDENT_ALT USER-INITIAL-ENVIRONMENT) USER-INITIAL-ENVIRONMENT)) (T (ERROR "Alte Kontonummer e x i s t i e r t n i c h t : " K_ I DENT_ALT)))) ==> AENDERE-KONTO-IDENTIFIZIERUNG!

10. Klasse-Instanz-Modell

283

eval>

(SEND A 0 0 1 AENDERE-KONTO- I D E N T I F I Z I E R U N G ! ' A O O l ' A 0 0 2 ) = = > [ERROR e n c o u n t e r e d ! ] Neue Kontonummer i s t b e l e g t : A002

eval>

(SEND AOOl A E N D E R E - K O N T O - I D E N T I F I Z I E R U N G ! ' A 0 0 8 ' A 0 Ü 9 ) = = > [ERROR e n c o u n t e r e d ! ] A l t e Kontonummer e x i s t i e r t n i c h t : A008

eval>

(SEND AOOl A E N D E R E - K O N T O - I D E N T I F I Z I E R U N G ! ' A 0 0 2 ' A 0 0 7 ) = = > # ( S E N D A007 GET-KONTOSTAND) = = > 1 0 0 .

eval>

Wie das obige Beispiel zeigt, können wir mit dem SEND-Mechanismus die Methode AENDERE-KONTO-IDENTIFIZIERUNG! an eine beliebige Instanz der Klasse KONTO senden. Auf welche Instanz sich die Änderung der Kontonummer bezieht, wird erst durch die weiteren Argumente definiert. Dies ist keine zweckmäßige Lösung. Wir hätten gern in der Methodendefinition die Möglichkeit genutzt, das Objekt abzufragen, an das die Nachricht gesendet wird, die zur Anwendung der Methode führt. Benötigt wird ein Konstrukt SELF, dessen Wert das Objekt ist, an das die Nachricht gesendet wurde. Dann hätten wir uns die LAMBDA-Variable K_ IDENT_ ALT in der Methodendefinition ersparen können. Ein solches SELF-Konstrukt stellt SCOOPS nicht zur Verfügung. Als Lösung bietet sich hier das Formulieren eines eigenen Makros SENDWITH-OBJECT an, so daß die doppelte Nennung der alten Kontonummer entfällt. Diese Lösung entspricht einer Funktion, die wir an ihre LAMBDA-Variablen binden (vgl. z.B. Fixpunktoperator in Abschnitt 8.1.2). eval>

eval>

(MACRO S E N D - W I T H - O B J E C T (LAMBDA ( S E X P R ) ' ( S E N D , ( L I S T - R E F SEXPR 1) . ( L I S T - R E F SEXPR 2) ' . ( L I S T - R E F SEXPR 1) , @ ( L I S T - R E F SEXPR 3)

¡das Objekt ;die Nachricht ¡wieder das Objekt ¡ R e s t der Angabe )) ==> SEND-WITH-OBJECT

; ; Da SEND a u c h e i n M a k r o i s t , i n t e r e s s i e r t ; ; h i e r n u r d i e E x p a n d i e r u n g a u f 1. S t u f e . (EX PAND-MACRO-1 '(SEND-WITH-OBJECT

A007 AENDERE-KONTO-IDENTIFIZIERUNG!

==> eval>

(SEND A007 A E N D E R E - K O N T O - I D E N T I F I Z I E R U N G !

'A100)) 'AlOO)

(SEND-WITH-OBJECT A007 A E N D E R E - K O N T O - I D E N T I F I Z I E R U N G !

'A100) ==>

eval>

'A007

(SEND AlOO GET-KONTOSTAND)

==>

100

#

284

II. Konstruktionen (Analyse und Synthese)

10.2 Multiple dynamische Vererbung Aufbauend auf den Klassen K O N T O und O F F E N E R - V O R G A N G definieren wir die Klasse V E R W A H R K O N T O (vgl. Bild 10-3). Die Klasse VERW A H R K O N T O „hängt" unter diesen beiden Klassen. Sie ist eine Unterklasse, auch Subklasse genannt, der Klasse K O N T O und der Klasse OFFENERV O R G A N G . Umgekehrt betrachtet: K O N T O und O F F E N E R - V O R G A N G sind in Bezug auf die Klasse V E R W A H R K O N T O Superklassen. Wir können die Klasse V E R W A H R K O N T O als eine Spezialisierung ihrer Superklassen betrachten. Eine Superklasse stellt dann eine Zusammenfassung der gemeinsamen Eigenschaften (Slots und Methoden) ihrer Subklassen dar. Die Zusammenfassung von gemeinsamen Eigenschaften zu einer Klasse bezeichnet man als Faktorisierung. eval>

( D E F I N E - C L A S S VERWAHRKONTO ( M I X I N S KONTO O F F E N E R - V O R G A N G ) ( I N S T V A R S (BUCHUNGSGRUND N I L ) (BEARBEITER "Krause")) (OPTIONS GETTABLE-VARIABLES SETTABLE-VARIABLES INITTABLE-VARIABLES)) ==>

VERWAHRKONTO

Mit dem in SCOOPS eingebauten DESCRIBE-Konstrukt ist das Ergebnis der definierten Klasse V E R W A H R K O N T O anzeigbar: eval> (DESCRIBE V E R W A H R K O N T O ) = = > CLASS

DESCRIPTION

NAME C L A S S VARS INSTANCE VARS METHODS MIXINS CLASS COMPILED CLASS INHERITED () ; Rückgabewert

VERWAHRKONTO ( ) (BUCHUNGSGRUND B E A R B E I T E R ) (SET-BUCHUNGSGRUND S E T - B E A R B E I T E R GET-BUCHUNGSGRUND G E T - B E A R B E I T E R ) (KONTO O F F E N E R - V O R G A N G ) ( ) () des D E S C R I B E - K o n s t r u k t e s

Als sogenannte M I X I N S ist erst die Klasse K O N T O und dann die Klasse OFFEN E R - V O R G A N G genannt. Die Reihenfolge der M I X I N S ist bedeutsam. Sie bestimmt die Priorität bei der Vererbung. Kommen namensgleiche Slots oder Methoden in K O N T O und in O F F E N E R - V O R G A N G vor, dann ist das Erbe der erstgenannten Klasse (hier K O N T O ) für Instanzen der Klasse V E R W A H R K O N T O dominant. Anders formuliert: Die Slots bzw. Methoden der zuerstgenannten Klasse überschatten die namensgleichen Slots bzw. Methoden der nachfolgenden genannten Klassen (vgl. Bild 10.2-1). SCOOPS

speichert die beiden Eigenschaften C L A S S C O M P I L E D und

285

10. Klasse-Instanz-Modell

CLASS INHERITED für eine Klasse. Eine Klasse kann entweder direkt mit dem COMPILE-CLASS-Konstrukt oder indirekt durch Anwendung des MAKEINSTANCE-Konstruktes compiliert werden. Bei dieser "Compilierung" einer Klasse werden die Slots und Methoden ihrer MIXINS vererbt. Die in den „compilierten" MIXINS genannten Klassen werden als vererbt gekennzeichnet, d.h. ihr CLASS INHERITED weist den Wert # T aus. eval>

(COMPILE-CLASS

)

==>

Die MIXINS der Klasse VERWAHRKONTO sind die Klassen KONTO und OFFENER-VORGANG, wobei bisher nur die Klasse KONTO definiert und durch das Kreieren ihre Instanz A001 implizit compiliert wurde. Die Definition der Klasse OFFENER-VORGANG ist noch nicht vollzogen. Bis dies erfolgt, bezeichnen wir sie als eine „unentschiedene" Klasse (engl.: pending class). Eine Instanz der Klasse VERWAHRKONTO zu konstruieren, bedingt vorab die Klassendefinition OFFENER-VORGANG. eval > eval>

( D E F I N E V 0 0 1 (MAKE - 1 N S T A N C E VERWAHRKONTO)) = = > ERROR . . . ¡ K l a s s e O F F E N E R - V O R G A N G n i c h t

definiert

( D E F I N E - C L A S S OFFENER-VORGANG (INSTVARS (AKTENZEICHEN N I L ) (ABSENDER N I L ) (BISHERIGE-BEARBEITUNG NIL) (BEARBEITER "Fischer")) ( C L A S S V A R S (ANZAHL 0 ) ) (0PTI0NS GETTABLE-VARIABLES SETTABLE-VARIABLES I N I T T A B L E - V A R I A B L E S ) ) = = > OFFENER-VORGANG

Die Klasse OFFENER-VORGANG enthält die Klassenvariable ANZAHL. Sie ist eine gemeinsame Variable (engl.: shared slot) aller ihrer Instanzen. In diesem Kontext ist eine Instanzvariable eine lokale Variabe (engl.: local slot). Als Kontenbeispiele konstruieren wir die beiden Verwahrkonten V001 und V002 und wenden die obigen Methoden darauf an. eval>

(DEFINE

eval>

(DEFINE

eval> eval> eval> eval> eval>

V001

(MAKE-INSTANCE

VERWAHRKONTO))

==>

V 0 0 2 ( M A K E - 1 N S T A N C E VERWAHRKONTO 'IDENTIFIZIERUNG 'V002 'NAME-INHABER "Franz Otto D i c k e r " ' A D R E S S E - I N H A B E R " D o r f s t r a s s e 10 D - 1 0 0 0 )) = = > V002

V001

Berlin

(SEND V002 ADD-EINZAHLUNG! 891230 1 0 0 . 1 1 ) = = > 1 0 0 . 1 1 (SEND V002 ADD-EINZAHLUNG! 8 9 1 2 3 1 0 . 8 9 ) ==> 101. (SEND V002 ADD-AUSZAHLUNG! 900102 5 1 . 0 0 ) ==> 50. (SEND V002 ADD-AUSZAHLUNG! 9 0 0 1 0 3 7 0 . 0 0 ) = = > [ERROR e n c o u n t e r e d ! ] K e i n e Deckung f u e r : 70. (SEND-WITH-OBJECT V002 AENDERE-KONTO-IDENTIFIZIERUNG! ' V 0 0 3 ) ==> V002

2"

286

II. Konstruktionen (Analyse und Synthese)

e v a l > (SEND V003 GET-ANZAHL) = = > 0 e v a l > (SEND V 0 0 1 S E T - A N Z A H L 1 2 ) = = > 12 e v a l > (SEND V003 GET-ANZAHL) = = > 12

¡Shared

slot

!

eval>

(SEND V003 SET-BISHERIGE-BEARBEITUNG

eval>

(SEND V003 SET-BISHERIGE-BEARBEITUNG (LIST "3. Lieferung" (SEND V003 G E T - B I S H E R I G E - B E A R B E I T U N G ) ) ) ==> ( " 3 . L i e f e r u n g " " T e l e f o n i s c h e

eval>

(DESCRIBE

INSTANCE

Instance

V003)

"Telefonische Anfrage") ==> " T e l e f o n i s c h e A n f r a g e "

==>

DESCRIPTION

of C l a s s

Class Variables ANZAHL : 12

VERWAHRKONTO

:

Instance Variables : BISHERIGE-BEARBEITUNG : (3. Lieferung T e l e f o n i s c h e ABSENDER : ( ) AKTENZEICHEN : ( ) KONTOSTAND : 5 0 . AUSZAHLUNGEN : ( ( 9 0 0 1 0 2 5 1 . ) ) EINZAHLUNGEN : ( ( 8 9 1 2 3 1 0 . 8 9 ) ( 8 9 1 2 3 0 1 0 0 . 1 1 ) ) A D R E S S E - I N H A B E R : D o r f s t r a s s e 10 D - 1 0 0 0 B e r l i n 2 NAME-INHABER : F r a n z O t t o D i c k e r I D E N T I F I Z I E R U N G : V003 BUCHUNGSGRUND : ( ) BEARBEITER : Krause () ; Rückgabewert des D E S C R I B E - K o n s t r u k t e s eval>

(DESCRIBE

CLASS

KONTO)

Anfrage)

==>

DESCRIPTION

NAME C L A S S VARS INSTANCE VARS METHODS

Anfrage")

: KONTO : () : ( I D E N T I F I Z I E R U N G NAME-INHABER A D R E S S E - I N H A B E R EINZAHLUNGEN AUSZAHLUNGEN KONTOSTAND) : (AENDERE-KONTO - 1 D E N T I F I Z I E R U N G ! ADD-AUSZAHLUNG! A D D - E I N Z A H L U N G ! S E T - 1 DENT I F I Z I E R U N G S E T - N A M E - I N H A B E R S E T - A D R E S S E -1NHABER G E T - I D E N T I F I Z I E R U N G GET-NAME-INHABER G E T - A D R E S S E - I N H A B E R GET-EINZAHLUNGEN GET-AUSZAHLUNGEN GET-KONTOSTAND)

287

10. Klasse-Instanz-Modell MIXINS C L A S S COMPILED CLASS INHERITED () eval> cplO

(DESCRIBE

CLASS

: () : #T : #T

VERWAHRKONTO)

==>

DESCRIPTION

NAME C L A S S VARS INSTANCE VARS

METHODS

MIXINS C L A S S COMPILED CLASS INHERITED ()

VERWAHRKONTO (ANZAHL) ( B I S H E R I G E - B E A R B E I T U N G ABSENDER AKTENZEICHEN KONTOSTAND AUSZAHLUNGEN EINZAHLUNGEN A D R E S S E - I N H A B E R NAME-INHABER I D E N T I F I Z I E R U N G BUCHUNGSGRUND B E A R B E I T E R ) ( G E T - B I S H E R I G E - B E A R B E I T U N G GET-ABSENDER G E T - A K T E N Z E I C H E N GET-ANZAHL SET-BISHERIGE-BEARBEITUNG SET-ABSENDER S E T - A K T E N Z E I C H E N S E T - A N Z A H L GET-KONTOSTAND GET-AUSZAHLUNGEN GET-EINZAHLUNGEN GET-ADRESSE-INHABER GET-NAME-INHABER GET-IDENTIFIZIERUNG SET-ADRESSE-INHABER S E T - N A M E - I N H A B E R S E T - I D E N T I F I ZIERUNG ADD-EINZAHLUNG! ADD-AUSZAHLUNG! A E N D E R E - K O N T O - I D E N T I F I ZIERUNG! SET-BUCHUNGSGRUND S E T - B E A R B E I T E R GET-BUCHUNGSGRUND G E T - B E A R B E I T E R ) (KONTO OFFENER-VORGANG) #T #T

e v a l > ( D E S C R I B E OFFENER-VORGANG) CLASS DESCRIPTION

NAME C L A S S VARS INSTANCE VARS METHODS

MIXINS C L A S S COMPILED CLASS INHERITED ()

==>

OFFENER-VORGANG (ANZAHL) ( A K T E N Z E I C H E N ABSENDER BISHERIGE-BEARBEITUNG BEARBEITER) (SET-ANZAHL SET-AKTENZEICHEN SET-ABSENDER SET-BISHERIGE-BEARBEITUNG SET-BEARBEITER GET-ANZAHL G E T - A K T E N Z E I C H E N GET-ABSENDER GET-BISHERIGE-BEARBEITUNG GET-BEARBEITER) () () #T

288

II. Konstruktionen (Analyse und Synthese)

Zur Vertiefung der multiplen Vererbung im Klassen-Instanz-Modell betrachten wir den Vererbungsgraphen gemäß Bild 10.2-1. Das Programmfragment 10.2-1 bildet diesen Vererbungsgraphen in SCOOPS-Konstrukten ab. Entsprechend Weinreb/Moon, die mit ihrem Flavor-System die multiple Vererbung in LISP bekannt gemacht haben, bezeichnen wir die Klassen(-Knoten) im Vererbungsgraphen als Flavors. Für einige Flavors definieren wir namensgleiche Slots (Klassen- und Instanzvariablen) und namensgleiche Methoden. Wird eine Instanz gebildet, dann stellt sich die Frage, welche Slots mit welchen Inhalten und welchen Methoden sie erbt. Bei gleichnamigen Slots bzw. Methoden ist eine Prioritätenregelung notwendig. Zur Bildung einer solchen Prioritätsreihenfolge sind die Flavors in eine Sequenz einzuordnen, d.h. der gerichtete azyklische Vererbungsgraph (engl.: directed acyclic graph, kurz DAG) ist zu linearisieren. In der CLOS-Terminologie formuliert: Es geht um die „class precedence list". Die multiple Vererbung erspart das Duplizieren von Informationen. Gegenüber einem einfachen Vererbungsbaum vermeiden wir identische Knoten und deren konsistente Pflege. Bilden wir den Vererbungsgraph von Bild 10.2-1 mit den Mitteln der einfachen, d.h. nicht multiplen, Vererbung ab, dann ist in dem Vererbungsbaum Flavor F3 doppelt auszuweisen (vgl. Bild 10.2-2). /Exkurs: Klassentypen. Wenn eine Klasse keine eigenen Instanzen aufweist, also nur Abstraktionsaufgaben hat (in Bild 10.2-1 die Flavors Fl, F2 und F4), dann spricht man im SmallTalk-Jargon von einer „abstrakten Superklasse" (vgl. Goldberg/Robson, 1983). Werden Klassen durch Objekte (LISP-Konstrukte) repräsentiert, die selbst Instanzen von sind, dann ist eine MetaKlasse, gesehen aus der Perspektive einer Instanz./ ; ; ; ; Dokument 10.2-1 ; ; ; ; T i t e l : Programmfragment zur Abbildung des Vererbungsgraphen ; ;;; gemäß Bild 10.2-1. ; ; ; ; E r s t e l l t am 14.12.89 ¡ l e t z t e Änderung: eval> (DEFINE *DATE* 891214) ==> *DATE* eva1> (DEFINE-CLASS Fl (INSTVARS (LS-A (ACTIVE ' ( F l 0) (LAMBDA (X) (CAR X)) (LAMBDA (X) (LIST X *DATE*))))) (CLASSVARS (CS ' F l ) ) (0PTI0NS GETTABLE-VARIABLES SETTABLE-VARIABLES INITTABLE-VARIABLES)) ==> Fl eva1> (DEFINE-CLASS F2 (INSTVARS (LS-B (ACTIVE '(F2 0) (LAMBDA (X) (CAR X)) (LAMBDA (X) (LIST X *DATE*))))) (MIXINS Fl) (0PTI0NS GETTABLE- VARIABLES SETTABLE-VARIABLES INITTABLE-VARIABLES)) ==> F2

289

10. Klasse-Instanz-Modell

Legende:

Fl, F2, F3, F4, F5 F3-I1, F5-I2 LS-A, LS-B, LS-C, LS-D CS

Flavor (Klasse) Instanz Local Slot ( I n s t a n z v a r i a b l e ) Shared (Class) Slot (Klassenvari able) Ml ::= Methode —> ::= Vererbungsrichtung [ i ] ::= Abstraktionsebene; 1 = 1 , 2 , 3 , 4

Bild 1 0 . 2 - 1 .

Multiple gleichen

::= ::= ::= ::=

Vererbung: Slots und

Flavor-Graph mit namens - gl ei chen

namensMethoden

eva1> (DEFINE-CLASS F3 (INSTVARS (LS-A (ACTIVE '(F3 0) (LAMBDA (X) (CAR X)) (LAMBDA (X) (LIST X *DATE*))))) (CLASSVARS (CS 'F3)) (MIXINS Fl) (OPTIONS GETTABLE-VARIABLES SETTABLE-VARIABLES IN ITTABLE-VARIABLES)) ==> F3

290

II. Konstruktionen (Analyse und Synthese)

Legende:

Vgl. Bild

Bild

10.2-2.

10.2-1. Einfache Vererbung führt zur Duplizierung Informationen; hier F3' und F3'' gleicher Flavor-Graph in Bild 10.2-1.

eval> (DEFINE-CLASS F4 (INSTVARS (LS-C (ACTIVE ' ( F4 0) (LAMBDA (X) (CAR X)) (LAMBDA (X) (LIST X *DATE*))))) (MIXINS F2 F3) (OPTIONS GETTABLE-VARIABLES SETTABLE-VARIABLES INITTABLE-VARIABLES)) ==> F4 eval> (DEFINE-CLASS F5 (INSTVARS (LS-D (ACTIVE ' ( F 5 (LAMBDA (X) (LAMBDA (X) (MIXINS F4) (OPTIONS GETTABLE-VARIABLES SETTABLE-VARIABLES INITTABLE-VARIABLES) eval> eval> eval> eval> eval>

(COMPILE-CLASS (COMPILE-CLASS (COMPILE-CLASS (COMPILE-CLASS (COMPILE-CLASS

Fl) F2) F3) F4) F5)

==> ==> ==> ==> ==>

Fl F2 F3 F4 F5

0) (CAR X)) (LIST X *DATE*)))))

) ==> F5.

gemäß

10. Klasse-Instanz-Modell

291

eval > ( D E F I N E F 3 - I 1 (MAKE - 1 N S T A N C E F3 'LS-A 'F3-I1)) = = > F 3 - I 1 e v a l > ( D E F I N E F5-I2 ( M A K E - I N S T A N C E F5 ' L S - B 'F5-12)) = = > F5-I2 e v a l > ( D E F I N E - M E T H O D (Fl M l ) () (WRITELN "---Fl " LS-A)) = = > Ml e v a l > ( D E F I N E - M E T H O D (F2 M l ) () ( W R I T E L N " — F2 " LS-A)) = = > Ml e v a l > ( D E F I N E - M E T H O D (F3 M l ) () ( W R I T E L N " — F3 " LS-A)) = = > Ml Programmfragment 10.2-1.

Vererbungsgraph gemäß Bild 10.2-1 - f o r m u l i e r t in S C O O P S - K o n s t r u k t e n -

Wir betrachten zunächst die Instanz F3-I1 des obigen Vererbungsgraphen. Die Instanz F3-I1 erbt von ihrem („Heimat-")Flavor F3 die Slots L S - A und CS. Beim Kreieren der Instanz F3-I1 mit dem MAKE-INSTANCE-Konstrukt erhielt der Slot L S - A den Wert F3-I1. Hier ist es der Name der Instanz, damit wir den Vererbungsmechanismus leichter verfolgen können. Das D E F I N E - C L A S S Konstrukt für Flavor F3 gibt für den Slot C S den Initialisierungswert F3 an. Für die Instanz F3-I1 hat C S diesen voreingestellten Wert F3. eval> (DESCRIBE F3-I1) = = > INSTANCE

DESCRIPTION

I n s t a n c e o f C 1 a s s F3 Class Variables : CS : F3 Instance Variables : LS-A : F 3 - I 1 () Als Komponenten-Flavor weist die MIXINS-Angabe von F3 den Flavor F l aus. Der Flavor F l hat in Bezug auf F3 die namensgleichen Slots L S - A und CS. Diese Fl-Slots werden von den namensgleichen F3-Slots „überschattet". Zur Bestimmung „Wer überschattet (überschreibt) wen?" ist der Vererbungsgraph zu durchlaufen. Startpunkt ist die jeweilige Instanz. Maßgeblich ist der (Durchsuchungs-)Algorithmus. In S C O O P S ist der Tiefensuche-Algorithmus implementiert. Diesen Suchalgorithmus haben wir in Abschnitt 5.3 erörtert und programmiert. Wird z.B. für die Instanz F5-I2 die Methode M l von F2 oder von F3 angewendet? Anders formuliert: Wird erst der linke F2-Zweig oder der rechte F3-Zweig des Graphen abgesucht? Die Entscheidung wird üblicherweise durch die vordefinierte „Von-

292

II. Konstruktionen (Analyse und Synthese)

links-nach-recht-Abarbeitungsfolge" in den MIXINS festgelegt. In CLOS-Terminologie ist es die „local precedence order"-Liste der Klassen-Definition. Durchläuft man den obigen Vererbungsgraphen, von der Instanz F3-I1 ausgehend, entsprechend dem Tiefensuche-Algorithmus entlang der definierten Vererbung, also entgegen der Pfeilrichtung, dann erhält man die Flavorfolge: F3 Fl. Gehen wir von der Instanz F5-I1 aus, so erhalten wir die Flavorfolge: F5 F4 F2 Fl F3 Fl. Slots bzw. Methoden werden entsprechend dieser Flavorfolge, die eine Linearisierung des Graphen darstellt, vererbt. Die Flavorfolge wird von links nach rechts abgearbeitet. Ist ein Slot bzw. eine Methode schon vererbt worden, dann wird sein erneutes Vorkommen nicht vererbt. Das erneute Vorkommen gilt als "überschattet". Um bei dieser Untersuchung schon „expandierte" Flavors nicht nochmals zu prüfen, werden sie vorab aus der Flavorfolge gestrichen. Es entsteht eine bereinigte Prioritätsfolge (vgl. Tab. 10.2-1). In SCOOPS wird diejenige Flavornennung gestrichen, die als Wiederholung vorkommt. Die bereinigte Prioritätenfolge bilden die erstmaligen Nennungen. Dies entspricht dem klassischen Flavor-Konzept. Instanz

Fl a v o r f ol ge

F3-I1

F3

Fl

F3-I5

F5

F4

Tab.

1 0 . 2 - 1 . Priorität Beispiel

Bereinigte F3

F2

Fl F3 Fl

Prioritätenfolge

Fl

F5 F4 F2 Fl F3 ¡Achtung! ; Fl h a t V o r r a n g

bei der Vererbung des Graphen gemäß

vor

F3

in SCOOPS am Bild 10.2-1.

Entsprechend dieser Prioritätsfolge erbt die Instanz F5-I2 ihren Slot LS-A von dem Flavor Fl und nicht vom Flavor F3. eval>

(DESCRIBE

INSTANCE

Instance

F5-I2)

DESCRIPTION

of C l a s s

Class Variables CS : Fl

F5

:

Instance Variables LS-C : (F4 0)

:

==>

293

10. Klasse-Instanz-Modell

()

LS-A LS-B LS-D

: (Fl 0) : F5-I2 : (F5 0)

Diese Regelung der Priorität spiegelt nicht das gewünschte Zusammenwirken von Spezialisierung und Faktorisierung wieder. Wir betrachten Flavor F2 und Flavor F3 jeweils als Verfeinerung der in Fl formulierten Eigenschaften. F3und F2-Eigenschaften sind eine Spezialisierung bzw. Ergänzung von Fl-Eigenschaften. Ein namensgleicher Slot bzw. eine namensgleiche Methode in F2 oder F3 sollte für die nachfolgenden Knoten Vorrang vor der Fl-Angabe haben. Wie unsere Instanz F5-I2 zeigt, ist dies bei der obigen Regelung der Priorität nicht der Fall. Die Instanz F5-I2 erhält im Slot LS-A nicht den spezielleren F3-Wert sondern den allgemeinen Fl-Wert. Dieser Nachteil des klassischen Flavor-Konzeptes ist leicht behebbar. Zu ändern ist der Bereinigungsvorgang der Flavorfolge. Entsprechend „New Flavors" ist nicht ein zweites Vorkommen einer Flavornennung zu streichen, sondern die erste Flavornennung. Maßgeblich ist damit das letzte Vorkommen in der Flavorfolge (vgl. Tab. 10.2-2).

Instanz

Flavorfolge

Bereinigte

Prioritätenfolge

F3-I1

F3 Fl

F3 Fl

F3-I5

F5 F4 F2 Fl F3 Fl

F5 F4 F2 F3 Fl ;Achtung! ; F3 hat V o r r a n g

Tab.10.2-2.

Priorität bei der Vererbung "New Flavors" am Beispiel des gemäß Bild 10. 2-1

vor

Fl

entsprechend Graphen

10.3 Aktiver Slot Im Klassen-Instanz-Modell werden Slots nicht nur als passive Speicher für die lokale oder gemeinsame Zustandsabbildung betrachtet. Einerseits können wir aufgrund der LISP-spezifischen Gleichheit von Daten- und Programm-Repräsentation (vgl. Abschnitt 1.3) auch eine LISP-Funktion in einem Slot speichern, so daß Slots eine aktive Rolle haben können. Sie sind dann ähnlich wie Methoden einsetzbar. Andererseits können Selektor- und Mutator-Funktionen direkt Slots zugeordnet werden. Wie das Programmfragment 10.2-1 zeigt, lassen sich solche „aktiven" Slots in SCOOPS definieren. Senden wir der Instanz F3-I1 die Nachricht SET-LS-A, dann ist ihr Slot

294

II. Konstruktionen (Analyse und Synthese)

LS-A, geerbt vom Flavor F3, zu verändern. Da der Slot LS-A als aktiver Slot definiert ist, wird seine Mutator-Funktion appliziert (vgl. -Beschreibung in der Syntaxbeschreibung des DEFINE-CLASS-Konstruktes, Abschnitt 10.1). Diese Mutator-Funktion ist für LS-A als eine anonyme Funktion, wie folgt, definiert: (LAMBDA (X) (LIST X *DATE*)) Die LAMBDA-Variable X wird an den Änderungswert gebunden. Mit dieser Bindung wird die Mutator-Funktion ausgeführt. Ihr Wert ist dann der neue Wert für den Slot LS-A. eval>

(SEND

F3-I1

SET-LS-A

"1.

Aenderung") = = > ("1. A e n d e r u n g "

891214)

Neben dem Mutator ist für den Slot eine Selektor-Funktion definiert. Sie besteht aus dem folgenden LAMBDA-Konstrukt: (LAMBDA (X) (CAR X)) Wenn wir auf den Wert des Slots mit Hilfe der Nachricht GET-LS-A zugreifen, dann wird die LAMBDA-Variable X an den Slotwert gebunden, und wir erhalten den Wert der LAMBDA-Konstrukt-Anwendung. Die generierten Selektoren und Mutatoren sind durch aktive Slots beeinflußbar. Fest verankert ist in SCOOPS nur der Mechanismus aus der Nachricht, den richtigen Selektor bzw. Mutator herauszufinden. Was diese generierte Methode konkret bewirkt, ist anwendungsspezifisch durch die Option "aktiver" Slot formulierbar. eval> eval>

(SEND (SEND

F3-I1 F5-I2

G E T - L S - A ) = = > "1. A e n d e r u n g " SET-LS-B "Alles klar!") ==> ("Alles klar!"

891214)

10.4 Modifikation des Vererbungsgraphen In unserem Flavor-System (Programmfragment 10.2-1) betrachten wir die Vererbung der selbstdefinierten Methode M l . Die Methode Ml ist so formuliert, daß wir erkennen können, für welchen Flavor sie definiert wurde. Ihr WRITELN-Konstrukt schreibt den jeweiligen Flavor-Namen. Gemäß dem klassischen Flavor-Konzept konstruiert SCOOPS für die Instanz F5-I2 die bereinigte Prioritätsfolge: F5 F4 F2 Fl F3 (vgl. Tab 10.2-1). Die Methode Ml kommt danach für F5-I2 zuerst in F2 vor; der Slot LS-A zuerst in Fl. eval> (SEND F5-I2 Ml) ==> — F2 (Fl 0) () ; R ü c k g a b e w e r t d e s W R I T E L N - K o n s t r u k t e s eval>

(SEND

eval> — F2

(SEND

()

F5-I2

SET-LS-A

"Vanilla schmeckt") ==> ("Vanilla

F5-I2 Ml) = = > (Vanilla schmeckt

891214)

schmeckt"

891214)

10. Klasse-Instanz-Modell

295

Löschen wir die Methode Ml des Flavors F2, dann muß im Fall der dynamischen Vererbung die nächste Methode Ml entsprechend der Prioritätsfolge angewendet werden. Ein dynamisches Vererbungssystem hat laufend den Vererbungsgraphen zu überwachen und gegebenenfalls neu zu linearisieren, um die Änderungen zu berücksichtigen. Es gilt, alle Änderungen auf die betroffenen Knoten im Vererbungsgraphen zu übertragen („propagieren"). Bei einem statischen System, welches das Ergebnis der einmaligen Abarbeitung des Vererbungsgraphen fest für die Instanzen implementiert, führt das Löschen der Methode Ml nicht mehr zur Anwendung einer vormals überschatteten Methode Ml. Objektorientierte Erweiterungen sind im Regelfall pragmatische Lösungen zwischen dem völligen Einfrieren des Vererbungsgraphen (extrem statisches Vererbungskonzept) und dem permanenten Überwachen und sofortigen Propagieren der Änderungen (sehr dynamisches Vererbungskonzept). Sie versuchen einen Kompromiß zwischen den Vor- und Nachteilen der beiden Konzepte zu finden. Wesentliche Vorteile des statischen Vererbungskonzeptes sind der geringere Abarbeitungsaufwand für eine Nachricht (CPU- und Speicherplatz-Bedarf) und die bessere Durchschaubarkeit des Systems. Haben wir ein Objekt verstanden, dann können wir darauf bauen, daß es so bleibt, da Änderungen seine erneute Konstruktion bedingen. Das Systemverhalten ist im Vergleich zur dynamischen Vererbung leichter nachvollziehbar und einfacher prognostizierbar. Wir müssen nicht den gesamten Kontext eines Objektes laufend überwachen, um sein Verhalten zu verstehen. Vorteil des dynamischen Vererbungskonzepts ist die große Flexibilität. Eine Abarbeitung einer simplen Nachricht kann die bestehenden Vererbungsregeln modifizieren. Jede Veränderung ist im gesamten System sofort bekannt und wird, falls erforderlich, berücksichtigt. Modifikationen können vom Benutzer jederzeit eingebracht werden, ohne daß quasi eine Neukonstruktion die Konsequenz ist. In SCOOPS ist eine dynamische Methodenvererbung realisiert. Neue Slots oder das Löschen von Slots erfordern die erneute Anwendung des DEFINECLASS- und des MAKE-INSTANCE-Konstruktes. Damit orientiert sich der SCOOPS-Kompromiß stark am statischen Vererbungskonzept. eval > (DELETE-METHOD (F2 Ml)) ==> Ml eval> (SEND F5-I2 Ml) ==> ---Fl (Vanilla schmeckt 891214) eval> (DELETE-METHOD (Fl Ml)) ==> Ml eva1> (SEND F5-I2 Ml) ==> — F3 (Vanilla schmeckt 891214) eval> (DELETE-METHOD (F3 Ml)) ==> Ml eval> (SEND F5-I2 Ml) ==> ERROR . . . ;Methode Ml wurde gelöscht

296

II. Konstruktionen (Analyse und Synthese)

Hier sei der Vollständigkeit halber noch erwähnt, daß SCOOPS weitere Konstrukte bereitstellt. Zum Beispiel sind mit den Konstrukten METHODS und ALL-METHODS die eigenen und die eigenen plus geerbten Methoden eines Flavors selektierbar: eval> eval>

(METHODS F 5 ) = = > ( G E T - L S - D S E T - L S - D S E T - L S - D G E T - L S - D ) (ALL-METHODS F5) = = > (Ml S E T - L S - C GET-LS-C GET-CS SET-CS SET-LS-A GET-LS-A GET-LS-B SET-LS-B GET-LS-D SET-LS-D SET-LS-D GET-LS-D) ;Diese Doppelnennung i s t offensicht; l i e h e i n SCOOPS-Fehl er

Die folgenden Beispiele verdeutlichen weiter SCOOPS-Konstrukte. eval> eval> eval> eval> eval> eval> eval> eval> eva1> eval>

eval>

( M I X I N S F4) ==> (F2 F3) (CLASSVARS F5) ==> ( ) ( A L L - C L A S S V A R S F5) ==> (CS) ( E Q ? F5 ( N A M E - > C L A S S ' F 5 ) ) = = > # T ( N A M E - > C L A S S ( C A R ' ( F l F2 F3 F4 F 5 ) ) ) ==> #( ... ) V e k t o r , der d i e K l a s s e Fl d a r s t e l l t . Direkte Wertzuweisung einer ( S E T C V F2 CS " O t t o " ) ==> "Otto" "Class l/ariable" (GETCV F2 C S ) D i r e k t e r Z u g r i f f auf eine ==> "Otto" "Class l/ariable" ( S E N D - I F - H A N D L E S F 5 - I 2 G E T - L S - C ) = = > F4 ( S E N D - I F - H A N D L E S F 5 - I S S E T - L S - A "Emma") = = > ("Emma" 8 9 1 2 1 4 ) ( S E N D - I F - H A N D L E S F 5 - I 2 SET-NO-SLOT (WRITELN ( + 1 2 ) ) ) ==> () ¡Methode unbekannt, daher () ; a l s Rückgabewert (DESCRIBE

CLASS

F2)

==>

DESCRIPTION

NAME C L A S S VARS I N S T A N C E VARS METHODS MIXINS CLASS COMPILED CLASS INHERITED ( )

F2 (CS) (LS-A LS-B) (Ml GET-CS SET-CS S E T - L S - A GET-LS-A GET-LS-B SET-LS-B SET-LS-B GET-LS-B) (Fl) #T #T

Bei komplexen Aufgaben verstehen wir die Konstruktion erst nach Definition einer Menge von anwendungsspezifischen Objekten (Klasse, Instanzen) und Operationen (Methoden). Erst nach ihrer Definition fallen uns Ähnlichkeiten auf. Zur Bewertung einer objektorientierten Entwicklungsumgebung gehört daher die Faktorisierungsoption. Können überhaupt, und wenn ja mit welchem

10. Klasse-Instanz-Modell

I.

Modifikation

der

297

Knoten

(Klassen/Flavors)

des

Graphen

o Hinzufügen eines neuen Knotens o Löschen eines existierenden Knotens o Umbenennen eines existierenden Knotens II.

Modifikation

der

Kanten

des

Graphen

o Knoten X als S u p e r k l a s s e ("mixin") eines Knotens Y definieren. o Knoten X aus den "mixins" eines Knotens Y e n t f e r n e n , o P r i o r i t ä t ( R e i h e n f o l g e ) in d e n " m i x i n s " einer Klasse ändern. III. M o d i f i k a t i o n

des

Knoteninhaltes

(Klasse/Flavors)

o Änderungen, die Methoden betreffen - Ändern der Definition einer e x i s t i e r e n d e n - Hinzufügen einer neuen Methode - Löschen einer existierenden Methode - Umbenennen einer existierenden1Methode - Ändern des Types einer M e t h o d e 1 ^

Methode

o Ä n d e r u n g e n , die Slots betreffen - Hinzufügen eines neuen Slots - Löschen eines existierenden Slots - Umbenennen eines existierenden Slots - Ändern des v o r e i n g e s t e l l t e n Wertes eines Slots - Ändern des Typs eines Slots * W e c h s e l v o m "local S l o t " ( I n s t a n z v a r i a b l e ) zum "shared Slot" ( K l a s s e n v a r i a b l e ) * Wechsel vom "shared Slot" ( K l a s s e n v a r i a b l e ) z u m "local S l o t " ( I n s t a n z v a r i a b l e ) 1)

Flavor-Systeme unterscheiden z.B. die M e t h o d e n t y p e n : "before d a e m o n " , "primary m e t h o d " , " a f t e r d a e m o n " und "whopper" (Näheres dazu vgl. z.B. Bonin, 1989 und die dort genannte Literatur)

Tab.

1 0 . 4 Modifikationen halten beim

von Knoten, Kanten Vererbungsgraphen

und

Knotenin-

Aufwand aus schon existierenden „speziellen" Klassen „abstraktere" Klassen nachträglich definiert werden? Welchen Aufwand bereitet die Suche nach potentiellen Kandidaten (Slots und Methoden) für die Faktorisierung? Das Komplement zur Faktorisierung ist die Spezialisierung. Zunächst werden Objekte auf einem hohen Abstraktionsniveau definiert und Schritt für Schritt durch Definition von Subklassen und ihren zugeordneten Methoden verfeinert. Nach der Analyse von Objekten mit allgemeinen Eigenschaften ergänzt, bzw. modifiziert man diese Objekte, indem man sich auf die spezielleren Eigenschaften in Form von Subklassen-Definitionen konzentriert. Selten können die Ab-

298

II. Konstruktionen (Analyse und Synthese)

straktionsebenen ohne Korrekturbedarf durch einen konsequenten Spezialisierungsansatz (engl.: top down approach) oder umgekehrt durch einen konsequenten Faktorisierungsansatz (engl.: bottom up approach) geschaffen werden. In der Praxis findet für eine objektgeprägte Konstruktion ein Wechsel zwischen Faktorisierungs- und Spezialisierungs-Schritten statt. Das inkrementelle Entstehen von Klassen, Instanzen und Methoden ist ein charakteristisches Kennzeichen der objektgeprägten Vorgehensweise. Die Möglichkeiten einer effizienten und transparenten Fortschreibung eines Vererbungsgraphen sind daher leistungsbestimmend für eine solche Software-Entwicklungsumgebung. Die Tabelle 10.4-1 nennt die gewünschten Modifikationoptionen.

10.5 Zusammenfassung: Spezialisierung und Faktorisierung Eine Klasse, manchmal auch Flavor genannt, definiert die Struktur und Eigenschaften einer Menge von Objekten, den Instanzen. Eine klassenspezifische Operation heißt Methode. Sie wird über eine Nachricht aktiviert. Bei der multiplen Vererbung kann eine Instanz die Struktur und Eigenschaften (Slots und Methoden) mehrerer Klassen übernehmen („erben"). Bei namensgleichen Slots und Methoden bedarf es einer Prioritätsregelung. Die Priorität wird mit Hilfe des Vererbungsgraphen ermittelt. Bei der dynamischen Vererbung werden Veränderungen des Vererbungsgraphen permanent überwacht und sofort berücksichtigt („propagiert"). Eine statische Vererbung wertet den Vererbungsgraphen nur zum Konstruktionszeitpunkt einer Instanz aus. Eine Modifikation des Graphen erfordert dann eine Neukonstruktion der Objekte. Das von PC Scheme bereitgestellte „Scheme Object-Oriented Programming System (kurz: SCOOPS)" vererbt Methoden dynamisch und Slots statisch. Dabei sind in SCOOPS Slots nicht nur passive Speicher für die lokale Zustandsabbildung der Instanzen. Sie sind als aktive Slots mit Selektor- und Mutator-Funktionen definierbar. Ein Aspekt zur Beurteilung einer objekt-orientierten Software-Entwicklungsumgebung sind die Optionen zur Spezialisierung und Faktorisierung. Sind „spezielle" Eigenschaften, im Sinne von Subklassen, auf der Basis „abstrakter" Klassen jeder Zeit definierbar? Das Komplement zu dieser Spezialisierung ist die Faktorisierung. Hier geht es um die Möglichkeit, jederzeit Eigenschaften aus existierenden Subklassen zu „abstrakteren" Klassen zusammenfassen zu können. Charakteristisches

Beispiel für Abschnitt

10:

Im folgenden ist mit den SCOOPS-Konstrukten eine Magazinverwaltung skizziert. Der Vererbungsgraphen ist in Bild 10.5-1 dargestellt. Das Programmfragment 10.5-1 zeigt anhand dreier Beispiele das Versenden von anwendungsspezifischen Nachrichten.

10. Klasse-Instanz-Modell

299

; ; Dokument 1 0 . 5 - 1 ; ; T i t e l : P r o g r a m m f r a g m e n t z u r A b b i l d u n g des ;; gemäß B i l d 1 0 . 5 - 1 . AI E x e m p l a r i s c h s i n d d i e Methoden: A I . .1 { E i n l a g e r n } und A I . .2 { E n t n e h m e n ! d e f i n i e r t . El Eingesetzt sind die SCOOPS-Konstrukte E l , .1 D E F I N E - C L A S S E l , .2 MAKE -1NSTANCE E l ,.3 C O M P I L E - C L A S S E l . .4 DEFINE-METHOD E l .5 SEND eval>

(LOAD " S C O O P S . F S L " )

Vererbungsgraphen

= = > OK

e v a l > ( D E F I N E - C L A S S LIEFERANT ( I N S T V A R S FIRMENNAME L I E F E R S C H E I N - N U M M E R ) (OPTIONS G E T T A B L E - V A R I A B L E S ) ) = = > LIEFERANT e v a l > ( D E F I N E - C L A S S LAGERGUT (CLASSVARS (ANZAHL-TRANSAKTIONEN 0) AKTUELLE-MAGAZINVERWALTER) (INSTVARS PRODUKT-IDENTIFIKATION PRODUKT-BEZEICHNUNG DATUM-LETZTE-EINLAGERUNG DATUM-LETZTE-ENTNAHME (BESTAND 0 ) LAGERBEDINGUNG) ( M I X I N S L I E F E R A N T BESTELLUNG LAGERPLATZ) (OPTIONS GETTABLE-VARIABLES ( S E T T A B L E - V A R I A B L E S ANZAHL-TRANSAKT IONEN LAGERBEDINGUNG) I N I T T A B L E - V A R I A B L E S ) ) = > LAGERGUT e v a l > ( D E F I N E - C L A S S BESTELLUNG ( I N S T V A R S BESTELL-VORGANGS-NUMMER BESTELL-DATUM) ( O P T I O N S GETTABLE- V A R I A B L E S ) ) = = > BESTELLUNG e v a l > ( D E F I N E - C L A S S LAGERPLATZ ( I N S T V A R S RAUM REGAL FACH K U R Z Z E I C H E N - M A G A Z I N - V E R W A L T E R ) (OPTIONS GETTABLE-VARIABLES (SETTABLE-VARIABLES KURZZEICHEN-MAGAZIN-VERWALTER) I N I T T A B L E - V A R I A B L E S ) ) = = > LAGERPLATZ e v a l > ( D E F I N E - C L A S S STUECKGUT (INSTVARS LAGER-DIMENSION (KOSTEN/STUECK 0) BESTANDSWERT) ( M I X I N S LAGERGUT) (OPTIONS G E T T A B L E - V A R I A B L E S ) )

==>

STUECKGUT

e v a l > ( D E F I N E - C L A S S EISENWARE (INSTVARS ROST-FREIHEIT) ( M I X I N S STUECKGUT) (OPTIONS G E T T A B L E - V A R I A B L E S ) )

==>

EISENWARE

II. Konstruktionen (Analyse und Synthese)

300

e v a l > ( D E F I N E - C L A S S FARBE (INSTVARS VERFALLS-DATUM) ( M I X I N S S T U E C K G U T FLU E S S I G K E I T ) (OPTIONS GETTABLE-VARIABLES)) ==>

FARBE

eval> (DEFINE-CLASS FLUESSIGKEIT (INSTVARS BEHAELTER-KLASSE ZUEND-TEMPERATUR) ( M I X I N S LAGERGUT) (OPTIONS GETTABLE-VARIABLES)) ==> FLUESSIGKEIT e v a l > ( D E F I N E - C L A S S MAGAZIN-VERWALTER ( I N S T V A R S NAME B E F U G N I S - K L A S S E K U R Z Z E I C H E N ) (OPTIONS GETTABLE- VARIABLES SETTABLE- VARIABLES I N I T T A B L E - V A R I A B L E S ) ) ==> MAGAZIN-VERWALTER e v a l > (DEFINE E0001 (MAKE-INSTANCE EISENWARE 'PRODUKT-IDENTIFIKATION

'E0001))

==>

E0001

e v a l > (DEFINE F0001 ( M A K E - I N S T A N C E FARBE 'PRODUKT-IDENTIFIKATION

'F0001))

==>

F0001

e v a l > ( D E F I N E SCHMIDT (MAKE - 1 N S T A N C E M A G A Z I N - V E R W A L T E R 'NAME " H a n s O t t o S c h m i d t " ' B E F U G N I S - K L A S S E ' ( ( E 1) (F 4 ) ) 'KURZZEICHEN ' S C H ) ) = = > SCHMIDT e v a l > ( D E F I N E MUELLER (MAKE-INSTANCE MAGAZIN-VERWALTER 'NAME " W e r n e r M u e l l e r " ) ) = = > MUELLER eval>

(COMPILE-CLASS

LAGERGUT)

==>

LAGERGUT

e v a 1 > ( D E F I N E - M E T H O D (LAGERGUT E I N L A G E R N ) ( ) (BEGIN (WRITELN " E i n l a g e r u n g von: " PRODUKT-IDENTIFIKATION) (WRITELN " = = = = = = = = = = = = = = = = " ) (LET ((ZUGANG (BEGIN (PRINC " Z u g a n g s m e n g e : ") (READ))) (KOSTEN (BEGIN (PRINC " K o s t e n pro S t u e c k : ") (READ)))) ( S E T ! KOSTEN/STUECK (/ (+ ( * KOSTEN/STUECK BESTAND) ( * KOSTEN Z U G A N G ) ) ( + BESTAND ZUGANG))) ( S E T ! BESTAND ( + BESTAND ZUGANG)) ( S E T C V LAGERGUT A N Z A H L - T R A N S A K T I O N E N ( 1 + (GETCV LAGERGUT A N Z A H L - T R A N S A K T I O N E N ) ) ) (WRITELN " E i n l a g e r u n g g e b u c h t ! " ) ) ) ) ==> EINLAGERN

10. Klasse-Instanz-Modell eval>

301

( D E F I N E - M E T H O D ( L A G E R G U T E N T N E H M E N ) () (BEGIN (WRITELN "Entnahme von: " PRODUKT-IDENTIFIKATION) (WRITELN "================") ( L E T ( ( A B G A N G ( B E G I N ( P R I N C " E n t n a h m e m e n g e : ") (READ)))) (COND (( ENTNEHMEN

; ; ; ; Bei spi e l e eval > ( S E N D E 0 0 0 1 Einlagerung

EINLAGERN) von: E0001

==>

Z u g a n g s m e n g e : 100 Kosten pro S t u e c k : 12.00 Einlagerung gebucht!

()

eval> (SEND E0001 E N T N E H M E N ) Entnahme von: E0001

==>

E n t n a h m e m e n g e : 40 Entnahme gebucht! () eval> (SEND Einlagerung

E0001 EINLAGERN) von: E0001

==>

Z u g a n g s m e n g e : 100 Kosten pro Stueck: 13.00 Einlagerung gebucht! () eval>

(SEND

E0001

GET-KOSTEN/STUECK)

==>

12.625

ProgrammfragmentlO.5-1.Magazinverwa1tungrealisiert (vgl. Bild 10.5-1.) SCOOPS-Konstrukten

Legende: ::= K l a s s e , N a m e ::= I n s t a n z I ... [ ...

in

Fettdruck

} ::= M e t h o d e ] ::= K l a s s e n v a r i a b l e ( " s h a r e d s l o t " ) ::= I n s t a n z v a r i a b l e ("local s l o t " ) > ::= V e r e r b u n g s r i c h t u n g

mit

302

II. Konstruktionen (Analyse und Synthese)

MAGAZINVERWALTER IBerechti gung) Name, Befugnisklasse, Kurzzei c h e n BESTELLUNG {Bestellen} Bestel1 V o r g a n g s n u m m e r , Bestell datum LAGERGUT ¡Einlagern) ; Entnehmen) [Anzahl-Transaktionen] [Aktuelle-Magazinverwalter] Produkt-Identifikation Produkt-Bezeichnung Datum-Letzte-Einlagerung Datum-Letzte - Entnahme. Lagerbedi ngung Bestand

-IEFERANT ; Li e f e r n 1 Fi r m e n n a m e Li e f e r scheinnummer

STUECKGUT Lagerdimension Kosten/Stueck Bestandswert

FLUESSIGKEIT Behaelterklasse Zuendtemperatury

FARBE Verfal1sdatum)

E0001

...

E9999

3ild 1 0 . 5 - 1 .

F0001

Magazinverwaltung: Skizze eines Vererbungsgraphen

.

F9999

III. Konstruktionsempfehlungen

Das Primärziel der Softwarekonstruktion ist eindeutig und unstrittig. Es ist: o nützliche Software zu konstruieren, d.h. Software, die eine nützliche Aufgabe erledigt, wobei die Erledigung vereinfacht oder erst ermöglicht wird, o und zwar hinreichend fehlerfrei und termingerecht. Von diesem Primärziel leiten sich eine Vielzahl von Sekudärzielen ab, wie z.B.: o Konstruiere Programm(teil)e in gewünschter Qualität, o Konstruiere Programm(teil)e, die wiederverwendbar sind, o Konstruiere Programm(teil)e, die sich pflegen und ergänzen lassen, o Konstruiere Programm(teil)e, die dokumentierbar und durchschaubar sind, o ... Diese Sekundärziele sind kein Selbstzweck. Wir fordern daher z.B. keine qualitativ hervorragende Dokumentation, sondern eine „angemessene", also am ökonomischen Primärziel „Nützlichkeit" gemessene Dokumentation. Die Dokumentation ist stets, auch im juristischen Sinne, wesentlicher Bestandteil der Konstruktion. Software ohne Dokumentation ist vergleichbar mit einer Wohnung ohne Fenster. Fehlt ein wesentlicher Bestandteil, dann ist die Übergabe unvollständig und das „Produkt" kaum nutzbar. Ein wesentlicher Bestandteil ist (häufig) ein wesentlicher Kostenfaktor. Daher wollen wir aus Kostenerwägungen das einmal „Erarbeitete" möglichst mehrfach nutzen. Aus diesem Wiederverwendungsziel hat sich das Baukasten-Konstruktionsprinzip entwickelt. Dieses in vielen Ingenieuerdisziplinen angewendete Prinzip fordert, daß eine Konstruktion aus möglichst wenigen standardisierten Bausteinen zu realisieren ist. Das Baukasten-Konstruktionsprinzip hat einen analytischen und einen synthetischen Aspekt. Das analytische Problem lautet: Wie kann eine gegebene Konstruktion durch eine Konstruktion gleicher Leistung ersetzt werden, die nur Konstrukte aus der vorgegebenen Konstruktemenge des genormten Baukastens verwendet? Das synthetische Problem lautet: Welche Konstrukte aus der vorgegebenen Menge werden benötigt, und welche Verknüpfungen dieser Konstrukte sind vorzunehmen, um eine Konstruktion mit der spezifizierten Leistung zu erhalten? Beide Aspekte betreffen die gesamte Konstruktion einschließlich Spezifikation und Dokumentation, also nicht nur die Konstruktion des Quellcodetextes. In diesem Kapitel diskutieren wir Empfehlungen für eine durchschaubare („transparente") Dokumentation (Abschnitt 11). Fragen der Benennung von Konstrukten (Abschnitt 11.1) und der Kommentierung im Quellcodetext werden ver-

304

III. Konstruktionsempfehlung

tieft (Abschnitt 11.2). Dabei erörtern wir die Bezugnahme auf vorhergehende und nachfolgende Dokumente (Abschnitt 11.3). Ein kleines Regelsystem verdeutlicht diese Empfehlungen (Abschnitt 11.4). Es weist Grundzüge der Konstruktion von sogenannten Produktionssystemen auf (z.B. im Sinne von OPS5, vgl. Forgy, 1981). LISP ist (wie jede höhere Programmiersprache) zur Spezifikation einer Aufgabe einsetzbar. Wir können mit LISP nicht nur die Lösung einer Aufgabe formulieren, sondern auch den Lösungsraum beschreiben. Die Spezifikation des Lösungsraums befaßt sich, etwas salopp formuliert, mit dem Problem „was gesollt werden soll" (kurz: mit dem WAS), d.h. mit der deskriptiven Aufgabenpräzisierung. Die Programmiersprache im engeren Sinne zielt auf das Problem, wie das Spezifizierte realisert wird (kurz: auf das WIE). Die Grenze zwischen WAS und WIE ist fließend. Das realisierbare WAS enthält in der Praxis (mindestens implizite) WIE-Aussagen. Eine Programmiersprache kann die Grenze in Richtung Lösungsraumbeschreibung zumindest im Umfang einer Pseudocode-Notation verschieben. Der Vorteil einer Pseudocode-Notation liegt in ihrer Flexibilität und der Einsatzmöglichkeit über mehrere Projektphasen. Sämtliche Eigenschaften und Merkmale eines Programms sind jedoch so nicht spezifizierbar, z.B. können keine Aussagen zur Antwortzeit, zum Betriebsmittelbedarf oder zu Realtime-Eigenschaften notiert werden. Programmiersprachen ersetzen daher nicht spezielle Spezifikationssprachen (z.B. SLAN-4, vgl. Beichter u.a., 1981). Die Empfehlungen zum Spezifizieren mit LISP basieren auf einer Beschreibung der Import- und Export-Schnittstellen. Ihre schrittweise Verfeinerung und Präzisierung wird anhand einer Checkliste vollzogen (Abschnitt 12.2). Vorab erörtern wir die Randbedingungen für das Spezifizieren in LISP-Notation (Abschnitt 12.1). Die Anforderungen an eine Konstruktion wie z.B. Effizienz, Transparenz, Wartbarkeit oder Portabilität bestimmen die Wahl der geeigneten Abbildungsbasis („Datenrepräsentation", vgl. Kapitel II). Die gewählte Abbildungsbasis erfüllt nicht alle gewünschten Eigenschaften gleich gut, da es sich teilweise um konkurrierende Eigenschaften handelt. Verschieben sich die Bewertungsgewichte, dann kommt ein Wechsel in Betracht. Einen solchen Wechsel der Abbildungsoption erörtern wir mit einem Beispiel aus der Graphik (Abschnitt 13). Dazu definieren wir Zeichenkonstrukte einer "Turtle Graphik" (Abschnitt 13.1). Ein Zeichengenerator für Struktogramme ist zunächst als „Nachrichtenversand"Lösung in SCOOPS definiert (Abschnitt 13.2). Zur Verbesserung der Antwortzeit wechseln wir zu einer Lösung mit dem DEFINE-STRUCTURE-Konstrukt und einer zugeordneten Verzweigungsfunktion (Abschnitt 13.3). Zur reinen Freude ist in diese Lösung auch eine Fraktalfigur eingebaut (Abschnitt 13.4).

11. Transparenz der Dokumentation

305

11. Transparenz der Dokumentation Konstruieren heißt dokumentieren. Das Ergebnis dieser Tätigkeit, die Konstruktion, ist ebenfalls ein Dokument. Softwarekonstruktion bedeutet, eine vorgegebene Kette von Dokumenten zu produzieren. Das Kostenbudget und die Termin vorgaben bedingen, daß wir diese dominierende Aufgabe nicht mißinterpretieren: „Je mehr Dokumente produziert werden, umso besser". Häufig gibt es zu viele (unnütze, nicht zweckorientierte) Dokumente (vgl. z.B. Schnupp/Floyd, 1979, S.205). Bei der Dokumentation geht es nicht um die Menge, sondern um die Qualität, d.h. um die Transparenz in Bezug auf ein schnelles und hinreichend genaues Verstehen der Konstruktion. Die populäre Dokumentationsstrategie orientiert sich an der Maxime: Erst Entwurf, dann Reinschrift! Damit ist Dokumentieren stets eine nachträgliche Arbeit. Die Dokumentation, die erst nach vollbrachter Tat, d.h. nach Abschluß der eigentlichen Konstruktion, entsteht, vergeudet Zeit und ist (fast) nutzlos. Zu solchen Nacharbeiten zählen insbesondere (vgl. z.B. Rogers, 1988, S.140): o die verbale Beschreibung der Kontrollstruktur, o Programmablaufpläne (PAP's) und o das Einfügen von Kommentaren. Ab einer gewissen Komplexität der Konstruktionsaufgabe sind: o vorbereitende Dokumente (Lastenheft, Pflichtenheft, Begründungen für das gewählte Konzept etc.), o Konstruktions-begleitende Dokumente (Testprotokolle, Integrationspläne etc.) und o nachbereitende Dokumente (Wartungsrichtlinien, Installationsanweisungen etc.) zu erstellen. Wir untergliedern daher die Dokumentation in Dokumente, die das Ergebnis (die Software im engeren Sinne) beschreiben und in Dokumente, die den Prozeß ihrer Erstellung nachweisen. Dokumentation ::= (+ Konstruktions-Dokumentation Konstruktions-Prozeßdokumentation) In der Praxis entstehen Dokumente mehr oder weniger iterativ. Ideenskizzen werden ergänzt, verworfen, weiterentwickelt. Bei diesem (Iterations-)Prozeß ist die allgemein übliche Arbeitsteilung in „so-eben-mal-skizziert" und in „Reinschrift-mit-ausreichender-Erklärung" auf kreative Ausnahmefälle zu begrenzen. Jede Aktivität im Rahmen des Konstruktionsprozesses ist gleich so zu notieren, daß sie Teil der Dokumentation sein kann. Unstrittig ist es ein echtes Problem,

306

III. Konstruktionsempfehlung

wie die entscheidenden Konstruktions-Absprachen, vielleicht notiert auf einem Bierdeckel, ohne Fehler in die Konstruktions-Prozeßdokumentation gelangen (zumal keiner den Mut haben wird, den Bierdeckel dort abzuheften). Zu fordern ist daher, jede Idee unverzüglich rechnergestützt zu notieren, entweder direkt in ein LISP-System oder in einen Texteditor. Sowohl in den ersten Phasen des Konstruktions-Prozesses als auch in den Phasen Wartung/Pflege und Fortentwicklung hat man das Problem, sich auf die wesentlichen Aussagen zu konzentrieren. Im ersten Fall fehlt eine stabile Basis (Spezifikation), im zweiten sucht und vergleicht man und kann die Informationsfülle nicht verarbeiten. Beide Situationen zeigen, daß es notwendig ist, unsere Aussagen in einer auf das Wesentliche verkürzten Form zu notieren. Was Wesentlich ist richtet sich: o nach den Adressaten und o dem Zweck des Dokumentes. Adressaten-Ausrichtung:

Die einzelnen Dokumente wenden sich an unterschiedliche Adressaten, z.B. an Benutzer, Operateure, Auftraggeber, Projektmanager, Systemdesigner, Programmierer, Vertriebspersonal etc. Kaum jemand von ihnen liest eine Dokumentation gern, freiwillig oder mehr als nötig. Schon aus diesem Grunde ist die Dokumentation in „bewältigbare" Abschnitte zu gliedern, die von den einzelnen Adressaten tatsächlich gelesen werden.

Wir formulieren keine Zeile ohne Annahmen über das Vorwissen und die vertraute Terminologie des Lesers. Zumeist unterstellen wir implizit ein unscharf durchdachtes Adressatenmodell. Notwendig ist jedoch hinreichende Klarheit über das annehmbare Leserverständnis. Welche Aspekte zu beschreiben sind und welche unerwähnt bleiben können, weil sie zum angenommenen „Leser-

11. Transparenz der Dokumentation

307

fundus" gehören, können wir nur anhand unseres unterstellten „Norm"-Adressaten entscheiden. Ist der Leser z.B. ein LISP-Programmierer, der den LISP-Quellcodetext zu pflegen hat, dann ist anzunehmen, daß dieser Adressat, die eingebauten, primitiven LISP-Konstrukte erkennt und versteht. Eine Kommentarzeile: „Hier wird die Datei X geöffnet" nach einem OPEN-Konstrukt ist daher unsinnig. Sinnvoll wäre z.B. die Erläuterung: „X ist als Datei abgebildet, damit der maximale Arbeitsspeicherbedarf kleiner als 1 MB bleibt". Da das Verständnis und der Kenntnisstand des Lesers mit der Benutzung der Dokumention wächst und sich infolgedessen seine Terminologie verändert, wäre eine Anpassung der Dokumentation an diese Veränderung wünschenswert. Soweit das Dokument rechnergestützt geführt wird, ist die Einprogrammierung verschieden kundiger Leserklassen (z.B. Anfänger, Eingeübter, Experte) ein üblicher Ansatz. Anzustreben ist eine Aktivitätsverschiebung. An die Stelle eines Dokumentes, das gelesen werden kann, tritt ein Dokumentations-Programm, das den Inhalt zugeschnitten auf den aktuellen Wissenstand des Lesers präsentiert. Lösungsansatz ist ein Dialog mit dem Leser, der Aufschluß über sein aktuelles Verständnis gibt (ohne dabei die Datenschutzaspekte zu mißachten!). Diese dynamische Klassifikation des Lesers wird genutzt, um eine Anpassung der anzuzeigenden Formulierungen zu realisieren. Während der Adressat „Rechner" den beherrschten Sprachschatz eindeutig in Form der verarbeiteten Konstrukte und Konstruktionen "offenbart", ist beim jeweiligen Leser ungewiß, ob dieser eine Formulierung tatsächlich hinreichend genau versteht. Kennt z.B. der Programmierer den Begriff „Rechnungsabgrenzungs-Konto"? Assoziiert er damit die Definition, die an anderer Stelle (vielleicht außerhalb der Dokumentationskette) in der Terminologie der Kaufleute formuliert wurde, oder muß dieser Begriff in dem betreffenden Dokument erst erklärt werden, oder genügt ein Verweis auf eine einschlägige Fundstelle? Jede einzelne Formulierung hat sich an der Antwort auf die Frage zu orientieren: Welche Assoziationen kann der Adressat beim Lesen haben, welche davon sind nicht präzise genug oder stehen sogar im Widerspruch zum Gemeinten? Es geht um die Entscheidung: Was ist unbedingt zu beschreiben, und was kann für sich selbst sprechen? Je mehr für sich selbst spricht, um so kürzer wird das Dokument. Die Umfangreduktion ist im Hinblick auf die Lesemotivation ein positives Ziel. Wir wollen daher nur etwas (zusätzlich) erläutern, wenn der Leser ohne diese Erläuterung die Aussage nicht oder falsch versteht. Damit beugen wir einer kostenintensiven, unnützen und zum Teil schädlichen Aufblähung der Dokumentation vor. Prinzipiell ist aus dem Quellcodetext (mit Kenntnis des jeweiligen LlSP-Systems) die Abarbeitung nachvollziehbar. Das WIE ist, wenn auch recht mühsam, rekonstruierbar. Aus welchen Gründen wir ein Konstrukt gerade so und nicht anders definieren, ist vom Leser nicht ohne weiteres rekonstruierbar. Ein paar Sätze zur WARUM-Darstellung sind daher oftmals hilfreicher als ausführliche

308

III. Konstruktionsempfehlung

Erläuterungen zum WIE. Wegen der Nicht-Rekonstruierbarkeit besteht eine besondere Pflicht, das WARUM explizit zu notieren. Zweck-Ausrichtung: Ein Dokument ist auf die Zwecke auszurichten, die es erfüllen soll. Gliederung, Inhalt und Gestaltung (Layout) des Dokuments sind zweckorientiert zu erarbeiten. Ein Pflichtenheft, als eine Vertragsgrundlage zwischen Auftraggeber und Softwarekonstrukteur wird so gestaltet, daß Inhaltsänderungen nur über schriftliche Zusatzvereinbarungen möglich sind (d.h. z.B. gebundene Seiten mit durchlaufender Seitennumerierung gemäß „Seite i von n Seiten"). Ein Benutzerhandbuch ist stattdessen eine Loseblattsammlung, um Ergänzungen und Korrekturen an den richtigen Platz durch Austausch der Seiten aufnehmen zu können. Ein Formulierungskonflikt besteht zwischen der Zweckausrichtung und dem Baukasten-Konstruktionsprinzip (Mehrfachverwendbarkeit). Die Aussagen sind so zu formulieren, daß eine Mehrfachverwendung einzelner Passagen und/oder ganzer (Teil-)Abschnitte in anderen Dokumenten möglich ist. Beispielsweise sollen Textpassagen des Pflichtenheftes auch für Vertriebs- und EinführungsDokumente verwendbar sein. Diese Forderung nach Mehrfachverwendung verlangt möglichst kontextunabhängig zu formulieren. Die Zweckausrichtung führt jedoch zur Kontextintegration. Zu vermeiden ist eine Kontextabhängigkeit, die sich nicht aus der Zweckausrichtung ableitet. Für ein Plichtenheft sind daher z.B. die Aussagen nicht in der Zukunftsform zu notieren, sondern im Präsens. Weil es zunächst um etwas Zukünftiges geht, wählt der Autor spontan die Zukunfsform („Das Programm R E C H N U N G wird die Mehrwertsteuer berechnen"). Erst die Notation im Präsens bringt die Herauslösung aus dem Kontext „zukünftige Eigenschaft". („Das Programm R E C H N U N G berechnet die Mehrwertsteuer"). Für große Konstruktionen (vgl. Tab. 12-3) sind Dokumentationsregeln verbindlich vorzuschreiben. Im Bereich der öffentlichen Verwaltung sind es z.B. die KoopA-ADV-Rahmenrichtlinien (Näheres dazu vgl. z.B. Bonin, 1988). Solche Richtlinien bestimmen welchen Inhalt die einzelnen Dokumente des Konstruktionsprozesses haben (sollen!). Sie ermöglichen erst eine effiziente Kooperationen bei einer größeren Anzahl von Beteiligten und Betroffen. Allerdings motiviert eine Richtlinie zum Schreiben, bei dem ein schnelles Abhaken einer lästigen Vorgabe in den Mittelpunkt rückt. Die angestrebte Vollständigkeit wird in der Praxis mit mehr oder weniger aussageleeren Phrasen erfüllt. Die pragmatische Empfehlung lautet daher: „Sei kein Formalist, der Richtlinien abhakt, sondern schreibe adressaten- und zweck-ausgerichtet!". Im folgenden wird die Transparenz des Quellcodetextes behandelt. Dazu erörtern wir die drei Dokumentationsprobleme:

11. Transparenz der Dokumentation

309

o Benennung von Konstrukten, o Kommentierung und o Vor- und Rückwärtsverweise. Diese Punkte sind von praktischer Bedeutung, wenn eine vorgegebene Spezifikation umzusetzen ist. Empfehlungen zur Erarbeitung einer solchen Spezifikation behandeln wir anschließend (Abschnitt 12).

11.1 Benennung Der „Name" eines Konstruktes sei nicht irgendein Symbol, sondern benennt diejenige Eigenschaft, die es von allen anderen unterscheidet. Offensichtlich ist der Name bedeutsam für die Transparenz der gesamten Dokumentation (incl. Quellcodetexte). Mit der Namensvergabe für „Objekte", Funktionen, Makros, Variablen, Konstanten etc. sind zumindest zwei Aspekte verknüpft: o mnemotechnischer Aspekt Ziel ist eine leicht einprägsame Benennung im Sinne eines Verweises auf das „Gemeinte" (Objekt) in der „realen" Welt. Es geht um eine Korrelation zwischen der Bezeichnung des „realen" Objektes und der Bezeichnung des „formalen" Objektes (vgl. Abschnitt 2.1) o konstruktionsbedingter Aspekt Ziel sind Aussagen zu konstruktions-spezifischen Aufgaben und Eigenschaften (vgl. Abschnitt 4); z.B. Informationen zur Beantwortung der Fragen: - Ist es ein eingebautes Konstrukt? - Ist es ein risikoreiches Konstrukt?

Die Benennung ist zusätzlich abhängig vom jeweiligen Denkrahmen („Paradigma") des Konstrukteurs (vgl. Abschnitt 4). Daher wird beispielsweise empfohlen, Funktionsnamen so zu wählen, „daß sie implizit Annahmen über ihre Arbeit

310

III. Konstruktionsempfehlung

in Form von , Verträgen' über Eingabe-Ausgabe-Relationen aufdrängen." (Stoyan/Görz, 1984, S.56). Im objektgeprägten Denkrahmen sind Operationen mit Verben und Operanden mit Substantiven zu benennen. Im imperativgeprägten Denkrahmen haben alle Bezeichnungen Befehlscharakter an den ausführenden Rechner („Kasernenhof'-Formulierungen). Orientiert am jeweiligen Denkrahmen wären für ein Konstrukt, das z.B. den Firmenkurznamen eines Kunden selektiert, folgende Benennungen zu wählen: Imperativgeprägte Konstruktion: GIB-FIRMEN-KURZNAME Funktionsgeprägte Konstruktion: KUNDE->FIRMEN-KURZNAME Objektgeprägte Konstruktion: SELEKTIEREN-FIRMEN-KURZNAME Als konstruktionsbedingte Informationen wollen wir mit der Benennung z.B. vermitteln: o den (Daten-)Typ Ist es eine Funktion, eine Variable, ein Makro etc.? Z.B.: F-BILANZABGLEICH ;Funktion V-BILANZABGLEICH ;Variable M-BILANZABGLEICH ;Makro o den aufgabensspezifischen Typ Ist es ein Konstruktor, Prädikat, Selektor oder Mutator? (vgl. Tab. 11.1-2) o die Flußrichtung In welche Richtung fließen die Daten? Z.B.: INPUT-KUNDENDATEI oder OUTPUT-KUNDENDATEI o den Wertebereich Ist es ein Zahlatom oder String? Z.B.: ZAHL-BILANZ-AKTIVA oder STRING-BILANZ-AKTIVA o die Aufgabe Ist es eine LAMBDA-Variable, ein Argument, eine Hilfsvariable etc.? Z.B.: BILANZ. AKTIVA ;Unterstrich für LAMBDA-Variable BILANZ-AKTIVA ¡Bindestrich für Argument BA ;weniger als 3 Buchstaben für ; temporäre Hilfsvariable o die Lebensdauer (Persistenz) Ist der Speicherort eine Stamm-, Bewegungs-, Hilfs-Datei oder der Arbeitsspeicher? Z.B.: DB-KUNDE ;Stammdatei (Datenbank) WS-KUNDE; Arbeitsspeicher ; (working storage) Empfehlungen zur Namensvergabe beziehen sich häufig auf konstruktionsspezifische Informationen. So wird empfohlen, einen Konstruktor oder Selektor derart zu bezeichnen, daß man den Datentyp ersehen kann, den die Schnittstelle des Konstruktes erwartet. Ein typisches Beispiel für einen solchen Namen ist:

11. Transparenz der Dokumentation

311

ARGLIST!FIRST-ARG (Steele, B„ 1980, S.176). Oder es wird präzisiert, in welchen Fällen die Selektoraufgabe vor der Prädikataufgabe im Namen Vorrang hat. In Scheme haben daher die Konstrukte MEMQ, MEMV, MEMBER, ASSQ, ASSV und ASSOC kein Fragezeichen am Namensende, weil sie nützliche Werte und nicht nur den Standardwahrheitswert #T zurückgeben (vgl. Rees/Clinger, 1986). Sind viele Aspekte mit dem Namen zu vermitteln, dann führt dies zwangsläufig zu sehr langen Namen. Lange Namen vergrößern den Umfang der Dokumente. Sie führen darüber hinaus schnell zu Problemen bei einer begrenzten Zeilenlänge. Vor- und Nachteile bezogen auf die Namenslänge zeigt Tabelle 11.1-1. B e w e r t u n g s k r i teri um

langer

11.1-1

Namenslänge:

Vorteile

-

-

(+)

und

(-)

Beispiel:

einen Konstruktor: ein Prädikat: ein d e s t r u k t i v e s Konstrukt (Mutator): für eine b e s o n d e r e (globale) Variable: eine eingebaute Konstante: 11.1-2

Nachteile

:[][]

für für für

Tab.

Namen

+ + +

-

Empfehlung:

für

kurzer

+

(mnemotechnische) Aussagekraft Lesbarkeit/Leseaufwand Schrei baufwand Schreibfehlerrisiko Tab.

Namen

AFFIX-Empfehl

< p r ä f i x> < s u f f i x>

:= M A K E := ?

MAKE-WINDOW E0F-0BJECT?

< s u f f i x>

:=

SET-CDR!



:= * := *

< p r ä f i x>

:= #i

!

*GRAPHICS-COLORS* #! EOF

ungen

Ein Name, insbesondere ein langer Name, ist zu strukturieren. Wir unterteilen einen Namen in eine Vorspann (Präfix), den Hauptteil (Stamm) und einen Nachspann (Suffix). Die Tabelle 11.1-2 zeigt die verwendete Regelung für Präfix und Suffix, die zusammen als Affix bezeichnet werden. Die Optionen zur Wahl und Strukturierung eines zweckmäßigen Namens erörtern wir anhand eines Beispiels. Es sei der Kurzname der Firma aus den Kundendaten zu selektieren. Dazu betrachten wir sowohl die Namen bei der Funktionsdefinition, also die Benennung der LAMBDA-Abstraktion, als auch die Funktionsapplikation, also zusätzlich die Namen der Argumente. Uns interessieren

312

III. Konstruktionsempfehlung

die Wirkungen der unterschiedlichen Benennung im Hinblick auf die Transparenz der gesamten Konstruktion. Dazu betrachten wir exemplarisch vier Entscheidungsprobleme: o die Informationsaufteilung zwischen dem Funktionsnamen und den Namen für die LAMBDA-Variablen, o das (standardisierte) Einbeziehen von konstruktionsbedingten Informationen, o die Informationsaufteilung zwischen Namen und einem zugeordnetem (Daten-)Lexikon und o die Sortierfähigkeit für ein schnelles Recherchieren. Aus Vereinfachungsgründen liegen die Kundendaten in unserem Beispiel als Liste vor, wobei der Firmenkurzname als optionales zweites Listenelement angegeben ist. Zwei Kunden sind vorab folgendermaßen definiert: eval> (DEFINE KUNDE -1 '("Software AG" "SAG")) ==> KUNDE -1 eval> (DEFINE KUNDE - 2 '("Siemens AG")) ==> KUNDE-2 Ist der Firmenkurzname nicht angegeben, dann ist ein Ersatzwert zu selektieren. Dieser ist, wie folgt, definiert: eval> (DEFINE UNBEKANNTER-KURZNAME* " - ? - " ) ==> *UNBEKANNTER-KURZNAME* Problem 1:

Informationsaufteilungzwischen Funktionsname und Namen der LAMBDA-Variablen

Bei der Benennung des gewünschten Selektors ist zu entscheiden, welche Informationen im Funktionsnamen und welche in den Namen der LAMBDA-Variablen zu hinterlegen sind. Lösung A: o Funktionsname Haupt-Informationsträger o Kurze beliebige Namen für die LAMBDA-Variablen eval> (DEFINE KUNDEN->FIRMEN-KURZ NAME/ERSATZ (LAMBDA ( X . Y ) (OR (LIST-REF X 1) (LIST-REF Y 0 ) ) ) ) ==> KUNDEN->FIRMEN-KURZNAME/ERSATZ eval> (KUNDEN->FIRMEN-KURZNAME/ERSATZ KUNDE -1 *UNBEKANNTER-KURZ NAME*) ==> "SAG" Lösung B: o Funktionsname und Namen der LAMBDA-Variablen sind gleichbeteiligte Informationsträger eval> (DEFINE FIRMEN-KURZNAME (LAMBDA (KUNDE . ERSATZ_KURZNAME)

11. Transparenz der Dokumentation (OR

(LIST-REF (LIST-REF

313

KUNDE 1 ) ERSATZ_KURZNAME

0)))) ==>

eval>

(FIRMEN-KURZNAME

FIRMEN-KURZNAME

KUNDE - 1 U N B E K A N N T E R - K U R Z N A M E * )

Problem 2: Einbeziehen von konstruktionsbedingten

==>

"SAG"

Informationen

Die Namen in den Lösungen A und B enthalten keine Typ-Aussagen. So ist nicht erkennbar, daß die Funktion ein Selektor ist und ihr erstes Argument eine Liste sein muß. Lösung C: o Präfix des Funktionsnamens verweist auf den Typ Selektor o LAMBDA-Variablen geben Informationen in Bezug auf die zulässigen Argumente eval>

(DEFINE SELEKTIERE-FIRMEN-KURZNAME (LAMBDA ( L I S T E . E R S A T Z . S T R I N G ) (OR ( L I S T - R E F L I S T E 1 ) ( L I S T - R E F E R S A T Z _ S T R I N G 0 ) ) ) ) = = > S E L E K T I E R E - F I R M E N - KURZNAME

eval>

(SELEKTIERE-FIRMEN-KURZNAME

KUNDE - 2

UNBEKANNTER-KURZNAME*)

Diese Lösung ist auch weniger imperativgeprägt, wie folgt, formulierbar: eval>

(DEFINE SELEKTION-FIRMEN-KURZNAME (LAMBDA ( L I S T E . E R S A T Z . S T R I N G ) (OR ( L I S T - R E F L I S T E 1 ) ( L I S T - R E F E R S A T Z _ S T R I N G 0 ) ) ) ) = = > S E L E K T I O N - F I R M E N - KURZ NAME

eva1>

(SELEKTION-FIRMEN-KURZNAME

KUNDE - 2

UNBEKANNTER-KURZNAME*)

Die Information, daß die Funktion ein Selektor darstellt, ist sicherlich kürzer mit einem vorgegebenen Präfix, z.B. GET-, notierbar. Die Information, daß die erste LAMBDA-Variable an eine Liste zu binden ist, kann ebenfalls kürzer notiert werden. Wir können für eine ganze Konstruktion vereinbaren, daß z.B. eine LAMBDA-Variable mit dem Namen L, stets ein Argument vom Typ Liste erfordert. Die zweite LAMBDA-Variable im Beispiel verweist auf einen String. Diese Information ist in diesem Funktionskörper unerheblich. Die LAMBDA-Variable ERSATZ_ STRING wird aufgrund der Punkt-Paar-Notierung in der Schnittstelle des Konstruktes stets an eine Liste gebunden (vgl. Abschnitt 6.3). Das Konstrukt (LIST-REF E R S A T Z . STRING 0) selektiert das erste Element, unabhängig davon, von welchem Typ es ist. Wir können daher in diesem Konstrukt auf den Namensteil STRING verzichten. Lösung D: o Standard-Selektor-Präfix beim Funktionsnamen o Standard-Namen für LAMBDA-Variablen mit Informationen in Bezug auf die zulässigen Argumente (soweit erforderlich)

314 eval>

eval>

III. Konstruktionsempfehlung (DEFINE GET-FIRMEN-KURZNAME (LAMBDA (L . E R S A T Z ) (OR ( L I S T - R E F L 1 ) ( L I S T - R E F (GET-FIRMEN-KURZNAME

KUNDE-2

ERSATZ 0 ) ) ) ) ==> GET-FIRMEN-KÜRZNAME UNBEKANNTER-KURZNAME*) = = >

" - ? - "

Problem 3: Informationsaufteilung zwischen Namen und Lexikon Nachteilig ist, insbesondere bei häufiger Applikation der Lösung D, daß der Name GET-FIRMEN-KURZNAME mit 19 Zeichen recht lang ist. Wir verkürzen ihn daher. Zusätzlich präzisieren wir bei der LAMBDA-Variable ERSATZ, wofür diese als Ersatz dienen soll. Wir nennen sie jetzt NAME und verweisen mit dem Sonderzeichen ? als Präfix auf ihre Aufgabe. Sie ist Ersatz für den Firmenkurznamen, wenn dieser in den Kundendaten unbekannt ist. Lösung E: o Verkürzung der Namen von Lösung D o Nutzung von Sonderzeichen eval>

eval>

(DEFINE GET-F-K-NAME (LAMBDA (L . ?_NAME) (OR ( L I S T - R E F L 1 ) (GET-F-K-NAME

(LIST-REF

?_NAME

0)))) ==>

KUNDE-1 ^UNBEKANNTER-KURZNAME*)

GET-F-K-NAME ==>

"SAG"

Dieses Verkürzen führt rasch zu Namen, deren Bedeutung sich niemand merken kann. Wofür steht F und wofür K ? In der Praxis ist dann permanent in einem (Daten-)Lexikon nach der eigentlichen Bedeutung nachzuschauen. Das Suchen können wir für das rechnergestützte Lesen vereinfachen. Mit Hilfe der Eigenschaftsliste speichern wir für jeden verkürzten Namen die vollständige Fassung. Dazu formulieren wir zwei Makros. Das Makro ::= schreibt die Erläuterung in die Eigenschaftsliste. Das Makro ? ermöglicht das Nachfragen. Da die Eigenschaftsliste global ist, kann in jeder Umgebung nachgefragt werden (Zu den Nachteilen dieser Globalität vgl. Abschnitt 5.3). Lösung F: o Lösung E in Verbindung mit einem (Daten-)Lexikon als Eigenschaftsliste eval>

eval>

(DEFINE * I S T * (GENSYM)) ==>

(MACRO

?

(LAMBDA

'(GETPROP eval>

(MACRO

::=

"(PUTPROP

*IST*

;GENSYM d a m i t k e i n e E i g e n s c h a f t ü b e r ; schrieben wird (vgl. Abschnitt 7.4).

(SEXPR)

\(LIST-REF (LAMBDA

SEXPR

1)

MST*)))

==>

(SEXPR)

' , ( L I ST-REF

SEXPR

1)

.(LIST-REF

SEXPR

2)

MST*)))

==>

?

315

11. Transparenz der Dokumentation

eval>

(DEFINE

GET-F-N-NAME

(BEGIN (::= GET-F-N

"Kurzname der

Firma")

(::= ?_NAME "Ersatzwert für den Kurznamen der (LAMBDA

Firma")

(L . ?_NAME)

(OR CLIST-REF L 1) (LIST-REF ?_NAME

0))))) ==>

GET-F-K-NAME

eval>

( G E T - F - K - N A M E KUNDE-1 * U N B E K A N N T E R - K U R Z NAME*) ==>

eval>

(? G E T - F - K - N A M E ) ==>

"Kurzname der

"SAG"

Firma"

Das so mitgeführte Lexikon ist eine wenig effiziente, beschränkt nützliche Lösung, die beim Testen hilft (vgl. auch „documentation string", Abschnitt 11.2). In allen nicht rechnergestützten Lesefällen ist sie nicht besser als eine Semikolon-Notation (vgl. Abschnitt 11.2). Problem 4: Reihenfolge im Lexikon Mit dem Verweis auf eine zusätzliche Beschreibung in einem Lexikon wird deutlich, daß der Name so zu wählen ist, daß wir diese Beschreibung leicht finden; auch im Suchfall ohne direkte Rechnerunterstützung. Mit einem standardisierten Präfix für Selektoren (hier: GET-) werden diese im Lexikon alle hintereinander ausgewiesen. Wahrscheinlich bevorzugen wir jedoch eine Ordnung, bei der unser Verbund von Konstruktor, Selektor, Prädikat und Mutator (vgl. Abschnitt 4.2) hintereinander ausgewiesen wird. Suchen wir z.B. in PC Scheme die Beschreibung für WINDOW-Konstrukte, dann durchlaufen wir folgende Reihenfolge der Lexikoneinträge: WINDOW-CLEAR WINDOW-DELETE WINDOW-GET-ATTRIBUTE

WINDOW-SET-SIZE! WINDOW?

Selbst hier ist der zugehörende Konstruktor nicht konsequent mit WINDOWMAKE, sondern mit MAKE-WINDOW bezeichnet und befindet sich daher viel weiter vorn im Lexikon. Wir können die gewünschte Reihenfolge erreichen, indem wir jeweils einen Standard-Suffix für Konstruktor, Selektor, Prädikat und Mutator verwenden.

316

III. Konstruktionsempfehlung

Lösung G: o Standard-Suffix für den Verbund von Konstruktor, Selektor, Prädikat und Mutator eval>

(DEFINE FIRMEN-NAME-MAKE (LAMBDA (LANGNAME . KURZNAME) ( I F KURZNAME (CONS LANGNAME KURZNAME) (LIST LANGNAME)))) ==>

FIRMEN-NAME-MAKE

eval>

(DEFINE FIRMEN-KURZNAME-GET (LAMBDA ( K U N D E N L I S T E . E R S A T Z . K U R Z N A M E ) (OR ( L I S T - R E F KUNDENLISTE 1) ( L I S T - R E F ERSATZ_KURZNAME 0)))) ==> F I R M E N - K U R Z N A M E - G E T

eval>

(DEFINE FIRMEN-KURZNAME? (LAMBDA (KURZNAME) (AND (STRING? KURZNAME) ( F I R M E N - K U R Z N A M E ?

eval>

(DEFINE FIRMEN-KURZNAME-SET! (LAMBDA ( K U N D E N L I S T E KURZNAME) (SET-CDR! KUNDENLISTE (LIST KURZNAME)))) ==> F I R M E N - K U R Z N A M E - S E T !

eval>

(FIRMEN-KURZNAME-GET

KUNDE-1

*UNBEKANNTER-KURZNAME*) ==>

"SAG"

Die Berücksichtigung der Reihenfolge führt zu Formulierungen, die im Vergleich zur Präfix-Verschlüsselung (Lösung D), ungewohnt und weniger flüssig zu lesen sind. eval> eval>

FIRMEN-KURZNAME-GET GET-FIRMEN-KURZNAME

==> ==>

... ...

¡zweckmäßige Sortierbarkeit ¡ r e l a t i v gute Lesbarkeit

Wir haben für die Strukturierung eines Namens die Sonderzeichen, Bindestrich und Unterstrich, verwendet. Unsere Konvention reserviert den Bindestrich für Funktionsnamen und damit auch für Argumente. Der Unterstrich ist für die LAMBDA-Variablen reserviert. Option:

Groß/Kleinschreibung

Eine Strukturierung kann auch durch Groß/Kleinschreibung erfolgen. Darüber hinaus nutzen wir dann den Vorteil, daß Geschriebenes in Kleinbuchstaben um ca. 20 bis 50 Prozent schneller als in Großbuchstaben gelesen wird (untersucht von Stuart/Stuart Gardner, 1955; zitiert nach Carte, 1973). Wesentliche Ursache ist die Wellenform der oberen und unteren Linie bei Wörtern mit Kleinbuchstaben; z.B. „Der neue'Weg" statt „DER NEUE WEG". Die Groß/Kleinschreibung kommt allerdings nicht für jedes LISP in Betracht, weil häufig, so auch in PC Scheme, in der READ-Phase Kleinbuchstaben in große Buchstaben umgesetzt werden (vgl. Abschnitt 7.3).

11. Transparenz der Dokumentation

317

Lösung H: o Groß/Kleinschreibung zur Namensstrukturierung e v a l > ( d e f i n e FirmenKurzname (lambda ( K u n d e n L i s t e . ErsatzName) (or ( l i s t - r e f KundenListe 1) ( l i s t - r e f ErsatzName 0 ) ) ) ) ==> FIRMENKURZNAME In PC Scheme wäre eine solche Groß/Klein-Notation, wie sie z.B. in SmallTalk üblich ist (vgl. Goldberg/Robson, 1983), nicht sinnvoll. Schon der Rückgabewert des DEFINE-Konstruktes ist ein Symbol aus Großbuchstaben. Laden wir das Konstrukt aus einer Datei oder geben es z.B. mit dem eingebauten „PrettyPrint"-Konstrukt aus, stets verlieren wir die Groß/Kleinunterscheidung. e v a l > (PP FirmenKurzname) ==> # = (LAMBDA (KUNDENLISTE . ERSATZNAME) (OR ( L I S T - R E F KUNDENLISTE 1) ( L I S T - R E F ERSATZNAME 0 ) ) ) Man kann ein eigenes PP-Konstrukt definieren, das bei seiner Ausgabe große und kleine Buchstaben nutzt. Es kann eingebaute LISP-Konstrukte in Kleinbuchstaben und selbstdefinierte Konstrukte in Großbuchstaben ausgeben (vgl. z.B. das PP-Konstrukt in T L C - L I S P ) . e v a l > (MEIN-PP FirmenKurzname) ==> ( d e f i n e FIRMENKURZNAME (lambda (KUNDENLISTE . ERSATZNAME) (or ( l i s t - r e f KUNDENLISTE 1) ( l i s t - r e f ERSATZNAME 0 ) ) ) Um in PC Scheme die Groß/Kleinschreibung wie in anderen LISP-Systemen (z.B. in Allegro Common L I S P ) als Strukturierungsoption nutzen zu können, ist das Fluchtsymbol (vgl. Abschnitt 7.3) mitzunotieren, wie die Lösung I zeigt. Lösung /: o Groß/Kleinschreibung mit Fluchtsymbol zur Namensstrukturierung e v a l > (DEFINE |SeiektionFirmenKurznameI (LAMBDA ( ¡ K u n d e n L i s t e ! . ¡ErsatzName!) (OR ( L I S T - R E F ¡KundenListe! 1) ( L I S T - R E F ¡ErsatzName! 0 ) ) ) ) ==> ] S e i e k t i o n FirmenKurzname! Mit dem (mühsam) notierten Fluchtsymbol könnte man auch Leerzeichen zum Strukturieren des Namens verwenden. Ein Name kann somit ein ganzer Satz sein. e v a l > (DEFINE e v a l > (DEFINE

!* Unbekannter Kurzname * ! " - ? - " ) ==> !* Unbekannter Kurzname * | ¡Kunde 3| ' ( " T o s h i b a " ) ) ==> ¡Kunde 31

318

III. Konstruktionsempfehlung

eval>

(DEFINE ¡ S e l e k t i e r e FirmenKurzname a n d e r n f a l l s g i b ErsatzName! (LAMBDA ( i K u n d e n L i s t e I . ! E r s a t z N a m e | ) (OR ( L I S T - R E F ! K u n d e n L i s t e ! 1 ) (LIST-REF |ErsatzNameI 0)))) ==> ' S e l e k t i e r e FirmenKurzname a n d e r n f a l l s gib ErsatzName!

eval>

(¡Selektiere ¡Kunde 3!

FirmenKurzname |* U n b e k a n n t e r

a n d e r n f a l l s gib ErsatzName! Kurzname * | ) = = > " - ? - "

Option: ALIAS-Namen Mit Hilfe des ALIAS-Konstruktes kann ein Name wie ein anderer, schon existierender Name verwendet werden. Beide Namen bezeichnen dieselbe „Einheit". Man könnte spontan einen „Sonntags"- und einen „Alltags"-Namen kreieren. Der „Sonntags"-Name ist lang und enthält die gewünschten Informationen. Der „Alltags"-Name ist eine Kurzschreibweise dessen. Zunächst wird nur der „Sonntags"-Name genutzt. Käme dieser Name jedoch in einem Textbereich häufig vor, dann wechselt man zum „Alltags"-Namen. Man mutet dem Leser zu, sich die Bedeutung eines häufig notierten Namens einzuprägen, um die Verkürzungsvorteile nutzen zu können. Lösung J: o zwei Namen eval> eval> eval>

( A L I A S f LAMBDA) = = > f (ALIAS = DEFINE) ==> = (= FIRMEN-KURZNAME-GET (f (L . ERSATZ) (OR ( L I S T - R E F L 1 )

eval>

(ALIAS

F-K-GET

eval>

(F-K-GET

(LIST-REF

ERSATZ ==>

FIRMEN-KURZNAME-GET)

KUNDE-2

==>

*UNBEKANNT ER-KURZNAME*)

0)))) FIRMEN-KURZNAME-GET F-K-GET ==>

"-?-"

Die Gefahren, die eine solche doppelte Benennung hervorruft, sind nicht zu unterschätzen. Im Analysefall sind stets beide Namen zu verfolgen. Wir wählen daher für selbstdefinierte Mutatoren stets nur einen Namen. Beachten wir bei der Wahl eines Namens nicht die Informationsaufteilung mit dem (Daten-)Lexikon und mit weiteren Namen, die z.B. im Zusammenhang mit seiner Anwendung relevant sind, dann wird der Name lang, und wir müssen die damit verbundenen Nachteile (vgl. Tab. 11-1) in Kauf nehmen (Lösung A). Anzustreben ist eine Rechnerunterstützung beim Lesevorgang, weil damit ein zweckmäßiger Kompromiß zwischen Namen und Lexikon erreichbar ist (Ansatz z.B. Lösung F). Die Groß/Kleinschreibung ist eine geeignete Strukturierungsoption für den Namen, vorausgesetzt, es bedarf keiner Fluchtsymbolnotation. Zur Vermittlung konstruktionsbedingter Aspekte ist im Hinblick auf kurze Namen die Verwendung normierter Affixe zweckmäßig (Lösungen D und G).

11. Transparenz der Dokumentation

319

11.2 Kommentierung Einerseits wissen wir (zumindest) seit der Diskussion über die strukturierte Programmierung („Go To Statement Considered Harmful"; Dijkstra, 1968), daß ein undurchschaubarer Quellcodetext durch eingefügte Kommentarzeilen kaum transparenter wird. Springen wir kreuz und quer (d.h. es liegt eine nichtlineare Kontrollstruktur vor), dann kann der Transparenzmangel nicht mit einer Kommentierung (quasi nebenläufig) behoben werden. Andererseits wissen wir, daß sehr komplexe Konstruktionen mit unstrukturierten Konstrukten relativ kurz notiert werden können. Zu Recht sind daher auch Strukturen zu berücksichtigen, „die wir heute als ,ziemlich unstrukturiert' empfinden und vor denen wir in der Ausbildung (noch) warnen" (Claus, 1987, S.50). Beispielsweise sind wir mit dem CALL/CC-Konstrukt (vgl. Abschnitt 8.2) in der Lage komplizierte nichtlineare Strukturen abzubilden. Zur Transparenz solcher nichtlinearen Strukturen können verbale Kommentarzeilen nur begrenzt beitragen. Letztlich helfen sie nur bei transparenten Programmen. Diese brauchen Kommentare jedoch nicht, da sie ja schon transparent sind; im Gegenteil, eine Kommentierung verlängert das Dokument, erhöht den Wartungsaufwand, weil die Kommentare (mit)gepflegt werden müssen und schadet daher. So gesehen müßten wir jede Kommentarzeile ablehnen. Vorsichtshalber wäre eine Streichung des Semikolons als Kommentarpräfix aus unserem LISPSystem vorzunehmen (vgl. Kaelbling, 1988). Im Gegensatz dazu setzen viele Dokumentations-Empfehlungen auf die intensive Kommentierung: „Großzügiger Gebrauch von Kommentaren ist guter Programmierstil" (Winston/Horn, 1984, deutsche Fassung S. 48) oder „..., I can't recommend them highly enough" (Hasemer, 1984, p. 39). Wir befürworten einen pragmatischen Standpunkt und empfehlen, Kommentarzeilen sparsam zu verwenden, und warnen vor einer „Überkommentierung" (vgl. auch Kessler, 1988, S.377). Ihre Aufgabe ist die WARUM-Erläuterung und nur in Fällen, wenn unserem Adressaten die Abarbeitungsfolge fremd sein wird, auch die WIE-Erläuterung. So werden Kommentare kein Ersatz für eine unzulängliche Benennung von Konstrukten. Umgekehrt muß die Benennung nicht mit Informationen zum WARUM belastet werden. Nicht zu übersehen sind die gravierenden Nachteile von Kommentarzeilen. Zunächst ist zu vereinbaren, ob sie das ihnen nachfolgende Programm(fragment) beschreiben oder das vorhergehende. Selbst bei strikter Einhaltung einer entsprechenden Vereinbarung (vgl. Tab 11.2-1) bleibt der Nachteil, daß die Reichweite eines Kommentars nicht unmittelbar erkennbar ist, sondern durch Interpretation des Textes zu folgern ist. Konstruktionsmäßig wird eine Kommentarzeile eher wie ein global definierter Wert behandelt. Die Kommentierung bleibt damit auf dem Erkenntnisniveau primitiver Programmiersprachen stehen, die keine Blockstrukturen, d.h. keine

III. Konstruktionsempfehlung

320

lokalen Werte, kennen. Wünschenswert wäre ein Mechanismus zur Kommentierung, der die Reichweite und die Verknüpfung mit dem jeweiligen Programmfragment gewährleistet (vgl. Belli/Bonin, 1989). Solange das eingesetzte LISPSystem einen solchen Mechanismus nicht bietet, sind wir auf eine Ersatzlösung angewiesen. Eine einfache Lösung zeigt Tab. 11.2-1. ;[

;] ;< ;> Tab

< k o m m e n t a r> < k o m m e n t a r> 11.2-1.

m a r k i e r t den Beginn der Reichweite

ist e i n K o m m e n t a r und m a r k i e r t d a s der R e i c h w e i t e von < k o m m e n t a r > erläutert erläutert

Kennzei

chnung

von Ende

das das

vorhergehende Konstrukt nachfolgende Konstrukt

der

Rei chwei te eines

Komentärs

Bei den Anwendern von MacLISP (vgl. Anhang B) hat sich insbesondere im Umfeld vom Massachusetts Institute of Technology Cambridge (MIT) eine Konvention mit Semikolon-Folgen durchgesetzt, die Eingang in die Common LISPBeschreibung gefunden hat (vgl. Steele u.a., 1984, S. 348). Ein Semikolon dient zur Kommentierung der Zeile, auf der es steht. Dabei sind mehrere Einfach-Semikolon-Kommentare spaltenmäßig auszurichten, d.h. sie beginnen stets in der gleichen Spalte. Ist der Kommentar länger als die verbleibende Restzeile, dann wird er auf der nächsten Zeile fortgesetzt, allerdings folgt diesem Semikolon ein Leerzeichen. Ein Doppeiter-Semikolon-Kommentar beginnt in der Spalte, in der das zu erläuternde Konstrukt anfängt. Nach dem doppelten Semikolon folgt ein Leerzeichen. Die Kommentierung bezieht sich in der Regel auf das nachstehende Konstrukt. Ein Dreifach-Semikolon-Kommentar beginnt stets in der ersten Spalte einer Zeile. Er beschreibt ein größeres Konstrukt. Ein Vierfach-Semikolon-Kommentar kennzeichnet Überschriften. Er beginnt ebenfalls in der ersten Spalte. Die Beispiele in diesem Buch sind gemäß dieser Konvention (vgl. Tab. 11.2-2) kommentiert. Kommentarzeilen sind gleichzeitig mit den LISP-Zeilen zu schreiben, die sie erläutern. Es ist sicherzustellen, daß Kommentare mitgepflegt werden. Ein nicht mehr gültiger Kommentar ist irreführend und daher schädlicher als ein fehlender Kommentar. Bei jeder Modifikation empfiehlt es sich, vorsichtshalber Kommentare in Bezug auf die Änderungsstelle vorab zu löschen. /Common LISP: Documentation string. Beim Definieren einer Funktion (mit dem DEFUN-Konstrukt) oder eines Makros (mit dem DEFMACRO-Konstrukt) kann im Deklarationsbereich ein Kommentar hinterlegt werden: (DEFUN {} ) Ist eine vom Typ String, dann dient sie zur Kommentierung des

11. Transparenz der Dokumentation

321

Konstruktes. Der Kommentar ist abrufbar mit der Applikation von DOCUMENTATION, z.B: eval>

(DOCUMENTATION

Semi kolonanzahl

'F00

'FUNCTION)

Begi nn i n Spai te

==>

"Kommentar-Text"

Verwendung

; ; ;;#\SPACE

1

Ü b e r s c h r i f t für K a p i t e l , und U n t e r a b s c h n i t t e

; ;;#\SPACE

1

K o m m e n t a r für e i n (z.B. Funktion)

; ;#\S PAC E

Legende: #\SPACE Tab.

::=

]

für d a s

gößeres

Abschnitte Konstrukt

des Konstruktes

Kommentar Konstrukt

(nachfolgende)

lokal vorgegeben

K o m m e n t a r für d i e s e Z e i l e . F a l l s P l a t z mangel, dann nächste Zeile mit Semikolon, g e f o l g t von einem L e e r z e i c h e n .

Leerzeichen

11.2-1.

Eine bewährte (vgl. Steele

Konvention u.a., 1984)

für

Kommentare

Das folgende ARRAY-Beispiel zeigt eine Situation, bei der eine Kommentierung notwendig ist, obwohl die Kommentarzeile das WIE beschreibt. Beispiel: ARRAY initialisieren Es ist eine zweidimensionale Tabelle (engl.: array) zu konstruieren. Dazu sind die beide folgenden Konstrukte MAKE-ARRAY und ARRA Y-SET! definiert. eval>

(DEFINE MAKE-ARRAY (LAMBDA (MAX_ZEILEN MAX_SPALTEN) (LET ((V ( M A K E - V E C T O R M A X _ Z E I L E N ) ) ) (DO ((I 0 (1+ I))) ((> I ( - 1 + M A X _ Z E I L E N ) ) V) (VECTOR-SET! V I (MAKE-VECTOR MAX_SPALTEN)))))) ==> MAKE-ARRAY

eval>

(DEFINE ARRAY-SET! (LAMBDA (ARRAY ZEILE SPALTE N E U E R . W E R T ) (LET ( ( N E U E - Z E I L E (VECTOR-SET! (VECTOR-REF ARRAY (-1+ ZEILE)) (-1+ SPALTE) NEUER_WERT))) (VECTOR-SET! ARRAY (-1+ ZEILE) NEUE-ZEILE)))) ==> ARRAY-SET!

322

III. Konstruktionsempfehlung

Mit dem Konstrukt MAKE-ARRAY definieren wir ein Tabellenbeispiel FOO mit 4 Zeilen und 5 Spalten. Das anschließenden LET-Konstrukte modifiziert den Wert von FOO. Wir beurteilen hier nicht, ob es sich um ein „trickreiches" Konstrukt handelt, das besser durch eine durchschaubare Lösung zu ersetzen wäre (dazu vgl. Kernighan/Plauger, 1978). Uns intressiert das Bestehen der Kommentierungs-Pflicht. eval> (DEFINE eval> FOO ==> #(#(() #(() #(() #(()

FOO (MAKE-ARRAY 4 5)) ==> FOO () () () ()

(:) (:) (:) (:)

() o o

o

(LET ((N 4) (M 5) (DO ((I 1 (1+ I ((> I N)) (DO ((J 1 (1+ J ) ) ) ((> J M)) (ARRAY-SET! FOO I J (* (QUOTIENT I J) (QUOTIENT J I ) ) ) ) ) ) ==> #T Der neue Wert von FOO ist für den angenommenen Leser nicht sofort nachvollziehbar. Dieser muß erkennen, daß das Argument (* (QUOTIENT I J) (QUOTIENT J I)) nur die beiden Werte 0 und 1 annehmen kann. Ist (EQ? I J) erfüllt, dann ist es der Wert 1, andernfalls ist es der Wert 0. Das QUOTIENT-Konstrukt hat als Rückgabewert die Integerzahl der Divisionsrechnung. Es ist daher adressatengerecht, auf diese Integerdivision hier mit einem Kommentar hinzuweisen. eval> (LET ((N 4) (M 5)) (DO ((I 1 (1+ I ) ) ) ((> I N)) (DO ((J 1 (1+ J ) ) ) ((> J M)) (ARRAY-SET! FOO I J ;; Integer-Di vision, Wert entweder 0 oder 1 (* (QUOTIENT I J) (QUOTIENT J I ) ) ) ) ) ) ==> #T eval> FOO ==> #(#(1 0 0 #(0 1 0 #(0 0 1 #(0 0 0

0 0 0 1

0) 0) 0) 0))

11.3 Vorwärts- und Rückwärtsverweise In den ersten Phasen des Konstruierens mag ein „lokal sequentielles" Lesen und Vergleichen mit anderen Passagen im selben Dokument oder in anderen dominieren. Spätestens in der Wartungs- und Pflegephase herrscht das Lesen als Suchprozeß vor. Über Verzeichnisse und Querverweise wird mehr oder weniger „dia-

11. Transparenz der Dokumentation

323

gonal" gelesen, um z.B. Fehler zu isolieren oder versteckte Abhängigkeiten aufzudecken. Daher ist es sinnvoll, von Anfang an das Suchen in einer Dokumentation zu unterstützen. Vorwärts- und Rückwärtsverweise sind deshalb Bestandteil einer „guten" Dokumentation. Tabelle 11.3-1 nennt die anzustrebenden Eigenschaften für eine Dokumentation (vgl. z.B. ANSI/IEEE Std. 830, 1984). Ei g e n s c h a f t e n : (1) e i n d e u t i g , (2) v o l l s t ä n d i g , (3) v e r i f i z i e r b a r , (4) konsistent, (5) m o d i f i z i e r b a r , (6) z u r ü c k f ü h r b a r (traceable) (7) h a n d h a b b a r

und

Tab. 11.3-1 Anzustrebende Eigenschaften für eine Dokumentati on

Die Eigenschaft „Eindeutigkeit" bedingt, daß wir mehrdeutige Begriffe vermeiden oder zumindest ihre angenommene Bedeutung in einem Begriffslexikon (Glossary) hinterlegen. Die Eigenschaft "Vollständigkeit" ist adressaten- und zweckausgerichtet zu erfüllen. Ist der Adressat der Rechner, dann ist „Vollständigkeit" (in der Praxis nachträglich) objektiv feststellbar. In allen anderen Fällen ist subjektiv zu entscheiden, ob etwas explizit zu beschreiben ist oder nicht (vgl. Abschnitt 11). Die Eigenschaften "Verifizierbarkeit" und „Konsistenz" (Widerspruchsfreiheit) sind, soweit es sich um verbale, nicht streng formaliserte Texte handelt, nicht exakt definierbar und kaum erreichbar. Sie bilden jedoch schon intuitiv einen Maßstab, der zur Präzision und zum Einbeziehen schon formulierter Aussagen zwingt. Die Eigenschaft „Modifizierbarkeit" können wir entsprechend dem folgenden Prädikat MODIFIZIERBAR? weiter aufschlüsseln. Modifizierbar ist eine Dokumentation, wenn die Änderung einfach, vollständig und konsistent durchführbar ist. eval>

(DEFINE M O D I F I Z I E R B A R ? (LAMBDA (ÄNDERUNG) (AND ( E I N F A C H - D U R C H F Ü H R B A R ? Ä N D E R U N G ) (VOLLSTÄNDIG-DURCHFÜHRBAR? ÄNDERUNG) (KONSISTENT-DURCHFÜHRBAR? ÄNDERUNG)))) ==> MODIFIZIERBAR?

Die einfache Durchführbarkeit der Änderung setzt eine dem Benutzer vertraute Gliederung der Dokumentation voraus. Für die Quellcodetexte ist z.B. die Reihenfolge der einzelnen Konstrukte festzulegen. Analysieren wir eine Konstrukte-Hierarchie (vgl. Bild 4.2.-1), dann folgen wir den Abstraktionsebenen; entweder von oben beginnend nach unten (,,top-down"-Ansatz) oder umgekehrt, von

324

III. Konstruktionsempfehlung

unten beginnend nach oben (,,bottom-up"-Ansatz). Einzuhalten ist dabei eine feste Reihenfolge innerhalb unseres Verbundes von Konstruktor, Selektor, Prädikat und Mutator. Zusätzlich sind Verweise auf abhängige und redundante Text(teil)e erforderlich, damit die Änderung vollständig und konsistent durchführbar ist. Für die gesamten Dokumentation wird keine Redundanzfreiheit angestrebt. Sie widerspräche der Adressaten- und Zweck-Ausrichtung der Dokumente. Das schließt nicht aus, daß einzelne Dokumente (z.B. die Quick-Referenzkarte) möglichst redundanzfrei sind. eval> (DEFINE EINFACH-DURCHFÜHRBAR? (LAMBDA (ÄNDERUNG) (AND (VERTRAUTE-DOKUMENTATIONS-GLIERDERUNG? *BENUTZER*) (VERSTEHBAR? ÄNDERUNG) (EXPLIZITES-VERWEISSYSTEM? *D0KUMENTATI0N*)))) ==> EINFACH-DURCHFÜHRBAR? Die Eigenschaft „Zurückführbarkeit" bezieht sich auf die Konstruktions-Pprozeßdokumentation. Wir wollen zu einer Aussage in einem Dokument die zugehörigen Aussagen in der Kette der vorhergehenden Dokumente auffinden. Die „Zurückführbarkeit" verlangt, daß wir z.B. von einem Konstrukt im Quellcodetext aus die betreffende Anforderung im Pflichtenheft identifizieren können. Die einzelnen Dokumente dürfen kein Konglomerat, d.h. kein bunt zusammengewürfeltes Papierwerk, bilden. Erst eine gegenseitige Abstimmung („Arbeitsteilung") der einzelnen Dokumente macht eine Dokumentation handhabbar. Die Eigenschaft „Handhabbarkeit" betrifft den Umfang jedes einzelnen Dokumentes. Ein adressaten- und zweckgerechter Umfang ist nur erreichbar, wenn wir problemlos auf Aussagen in anderer Dokumente verweisen können. Die Vor- und Rückwärtsverkettung verbessert die „Modifizierbarkeit", „Zurückführbarkeit" und „Handhabbarkeit" der Dokumentation. Voraussetzung ist dazu, daß jedes Dokument und jede Aussage in jedem Dokument mit einem eindeutigen Bezeichner (Identifier) versehen ist. Wir notieren daher keine Überschrift für ein Kapitel, einen Abschnitt oder Unterabschnitt, keine Unterschrift für eine Abbilung, Zeichnung oder Tabelle und keine wesentliche Aussage im Text ohne (alpha-)numerische Kennziffer. In welcher Form die Kennziffern als Basis dieser Vor- und Rückwärtsverkettung zu bilden sind, ist in den jeweiligen Dokumentationsrichtlinien festzuschreiben. In diesem Buch benutzen wir Zahlen mit einem vorangestelltem Buchstaben. Der Buchstabe steht für folgende Abkürzungen: = Anforderung = Enwurf = Implementation = Test Außerdem haben die Dokumentationsrichtlinien vorzuschreiben, welche Kenndaten ein selbstständiges Dokument aufzuweisen hat („Kopfdaten"- und „Fußdaten"-Vorschrift). Zumindest erforderlich sind die Angaben:

11. Transparenz der Dokumentation o o o o

325

Dokumentnummer (Identifier), Kurzbezeichnung (Titel) kurze Zweckangabe (Zusammenfassung) und Erstellungs- und Modifikationsdaten.

Die folgende Gegenüberstellung einer Beschreibung weniger Anforderungen zeigt Möglichkeiten einer Identifizierung. Beispiel: Plausibilitätspriifung Fall 1: Verbaler Text (So nicht!) Das Programm soll drei Datenelemente auf Plausibilität überprüfen. Ist das erste Datenelement falsch, wird eine Fehlernachricht ausgegeben. Ist das zweite Datenelement nicht richtig wird ebenfalls eine Fehlermeldung ausgegeben. Ist das dritte Datenelement falsch, soll das Programm den Wert „Unbekannt!" annehmen. Fall 2: Verbaler Text mit Bezeichnern A01 Das Programm PLAUSIBEL? überprüft die drei Datenelemente: ELEMENT-1, ELEMENT-2 und ELEMENT-3. A01.1 Ist ELEMENT-1 falsch, gibt PLAUSIBEL? die Fehlernachricht F01 aus. A01.2 Ist ELEMENT-2 falsch, gibt PLAUSIBEL? die Fehlernachricht F02 aus. A01.3 Ist ELEMENT-3 falsch, nimmt PLAUSIBLE? den Wert W01 = "Unbekannt!" an. Fall 3: Formalisierter Text mit Bezeichnern

ET-PLAUSIBEL?

R1

R2

R3

B1

ELEMENT-1

falsch?

J

-

-

B2

ELEMENT-2

falsch?

-

J

-

B3

ELEMENT-3

falsch?

-

-

J

AI

Fehlernachricht

F01

A2

Fehlernachricht

F02

A3

PLAUSIBEL? nimmt Wert W01 = " U n b e k a n n t " an

X X X

Legende (vgl. A b s c h n i t t 2 . 2 . 2 ) : M e h r t r e f f e r - E T ( A b a r b e i t u n g s f o l g e R1, R 2 , R3) J ::= J a , B e d i n g u n g t r i f f t zu - ::= I r r e l e v a n t , A n w o r t h a t k e i n e n E i n f l u ß a u f d i e Wahl d e r Regel X ::= A k t i o n ist zu v o l l z i e h e n Bild

11.3-1.

Beispiel:

ET-PLAUSIBEL?

326

III. Konstruktionsempfehlung

In den Fällen 2 und 3 ist jede einzelne Anforderung direkt angebbar. Jedes nachfolgende Dokument, z.B. der Quellcodetext, kann sich auf diese Identifizerung stützen. Bei einer Modifikation sind die Änderungsbereiche problemlos „adressierbar", z.B.: "A01.3 Wert W01 = .UNKLAR" (Fall 2) bzw. „ET-PLAUSIBLE? Aktion A3, Wert W01 = 'UNKLAR" (Fall 3).

11.4 Zusammenfassung: Namen, Kommentare und Verweise Die Konstruktions- und Konstruktions-Prozeßdokumente sind wesentliche Bestandteile der Software. Jede Aussage in jedem Dokument hat sich nach den Adressaten und dem Zweck zu richten. Das Baukasten-Konstruktionsprinzip bedingt, daß Formulierungen mehrfach verwendbar sind. Daher sind z.B. Anforderungen im Präsens zu formulieren. Der Name eines Konstruktes (z.B. einer Funktion, eines Makros oder einer Variablen) ist abhängig vom gewählten Paradigma. Einerseits verweist er auf das repräsentierte „reale" Objekt und andererseits transportiert er konstruktions-spezifische Informationen. Letztere lassen sich gut mit einer AFFIX-Konvention verschlüsseln. Bei der Benennung einer Funktion ist stets die Informationsaufteilung mit anderen Namen (LAMBDA-Variablen) und dem Eintrag im (Daten-)Lexikon zu bedenken. Groß/Kleinschreibung ist für einen Namen eine hilfreiche Strukturierungsoption, vorausgesetzt, es bedarf keiner Fluchtsymbol-Notierung. Kommentarzeilen im Quellcodetext dienen primär zur WARUM-Erläuterung. Mit einer verbindlichen Regelung ist festzulegen, worauf sie sich beziehen und welchen Textbereich ihre Erklärung umfaßt. Vor- und Rückwärtsverweise verbessern die Dokumentations-Eigenschaften „Modifizierbarkeit", „Zurückführbarkeit" und „Handhabbarkeit". Dazu ist jedes Dokument und jede Aussage in einem Dokument mit eindeutigen Bezeichnern zu versehen. Charakteristisches

Beispiel für Abschnitt

11:

;;;; D o k u m e n t 1 1 . 4 - 1 ;;;; T i t e l : E i n f a c h e r R e g e l i n t e r p r e t e r D I A G N O S E ;;;; E r s t e l l t am: 0 1 . 1 1 . 9 0 ¡ l e t z t e Ä n d e r u n g : 4 . 1 1 . 9 0 ;;; AI ; ;; ;;; A I . 1 ;;; A I . 2

D I A G N O S E a n a l y s i e r t A u s s a g e n , d i e aus B e d i n g u n g e n Aktionen bestehen. A u s s a g e n sind aus Regeln a b g e l e i t e t oder w e r d e n beim Benutzer nachgefragt.

;;; A2 ;;; A 2 . 1 ;;; A 2 . 2

Ei ne Regel h a t eine oder mehrere eine Aktion.

Bedingungen

und

und

11. Transparenz der Dokumentation

327

A3

E i n e A u s s a g e ist e i n e L i s t e , s e i n e r E i g e n s c h a f t und d e r e n

A4

D I A G N O S E e r m i t t e l t für ein v o r g e g e b e n e s v o r g e g e b e n e E i g e n s c h a f t den z u g e h ö r i g e n

A5

begründet diesen, durch Auflistung von z u t r e f f e n d e n Regeln.

El El.1

Abgebildte

El.2 El.3



El.4

El.5 El.6 El.7 T1 Tl.l

der

aus d e m

Objekt,

O b j e k t und W e r t und

eine

Bedingungen

Daten(strukturen): ::= ; vgl. A3 ( ) ::= < b e d i n g u n g > | < a k t i o n > ;vgl. AI ::= ( ( < b e d i n g u n g - 1 > ;vgl. A2 ... < b e d i n g u n g - n > ) < a k t i o n > ) ::= ( < r e g e l - l > ... < r e g e l - n > )

Regeln sind einer Eigenschaft zugeordnet: (PUTPROP 'REGELN) Der W e r t kommt vom B e n u t z e r , w e n n : ;vgl. A I . 2 ( P U T P R O P # T ' N A C H F R A G E ) Die S t a r t a u s s a g e und die von D I A G N O S E e r m i t t e l t e n Begründungen sind Listenelemente der Variablen ^ A U S S A G E * Bei spiel : Daten: (DEFINE *AUSSAGEN* '((BENZINPUMPE ARBEITET KORREKT))) (PUTPROP 'ARBEITET '((((BATTERIE STROM AUSSREICHEND) (KABEL KONTAKTE LEITEND)) (MOTOR ARBEITET GUT)) (((BENZINVERSORGUNG ARBEITET NICHT)) (MOTOR ARBEITET NICHT)) (((LICHTMASCHINE ARBEITET NICHT)) (MOTOR ARBEITET NICHT)) (((TANKFUELLUNG STAND AUSREICHEND) (BENZINPUMPE ARBEITET KORREKT) (BENZINFILTER DURCHLAESSIGKEIT KEINE)) (BENZINVERSORGUNG ARBEITET NICHT))) 'REGELN) (PUTPROP (PUTPROP

Tl.2

bestehend Wert.

'STAND #T 'NACHFRAGEN) 'DURCHLAESSIGKEIT #T 'NACHFRAGEN)

Applikation (DIAGNOSE 'MOTOR 'ARBEITET) ==> Nenne S T A N D von T A N K F U E L L U N G ? ausreichend ¡Benutzereingabe Nenne D U R C H L A E S S I G K E I T von B E N Z I N F I L T E R ? keine ¡Benutzereingabe ((MOTOR ARBEITET NICHT) (BENZINVERSORGUNG ARBEITET NICHT) (BENZINFILTER DURCHLAESSIGKEIT KEINE) (TANKFUELLUNG STAND AUSREICHEND) (BENZINPUMPE ARBEITET KORREKT))

III. Konstruktionsempfehlung

328

( D E F I N E DIAGNOSE (LAMBDA (OBJEKT (LETREC ( Primitive

EIGENSCHAFT) Konstruktoren

(MAKE-AUSSAGE (GET-OBJEKT

(LAMBDA (LIST

(LAMBDA

(GET-EIGENSCHAFT (GET-WERT

(LAMBDA

(GET-BEDINGUNGEN

und

Selektoren

El

( O B J E K T E I G E N S C H A F T WERT) OBJEKT EIGENSCHAFT W E R T ) ) )

(AUSSAGE)

(LAMBDA

(LAMBDA

(CAR

(AUSSAGE)

(AUSSAGE)

(GET-ERSTE-BEDINGUNG

;vgl.

AUSSAGE))) (LIST-REF

(LIST-REF

(REGEL)

(CAR

AUSSAGE

AUSSAGE

1)))

2)))

REGEL)))

(LAMBDA (BEDINGUNGEN) (CAR B E D I N G U N G E N ) ) )

(GET-REST-BEDINGUNGEN

(LAMBDA (BEDINGUNGEN) (CDR B E D I N G U N G E N ) ) )

(GET-AKTION

(LAMBDA

(REGEL)

(LIST-REF

(GET-REGELN

(LAMBDA ( E I G E N S C H A F T ) (GETPROP EIGENSCHAFT

REGEL

1))) ;vgl .

El.5

'REGELN)))

(GET-ERSTE-REGEL

(LAMBDA

(REGELN)

(CAR

REGELN)))

(GET-REST-REGELN

(LAMBDA

(REGELN)

(CDR

REGELN)))

; ; R e g e l i s t r e l e v a n t , wenn i h r e A k t i o n g l e i c h e s O b j e k t ; ; h a t w i e d i e zu p r ü f e n d e A u s s a g e ( R E L E V A N T E - R E G E L N (LAMBDA (REGELN OBJEKT E I G E N S C H A F T ) (COND ( ( N U L L ? R E G E L N ) N I L ) C C EQ? OBJEKT (GET-OBJEKT (GET-AKTION (GET-ERSTE-REGEL REGELN)))) (CONS ( G E T - E R S T E - R E G E L R E G E L N ) (RELEVANTE-REGELN (GET-REST-REGELN REGELN) OBJEKT E I G E N S C H A F T ) ) ) (T ( R E L E V A N T E - R E G E L N ( G E T - R E S T - R E G E L N R E G E L N ) OBJEKT E I G E N S C H A F T ) ) ) ) ) Konstrukte

zum F o r t s c h r e i b e n

von

*AUSSAGE*

;vgl .

( E R G A E N Z U N G - * A U S S A G E N * ! (LAMBDA (NEUE.AUSSAGE ) ( S E T ! ^ A U S S A G E N * (CONS NEUE_AUSSAGE ^ A U S S A G E N * ) ) ) ) (MODI F I KATION - * A U S S A G E N * ! (LAMBDA ( A L T E _ A U S S A G E NEUE_AUSSAGE) (SET-CAR! ALTE_AUSSAGE NEUE_AUSSAGE)))

El.7

329

11. Transparenz der Dokumentation ;; E f f i z i e n t e s Suchen d u r c h z w e i s t u f i g e s Verfahren ( G E T - W E R T - I N - * A U S S A G E N * (LAMBDA (OBJEKT E I G E N S C H A F T ) (DO ( ( F A K T ( A S S O C O B J E K T * A U S S A G E N * ) (ASSOC OBJEKT (CDR F A K T ) ) ) ) ((OR (NULL? FAKT) (EQ? (GET-EIGENSCHAFT FAKT) E I G E N S C H A F T ) ) ( I F ( N U L L ? FAKT) N I L (GET-WERT F A K T ) ) ) ) ) )

(AUSSAGE - 1 N - * A U S S A G E N * ! (LAMBDA ( A K T I O N ) (LET ((BISHERIGER-WERT (GET-WERT-IN-*AUSSAGEN* (GET-OBJEKT AKTION) (GET-EIGENSCHAFT A K T I O N ) ) ) ) (COND ( ( N U L L ? B I S H E R I G E R - W E R T ) (ERGAENZUNG-*AUSSAGEN*! AKTION)) (T ( M O D I F I K A T I O N - * A U S S A G E * ! BISHERIGER-WERT AKTION)))))) Wert beim B e n u t z e r n a c h f r a g e n ;vgl. El.6 (Benutzerschnittstelle) ;; V o r a u s s e t z u n g f ü r e i n e B e n u t z e r n a c h f r a g e ( N I C H T - A B L E I T E N ? (LAMBDA ( E I G E N S C H A F T ) (GETPROP EIGENSCHAFT 'NACHFRAGEN))) (BENUTZER-RUECKFRAGE! (LAMBDA (OBJEKT E I G E N S C H A F T ) (WRITELN "Nenne " EIGENSCHAFT " von " OBJEKT " ? " ) (ERGAENZUNG-*AUSSAGEN*! (MAKE-AUSSAGE OBJEKT EIGENSCHAFT ( R E A D ) ) ) ) ) Regelauswahl,

Bedingungen

testen,

neues

Ziel

bilden

( T E S T (LAMBDA (B_N) ;B_N : : = B e d i n g u n g e n (Plural) (COND ( ( N U L L ? B _ N ) T ) ((MEMBER ( G E T - E R S T E - B E D I N G U N G B_N) * A U S S A G E N * ) (TEST (GET-REST-BEDINGUNGEN B _ N ) ) ) ((ZIELBILDUNG ( G E T - O B J E K T ( G E T - E R S T E - B E D I N G U N G B_N ) ) ( G E T - E I G E N S C H A F T ( G E T - E R S T E - B E D I N G U N G B_ N ) ) ) ;: Z I E L B I L D U N G kann *AUSSAGEN* m o d i f i z i e r e n , daher ;; e r n e u t e s Nachschauen i n *AUSSAGEN* (COND ( ( M E M B E R ( G E T - E R S T E - B E D I N G U N G B _ N ) *AUSSAGEN*) ( T E S T ( G E T - R E S T - B E D I N G U N G E N B_ N ) ) ) (T N I L ) ) ) (T N I L ) ) ) ) ( P R U E F E - R E G E L N (LAMBDA (REGELN) (COND ( ( N U L L ? R E G E L N ) N I L ) ( ( T E S T (GET-BEDINGUNGEN ( G E T - E R S T E - REGEL R E G E L N ) ) ) (AUSSAGE - 1 N - ^ A U S S A G E N * ! (GET-AKTION (GET-ERSTE-REGEL REGELN)))) (T ( P R U E F E - R E G E L N ( G E T - R E S T - R E G E L N R E G E L N ) ) ) ) ) )

330

III. Konstruktionsempfehlung (ZIELBILDUNG (LAMBDA (AKT.OBJEKT A K T _ E I G E N S C H A F T ) (COND ( ( G E T - W E R T - I N - * A U S S A G E N * AKT_OBJEKT AKT_EIGENSCHAFT)) ( ( N I C H T - A B L E I T E N ? AKT_EI G E N S C H A F T ) (BENUTZER-RUECKFRAGE! AKT_OBJEKT AKT.EIGENSCHAFT)) ((PRUEFE-REGELN (RELEVANTE-REGELN (GET-REGELN A K T _ E I G E N S C H A F T ) AKT_OBJEKT AKT_EI G E N S C H A F T ) ) ) (T NIL)))))

;; Starten der R e g e l a b a r b e i t u n g (PP (ZIELBILDUNG OBJEKT E I G E N S C H A F T ) ) ) ) ) Programm 11.4 Einfacher Regelinterpreter ( z i e l o r i e n t i e r t e Prüfung)

DIAGNOSE

12. Spezifikation mit LISP Spezifizieren heißt eine (zunächst noch unbekannte) Aufgabenstellung durch sprachliche Festlegung ihres Ergebnisses, bzw. ein (zunächst noch unbekanntes) Objekt durch sprachliche Festlegung seines Gebrauchs zu präzisieren (vgl. z.B. Hesse u.a., 1984). Publikationen zur Thematik „Software-Spezifikation" gehen von unterschiedlichen Begriffsdefinitionen aus. Zumeist basieren sie auf der Abgrenzung einzelner Phasen des Lebenszyklus (vgl. Bild 2-1) und der Beschreibung ihrer Dokumente. Zielvorstellung ist dabei die Spezifikation mit der Präzision der Mathematik und der Verständlichkeit der Umgangssprache. Spezifizieren im Sinne eines Präzisierens umfaßt alle Phasen. In den ersten Phasen bezieht sich die Spezifikation auf die Analyse und Synthese möglicher Konzeptionen. Ausgehend von einer Problemanalyse, werden mit der Aufnahme der Ziele und Konflikte sowie der Ist-Situation des bisherigen System(umfelde)s der Bedarf und die Schwachstellen präzisiert. Alternative Lösungansätze sind dann anhand der präzisierten Ziele und Konflikte zu bewerten (vgl. Bild 12.1). Anschließend folgt das Spezifizieren im engeren Sinne, d.h. das Entwerfen und Formulieren von Quellcodetexten. Konzentriert man sich auf die Phase, in der anwendungsspezifische Datentypen zu präzisieren sind, dann besteht die Spezifikation aus Sorten, Operationen und Gleichungen. Diese Spezifikation notiert die Datentypen im Sinne von Algebren (Näheres zur algebraischen Spezifikation vgl. z.B. Kreowski, 1981). Wir gehen von einer gewählten Lösungsalternative aus (Bild 12-1, nach Phase P 6 ) und spezifizieren schrittweise die Aufgabenstellung so weit, bis diese

12. Spezifikation mit LISP

331

Dokumentati on [Anzahl Sei t e n ]

De

Bewertung/Auswahl

+

L ö s u n g s a l t e r n a t i ven

+ Bedarf

H

IST-Aufnahme

+ J

Ziele &

h

1

&

Schwachstellen

des

System(umfelde)s

Konflikte

Problemanalyse

1

P

P

2

3

P

P

4

P

5

6

Z e i t " > [Mannjahre]

r M

Legende: D-j Bild

::= D o k u m e n t 12-1.

als

Spezifizieren

Ergebnis

der

in den

P h a s e P-j

ersten

Phasen

(ohne Mißverständnisse) direkt konstruierbar (definierbar) ist. Diese Spezifikation präzisiert: Was leistet die Konstruktion im Einzelnen? Die Hauptaufgabe ist somit das Erarbeiten detaillierter Anforderungen (vgl. Tab. 12-1.). Die Anforderungen können sich auf numerische Berechnungen (z.B. Lösungen von Differentialgleichungen), geometrische Berechnungen (z.B. 3-dimensionale Modelle), Datenaggregationen (z.B. Besoldungsbescheide), Transaktionsprozesse (z.B. Platzreservierungssysteme), Wissensakquisition (z.B. Diagnosesysteme), Kommunikationsprozesse (z.B. Elektronische Post) und vieles mehr beziehen. Diese Vielfalt der Konstruktionsaufgaben macht unterschiedliche Arbeitstechniken notwendig. Arbeitstechniken umfassen einerseits Prinzipien (Handlungsgrundsätze) und Methoden (erfolgversprechende, begründbare Vorgehensweisen) und andererseits Instrumente („Werkzeuge"). Erste sind nicht, zweite sind (teilweise) selbst Software. Empfehlungen zur Spezifikation haben zumindest die Aufgabenart und die Aufgabengröße zu berücksichtigen. Es ist z.B. nicht unerheblich, ob ein administratives System oder ein System zur Steuerung eines technischen Prozesses zu spezifizieren ist. Im ersten Fall ist das Nutzen/Kostenverhältnis einzelner Systemleistungen disponibel bzw. unklar. Wir haben es mit Definitionsproblemen der Automationsaufgabe zu tun. Im zweiten Fall mag die geforderte Reaktionsgeschwindigkeit das eigentliche Konstruktionsproblem sein. Das Ziel und die Arbeitstechnik seien klar; das Problem liegt in der Durchführung (Vollzugsproblem). Ausge-

332

III. Konstruktionsempfehlung

AnforderungsKategori e

Kernfrage

Beispiel formuli erungen (vgl. P r o g r a m m D I A G N O S E Abschnitt 11.4)

1

funkti onale Anforderungen

W a s soll d a s System tun?

A u s s a g e n s i n d aus R e g e l n abgeleitet oder werden beim Benutzer nachgefragt.

2

Anforderungen an d a s f e r t i g e Produkt

W a s ist System?

Das D i a l o g s y s t e m D I A G N O S E ist e i n P r o d u k t für d e n E i n s a t z bei m e h r als 100 K f z - B e t r i e b e n .

3

Anforderungen zur Systemumgebung

Was sind die Einsatzbedingungen?

D I A G N O S E s e t z t d a s Betriebssystem MS-DOS Version 3.03 voraus.

4

Anforderungen an d i e Z i e l struktur

W a s ist d e r Bewertungs hi n t e r g r u n d ?

D I A G N O S E verkürzt die Fehlersuchzeit zumindest bei a n g e l e r n t e n K r ä f t e n .

5

Anforderungen zur Projektdurchführung

Was sind die R e s s o u r c e n für das Projektmanagement?

D I A G N O S E V e r s i o n 1.0 i s t i n n e r h a l b von 3 M o n a t e n mit 2 Mann zu e n t w i c k e l n .

Tab.

12-1.

Kategorien

von

das

Anforderungen

hend von unserem (Vor)-Wissen über die erfolgversprechende Arbeitstechnik und der Klarheit der Zielkriterien, sind verschiedene Problemfelder zu unterscheiden (vgl. Tab. 12-2). Unsere Konstruktionsaufgabe sei ein Vollzugsproblem (Feld 1.1 in Tab 12-2). Die erfolgversprechende Arbeitstechniken zur Spezifikation beziehen sich damit auf: o eine Schrittweise Verfeinerung (vertikale Ebene) und o eine modulare Strukturierung (horizontale Ebene) von Anforderungen. Für beide Fälle bedürfen wir einer Rechnerunterstützung. Die Konstruktionsgröße bestimmt welche (rechnergestützten) Arbeitstechniken anzuwenden sind. Bei einer kleinen Konstruktionsaufgabe ist die Spezifikation der einzelnen Verarbeitungsprozesse und der Datenrepräsentation' zu meistern. Bei einer sehr großen Aufgabe sind zusätzlich die Fortschritte der System-Software und -Hardware während der benötigten Planungs- und Realisierungszeit einzukalkulieren. Außerdem ändern sich Anforderungen in dieser relativ langen Zeit. Zu spezifizieren ist daher eine Weiterentwicklung, d.h. ein

12. Spezifikation mit LISP

333

Zu P r o j e k t b e g i n n die A r b e i t s T e c h n i ken 1

2

Tab.

erfolgversprechende Prinzipien, Methoden und Instrumente zur Problem1ösung

12-2.

Problemarten

Klarheit

gering II

Vol1zugs probleme

Defi ni t i o n s Probleme der Automati onsaufgäbe

unklar

Zielerrei c h u n g s probleme

Steuerungsprobleme eines konti nui erli c h e n Herantastens

beim

1

Kl ei ne K o n s t r u k t i on

2

Mi t t l e r e K o n s t r u k t i on

3

Große < K o n s t r u k t i on

100.000

4

Sehr große mehrmals K o n s t r u k t i on 100.000 (noch größer "zerfal1en" in e i g e n ständige Tei 1 e




(DEFINE REALISIERBAR? (LAMBDA (ANFORDERUNG DULDBARE_ABWEICHUNG) ( R E A L I S I E R B A R ?

Entsprechend diesem Prädikat kann die D U L D B A R E , ABWEICHUNG oder die ANFORDERUNG selbst modifiziert werden, um Realisierbarkeit zu erreichen. Die Aussage A2 („Benutzerfreundlichkeit") zeigt, daß auch die Modifikation einer Anforderung in gewissen Interpretationsgrenzen in Betracht kommen kann. Statt einen Teil von A2 mit A2.i (überlappende Bildschirmfenster) zu approximieren, ist ein Teil von A2 als „Kommandos über Funktionstasten" (A2.j) interpretierbar. In der Regel ist jedoch die Toleranzschwelle das Mittel, um eine Realisierbarkeit noch zu erreichen. Für eine Vorgabe können wir daher folgendes Prädikat definieren: e v a l > ( D E F I N E VORGABE? (LAMBDA (ANFORDERUNG DULDBARE,ABWEICHUNG) (LETREC ((ANFORDERUNG? (LAMBDA (AUSSAGE) (AND ( S P E Z I F I Z I E RT- SYSTEM? AUSSAGE) (OR (SPEZI FI Z I E R T - Z U - E R F Ü L L E N D E - L E I S T U N G ? AUSSAGE) (SPEZI FIZIERT-QUANTITATIVE-EIGENSCHAFT? AUSSAGE) (SPEZI FI ZIERT-QUALITATIVE-EIGENSCHAFT? AUSSAGE))))) (REALISIERBAR? (LAMBDA (ANFORDERUNG DULDBARE_ABWEICHUNG) (COND ( ( < = (BESTIMMUNG-SOLL-IST-ABWEICHUNG (FESTSTELLUNG-IST-VERHALTEN-BEZOGEN-AUF-SOLL (PLANVOLLZUG (PLANUNG ANFORDERUNG DULDBARE,ABWEICHUNG)))) DULDBARE,ABWEICHUNG) #T) ((MODIFIZIERBAR? ANFORDERUNG) (REALISIERBAR? (MODIFIKATION ANFORDERUNG) DULDBARE,ABWEICHUNG))

12. Spezifikation mit LISP

(AND

337

( ( M O D I F I Z I E R B A R ? DULDBARE_ABWEICHUNG) (REALISIERBAR? ANFORDERUNG (MODIFIKATION DULDBARE.ABWEICHUNG))) (T N I L ) ) ) ) ) (ANFORDERUNG? ANFORDERUNG) ( R E A L I S I E R B A R ? ANFORDERUNG DULDBARE_ABWEICHUNG))))) ==> V O R G A B E ?

Die einzelne Anforderung mag das Prädikat V O R G A B E ? erfüllen; im Zusammenhang mit anderen jedoch nicht. Naturgemäß gibt es konkurrierende und sich widersprechende Vorgaben. Vorrang- und Kompromißentscheidungen sind daher im Rahmen der Spezifikation zu treffen. Eine pragmatische Vorgehensweise beachtet bei den einzelnen Spezifikationsschritten vorrangig kritische Vorgaben und gewährleistet die anderen quasi nachträglich durch gezielte Modifikationen. Die kritische Vorgaben intuitiv zu erkennen, ist die „Kunst" des erfahrenen Konstrukteurs. Ziel der Spezifikation ist es, die Vorgaben so auszuarbeiten, daß sie durch passende Verknüpfungen möglicher Konstrukte abbildbar werden. Dazu bedarf es ihrer Strukturierung in Teilbereiche, die dann weitgehend unabhängig von einander mehr und mehr präzisiert werden. Die Konstruktion wird als „Geflecht" von Konstrukten („Moduln"), die über Schnittstellen miteinander verknüpft sind, spezifiziert. Wir verwenden hier den üblichen Begriff „Modul" im Sinne eines Synonyms für Konstrukt bzw. Teilkonstruktion. Die "Dopppelgesichtigkeit" jeder Schnittstelle, die auch der englische Begriff „interface" betont, bezieht sich auf die Menge aller Annahmen, die jeweils der eine Modul vom anderen unterstellt und umgekehrt. Innerhalb der Schnittstelle werden daher die relevanten Eigenschaften für ihre Kommunikation präzisiert.

338

III. Konstruktionsempfehlung

12.2 Import-Export-Beschreibung Die Wechselwirkungen zwischen den einzelnen Moduln sind mit Hilfe einer „Benutzt"-Relation und einer „Enthält"-Relation beschreibbar. Die „Enthält"Relation verweist auf die Möglichkeit, daß ein Modul selbst wieder in Module zerlegbar sein kann. Die „Benutzt"-Relation verweist auf die Modul-Schnittstelle. Die Modul-Schnittstelle ist gliederbar in einen Import- und einen Export-Teil. Die Import-Schnittstelle beschreibt welche Konstrukte der Modul aus anderen Moduln benutzen kann. Die Export-Schnittstelle nennt die Konstrukte, die der Modul für andere Moduln bereitstellt. Wir sprechen daher von einem Import, wenn ein Modul M eine Leistung eines Moduls M £ verwendet. Der Modul M( importiert (benutzt) ein Konstrukt, das M g exportiert. Bei der Diskussion des Verbundes von Konstruktor, Selektor, Prädikat und Mutator haben wir eine Hierarchie unterstellt (vgl. Bild 4.2-1). Sie ist im Sinne der „Benutzt"-Relation zyklenfrei, d.h. aus „M( benutzt M E " folgt, daß M ß nicht Mj benutzt und daß kein in der Hierarchie unter ME befindlicher Modul den Modul Mj benutzt. Außerdem gibt es einen hervorgehobenen Modul (Hauptmodul) mit einer besonderem Konstrukt, das als erstes appliziert wird. Der gesamte übrige Berechnungsvorgang (dynamische Ablauf) erfolgt über „Benutzt"-Relationen. In der Praxis geschieht das Spezifizieren der Moduln zunächst "skelettartig" mit lose verknüpften, verbalen Beschreibungen und Absichtserklärungen. Darauf folgt eine Phase der Konsolidierung, in der Schnittstellen und Implementationansätze verbindlich vereinbart werden. Anschließend sind diese Beschreibungsrahmen („Skelette") auszufüllen. Das Ausfüllen kann mehr oder weniger lokal sequentiell erfolgen. Erforderlich ist allerdings die Bezugnahme auf andere bereits teilweise erstellte „Skelette". Empfohlen wird dazu folgender Beschreibungsrahmen, der die Aufgabe einer Checkliste hat (BFN-Notation vgl. Abschnitt 2.2): (

II (EFFEKTE < t e x t > ) {))

mit

: : = Mnemotechnisch p r ä g n a n n t e s Symbol, das s i c h von a l l e n a n d e r e n u n t e r s c h e i d e t < s c h n i t t s t e l 1 e > : : = S c h n i t t s t e l l e zu M o d u l n a u f h ö h e r e r und tieferer Hierarchie-Ebene < t e x t > : : = F r e i e r T e x t z u r K u r z b e s c h r e i b u n g des Moduls ::= Verbale Beschreibung einzelner Modul"Funktionen

12. Spezifikation mit LISP

339

Mit der Import-/Export-Unterscheidung bei der Schnittstelle entsteht daraus folgendes „Skelett". Dabei verdeutlichen die fettgedruckten Begriffe die Angaben, auf die man sich im jeweiligen Spezifikationsschritt konzentriert. ( ((EXPORT ( K e x p o r t - f u n k t i o n X ) ) (IMPORT ({ 1))) (EFFEKTE ( < t e x t - z u r - a l 1 gerneinen-beschreibung>) ({ 1)) Ausgangspunkt ist ein eindeutiger, kennzeichnender Modulname (vgl. Abschnitt 11.1). Mit der Eintragung unter EFFEKTE beschreiben wir alle zu erfüllenden Leistungen und Eigenschaften des gesamten Moduls in Form eines kurzen Textes. Die EXPORT- und IMPORT-Angaben definieren die Modul-Hierarchie. In der Praxis können wir selten diese Hierarchie vom Hauptmodul ausgehende konsistent aufbauen. Neben den „top down"-Schritten entsteht unser Skelett „bottom up", „middle out", „inside out", "outside in" und/oder „hardest first". Die EXPORT- und IMPORT-Schnittstellen beschreiben wir daher eher Zug um Zug mit laufenden Korrekturen. Während im Abschnitt EFFEKTE der Modul insgesamt beschrieben ist, sind die einzelen zu erfüllenden Leistungen, hier als bezeichnet, zunächst durch einen kennzeichnenden Namen anzugeben. Dieses erste Skelett ermöglicht eine Modul-Hierarchie als Systemarchitektur zu entwerfen. Im allgemeinen ist jedoch festzustellen, daß einzelne Leistungen von mehreren Moduln auf unterschiedlichen Hierarchieebenen benötigt werden. Ein Beipiel hierfür ist die Behandlung von Fehlermeldungen. Um das Schichtenprinzip (Importe nur aus der nächst tieferen Hierarchiestufe!) nicht generell zu durchbrechen, betrachten wir solche überall gebrauchten Moduln gesondert, also außerhalb der Hierarchie. Diese sogenannten „Dienstleister" (quasi globale Moduln) können in jeden Modul „eingebettet" werden. Wir geben sie im Abschnitt NUTZT an. ( ((EXPORT ( ( < e x p o r t - f u n k t i o n > ) ) ) (IMPORT ({ 1))) (EFFEKTE ( < t e x t - z u r - a l 1 gerneinen-beschreibung>) (NUTZT ( ( < d i e n s t l e i s t e r - m o d u l > ) ) ({ ) ) ) Im nächsten Verfeinerungsschritt sind die Funktionen des Moduls weiter zu präzisieren und zwar durch die Beschreibung ihrer Ein- und Ausgabe. Im Abschnitt INPUT geben wir daher die Argumente, hier , an. Im Abschnitt OUTPUT formulieren wir ihr Ergebniss, hier . Der Ab-

340

III. Konstruktionsempfehlung

schnitt EFFEKT-FKT dient zu verbalen Beschreibung der Leistung der einzelnen Funktionen, hier . ( ((EXPORT (EFFEKTE

({}))

(IMPORT

(( })))

()

( N U T Z T ( { < d i e n s t l e i s t e r > 1) ( ( ( < m o d u l - f u n k t i o n ) (INPUT ( ( < a r g u m e n t > ) ) ) (OUTPUT ( < w e r t - b e s c h r e i b u n g > } ) (EFFEKT-FKT ( < t e x t - z u r - b e s c h r e i bungder-funkti on>)))( ))

Eine weitere Verfeinerung, insbesondere der IMPORT-Schnittstelle, führt, indem die benötigten Funktionen aus den einzelnen Moduln genannt werden, zu einer Systemarchitektur, die als Ausgangsbasis für die Implementation als LISPKonstrukte geeignet ist. Um gestaltungsrelevante Restriktionen für die weitere Verfeinerung bzw. die Implementation festhalten zu können, ist ein Abschnitt EINSCHRÄNKUNG vorgesehehen. Grundprinzip des Abschirmens von Werten („informationen hiding") ist das Verhindern des direkten Zugreifens auf interne Zustände (vgl. Abschnitt 9.1). Dem Benutzer eines importierten Wertes ist zu verheimlichen, ob dieser z.B. aus einer Datei (permanenter Datenträger) oder aus einem Arbeitsspeicher (temporärer Datenträger) stammt. Um jedoch gegebenenfalls deutlich zu machen, welche Veränderungen bleibende Wirkung haben, also länger leben als die Aktivierung des Moduls (Dauerhaftigkeit, Persistenz), dient der Beschreibungsslot NEBENEFFEKT. ( ((EXPORT ({})) (IMPORT ( { ( < m o d u l > ( { < f u n k t i o n > } ) ) } ) ) (EFFEKTE

()

(((

(INPUT ((})) (OUTPUT {))} {(NEBENEFFEKT ())))1 ))

Dieses Spezifizieren ist ein Wechselspiel von Problemdurchdringung (Analyse), Erarbeitung einer Modulhierarchie (Synthese) und Überprüfung von Modulbeschreibungen (Revision). In diesem Wechselspiel entstehen neue, zum Teil bessere Ideen, die häufig eine Umstrukturierung bedingen. Der Beschreibungs-

341

12. Spezifikation mit LISP

rahmen erleichtert das Modifizieren. Mit Hilfe des Texteditors sind die einzelnen Slots des Rahmens leicht „umhängbar". Beispiel: FÜRSORGE (Automation im Sozialamt einer Kommune) Das System FÜRSORGE rationalisiert das Zahlungbarmachen von Sozialhilfe. Es unterstützt die Antragstellung, die Aktenverwaltung und die Aktualisierung von Berechnungsgrundlagen und Regelsätzen. Die Anforderungen seien so weit erarbeitet, daß der Entwurf einer Modul-Hierarchie zu spezifizieren ist. Wir skizzieren diese grob, wie folgt: (FÜRSORGE ((EXPORT (IMPORT (EFFEKTE

()) (ANSPRUCHSANALYSE AKTENVERWALTUNG

(FÜRSORGE p r ü f t A n t r ä g e a u f Z a h l u n g von S o z i a l h i l f e , e r s t e l l t t e r m i n g e r e c h t A u s z a h l u n g s a n o r d u n g e n und f ü h r t d i e A k t e n . FÜRSORGE w e i s t u n b e r e c h t i g t e T e r m i nalbenutzer ab.)

(FORMULARBEZOGENE-DATENPFLEGE (ANSPRUCHSANALYSE ((EXPORT ( B E S C H E I D ) ) (IMPORT ( R E G E L S Ä T Z E (EFFEKTE

(BESCHEID

ZUGANGSPRÜFUNG)))

RECHTSBELEHRUNG))

BERECHNUNGSGRUNDLAGE)))

(ANSPRUCHSANALYSE e r m i t t e l t a u s den g e p r ü f t e n A n t r a g s d a t e n B e t r ä g e und Z a h l u n g s t e r m i n e , f a l l s A n sprüche bestehen)) RÜCKRECHNUNG))

(AKTENVERWALTUNG ( ( E X P O R T (VORGANG)) (IMPORT ( A N T R A G S T E L L E R ) ) ) (EFFEKTE

(AKTENVERWALTUNG s p e i c h e r t f ü r j e d e n A n t r a g s t e l l e r a l l e i h n b e t r e f f e n d e n V o r g ä n g e u n a b h ä n g i g vom S a c h b e a r b e i t e r i n e i n e r A k t e . Für f e s t g e s t e l l t e A n s p r ü c h e g e n e r i e r t AKTENVERWALTUNG d i e A u s z a h l u n g s a n o r d n u n g . Das A k t e n z e i c h e n , Name des A n t r a g s t e l l e r s oder der e i n e s b e t r o f f e n e n F a m i l i e n m i t g l i e d e s sind Seiektionsmerkmale)

(VORGANG

AUSZAHLUNGSANORDNUNG))

(ZUGANGSPRÜFUNG ((EXPORT ( B E F U G N I S ) ) ) (EFFEKTE

(Sozialamtsleiter, Abteilungsleiter, Sachbearbeiter und M i t a r b e i t e r haben u n t e r s c h i e d l i c h e B e f u g n i s s e . ZUGANGS-PRÜFUNG v e r w a l t e t entsprechende Passwörter))

(FORTSCHREIBUNG-PAßWORT

BEFUGNIS))

342

III. Konstruktionsempfehlung

Im Rahmen der weiteren Verfeinerung könnten wir z.B. folgenden Modul A N S P R U C H S A N A L Y S E erhalten. Er zeigt, daß zu diesem Zeitpunkt die einzelnen Modulfunktionen unterschiedlich fein spezifiziert sind. Die interne Funktion R Ü C K R E C H N U N G ist verbal beschrieben, während die exportierte Funktion B E S C H E I D auf ihre Implementations-Restriktionen verweist. (ANSPRUCHSANALYSE ((EXPORT ( B E S C H E I D ) ) (IMPORT ( ( R E G E L S Ä T Z E (WOHNGELD S O Z I A L H I L F E ) ) BERECHNUNGSGRUNDLAGE))) (EFFEKTE

(ANSPRUCHSANALYSE e r m i t t e l t aus den g e p r ü f t e n Ant r a g s d a t e n B e t r ä g e und Z a h l u n g s t e r m i n e , f a l l s Ansprüche bestehen))

(NUTZT

(BEREITSTELLEN-FORMULARE

ARBEITSTAGE))

((BESCHEID

(INPUT (DATEN - FORMULAR-13 AKTE-ANTRAGSTELLER)) (OUTPUT DATEN-FORMULAR-412) (EFFEKT-FKT ( B e r e c h n e t B e t r ä g e / T e r m i n e und p r ü f t d i e im H i n b l i c k a u f Ü b e r z a h l u n g ) ) (EINSCHRÄNKUNG ( D i e e i n z e l n e n B e r e c h n u n g s s c h r i t t e s i n d d i e D i a l o g s c h n i t t s t e l l e zu q u i t t i e r e n zu k o r r i g i e r e n . ) ) (NEBENEFFEKT ( J e d e r A u f r u f f ü h r t zu einem E i n t r a g im tem-Journal ) ) )

(RÜCKRECHNUNG (EFFEKT-FKT

))

Akte über oder Sys-

( E r m i t t e l t den z u s ä t z l i c h e n A n s p r u c h bei r ü c k w i r k e n d e n Ä n d e r u n g e n der R e g e l s ä t z e ) ) )

12.3 Zusammenfassung: Spezifikation Spezifizieren heißt Präzisieren und umfaßt alle Phasen. Ziel ist eine Spezifikation mit der Präzision der Mathematik und der Verständlichkeit der Umgangssprache. Die Aufgabenart (Vollzugs-, Defintions-, Zielerreichungs- oder Steuerungsproblem) und die Aufgabengröße (ein Mann, kleines Team oder große Mannschaft) erfordern unterschiedliche (rechnergestützte) Arbeitstechniken. Eine funktionale Anforderung beschreibt eine Leistung bzw. eine quantitative oder qualitative Systemeigenschaft. Von ihr fordern wir Realisierbarkeit und Gestaltungsrelevanz. Schrittweise werden qualitative Vorgaben verfeinert, bis die einzelnen Eigenschaften durch Ersatzleistungen approximierbar sind. "Benutzt"- und „Enthält"-Relationen dienen zum Spezifizieren von Moduln und ihren Wechselwirkungen. W i r definieren eine azyklische Modul-Hierarchie über E X P O R T - und IMPORT-Schnittstelle. Schritt für Schritt verfeinern wir dieses „Skelett". Dabei definieren wir allgemeine „Dienstleister" (globale M o duln) und geben Restriktionen und Nebeneffekte an.

12. Spezifikation mit LISP Charakteristische

343

Beispiele für Abschnitt 12:

;;;; F Ü R S O R G E (Automation im S o z i a l a m t einer Kommune) ;;; D e f i n i t i o n s p r o b l e m bei m i t t l e r e K o n s t r u k t i o n s g r ö ß e ;; A p p r o x i m i e r b a r e

Vorgabe

AI FÜRSORGE u n t e r s t ü t z t a u s r e i c h e n d das

Sozialamt-Management.

;; K o n k u r r i e r e n d e Vorgabe zu AI A2 FÜRSORGE schützt den S a c h b e a r b e i t e r vor permanenter Arbeitskontrol1e. ;; Keine Vorgabe ( R e a l i s i e r b a r k e i t und G e s t a l t u n g s r e l e v a n z fehlen) A3 FÜRSORGE schafft große Freude.

Die schrittweise Approximation von AI führt zu folgenden Anforderungen: Al.l FÜRSORGE b i l a n z i e r t das IST-Geschehen in S o z i a l a m t bezogen auf S a c h b e a r b e i t e r , V o r g a n g s a r t und Zeitraum. AI.2 FÜRSORGE v e r g l e i c h t die B i l a n z e r g e b n i s s e mit denen von ähnlichen S o z i a l ä m t e r n . AI.3 FÜRSORGE stellt sogenannte "WENN ... DANN ..."-Situationen dar. Offensichtlich

konkurriert Al.l mit A2.

Ein Kompromiß wäre

Al.l FÜRSORGE b i l a n z i e r t das IST-Geschehen im S o z i a l a m t auf A b t e i l u n g e n , V o r g a n g s a r t alle 14 Tage.

z.B.:

bezogen

;; Skizze einer a u s g e f ü l l t e n C h e c k l i s t e zur M o d u l - B e s c h r e i b u n g (REGISTRATUR ((EXPORT (NEUZUGANG Ä N D E R U N G LÖSCHUNG S P E R R U N G RECHERCHE)) (IMPORT ((JOURNAL (EINTRAGUNG)) (VERTRAULICHKEIT (ÜBERPRÜFUNG V E R S C H L Ü S S E L U N G ENTSCHLÜSSELUNG)))) (EFFEKTE

(Speichern und B e r e i t s t e l l e n

(NUTZT

(FEHLERMANAGEMENT))

((NEUZUGANG

von

Akten))

(INPUT (AKTENZEICHEN V O R G A N G B E R E C H T I G U N G ) ) (OUTPUT V O L L Z U G S M E L D U N G ) (EFFEKT-FKT (NEUZUGANG legt eine Akte an, falls unter dem A k t e n z e i c h e n noch keine g e s p e i c h e r t ist, und vergibt den B e - r e c h t i g u n g s c o d e . ) ) ( E I N S C H R Ä N K U N G (Zur D a t e n s i c h e r h e i t führt ein korrekter Neuzugang zum s o f o r t i g e n Rückschreiben das Datensatzes in die Datei.)) (NEBENEFFEKT (Das J O U R N A L weist jeden Aufruf mit Vertraul i c h k e i t s s t u f e > 5 aus.))) (ÄNDERUNG . (LÖSCHUNG . (SPERRUNG . (RECHERCHE ))

344

III. Konstruktionsempfehlung

13. Wechsel der Abbildungsbasis Effizienz, Transparenz, Wartbarkeit, Ergänzbarkeit oder Portabilität sind (teilweise konkurrierende) Anforderungen für die Wahl der geeigneten Abbildungsbasis („Datenrepräsentation"). Verschieben sich die Bewertungsgewichte, dann kann ein Wechsel angebracht sein. Wir unterstellen eine Konstruktion in SCOOPS (vgl. Abschnitt 10.1), die nicht akzeptable Anwortzeiten aufweist (Effizienzmangel). Alternativ könnte es um eine Portierung gehen, bei der die SCOOPS-Konstrukte nicht verfügbar sind. Von dieser Klassen-Instanz-Abbildung wechseln wir auf eine DEFINE-STRUCTURE-Abbildung (vgl. Abschnitt 9.2), die mit einem Konstrukt zur Selektion der jeweiligen Operation zusammenarbeitet. Als Beispiel dient ein Graphikprogramm, das einen verschiebbaren Zeichenstift („Turtle") verwendet (Abschnitt 13.1). Damit zeichnen wir Struktogrammen (Nassi/Shneiderman-Zeichensymbole, vgl. Abschnitt 2.2). Die SCOOPSKonstruktion basiert auf dem Versenden von Nachrichten (engl.: message passing). Wir nennen sie kurz "Nachrichtenversand" (Abschnitt 13.2). Bei der DEFINE-STRUCTURE-Lösung selektiert eine Verzweigungsfunktion (engl.: dispatch procedure) die jeweils anzuwendend Zeichenoperation. Wir nennen sie kurz „Verzweigungsfunktion" (Abschnitt 13.3). Um in beiden Fällen die gleichen Eingabebefehle zu realisieren, bilden wir die Benutzeroberfläche mit Makros ab (vgl. Abschnitt 8.3).

13.1 Turtle Graphik Die Struktogramme zeichnen wir mit Hilfe graphischer Grundprozeduren (engl.: primitives), die in PC Scheme eingebaut sind. Solche graphischen „Primitives", wie z.B. DRAW-LINE-TO, erfordern ein Ausgabe-Fenster, das sich in einem Graphikmodus befindet. Welcher Graphikmodus mit dem SET-VIDEOMODE!-Konstrukt aktivierbar ist, hängt von der jeweiligen Hardware ab. Mit der Zuweisung (SET-VIDEO-MODE! 4) gehen wir von einem (kompatiblen) IBM PC aus und verwenden dessen CGA-Modus. Bild 13.1-1 zeigt das zugehörige Koordinatensystem. /Hinweis: Graphikmodus. Verfügt Ihr Rechner über eine Graphikkarte mit höherer Auflösung, z.B. EGA oder VGA, dann ist an die Stelle von (SET-VIDEOMODE! 4) ein anderer Wert zu setzen (EGA := 14 oder VGA := 16; vgl. TI PC Scheme Manual). Die Koordinaten- und Längenangaben sind dann entsprechend anzupassen./ Eine Linie wird auf dem Bildschirm erzeugt, indem wir den Cursor von ihrem

345

13. Wechsel der Abbildungsbasis

(-160

99)

(159,99)

A

1 Y *

(0,0)

(-160 Bild

-100) 13.1-1.

X

>

Koordi natensystem -

(SET-VIDEO-MODE!

(159

im 4)

CGA-Modus (IBM

-100)

PC)

-

Anfangspunkt zu ihrem Endpunkt verschieben. Der Anfangspunkt wird durch die aktuelle Cursorstellung definiert. Mit dem eingebauten POSITION-PENKonstrukt ist die aktuelle Position durch Angabe des X,Y-Wertes setzbar. Der X,Y-Wert des DRAW-LINE-TO-Konstruktes ist der Endpunkt. Als Nebeneffekt der Applikation des DRAW-LINE-TO-Konstruktes entsteht die Linie. Mit diesen Primitives definieren wir einen Zeichenstift. Es ist ein Pfeil, der eine aktuelle Position und eine definierte Richtung hat. Er entspricht damit der sogenannten „Turtle Graphik", wie sie durch die Programmiersprache LOGO bekannt geworden ist. Unsere Turtle (deutsch: Schildkröte, hier gleich Zeichenstift) kann vorwärts in der eingestellten Richtung bewegt werden und dabei entweder eine „Spur" zeichnen oder nicht. Dies hängt davon ab, ob der Zustand der Turtle auf Malen gesetzt wurde. Wir können die Turtle drehen und damit ihre Zeichenrichtung verändern. Mit den beiden Operationen Drehen und Vorwärtsverschieben zeichnen wir die gewünschten Figuren. /Exkurs: Turtle-Graphik. Der Name stammt von einem schildkrötenähnlichen Roboter. Seymour Papert entwickelte diesen Roboter, um Kindern das Programmieren anschaulich zu machen. Der Roboter konnte sich nach Befehlen auf dem Boden fortbewegen und mit einem Schreiber eine Spur ziehen. Später wurde der Roboter als ein Pfeil auf dem Bildschirm abgebildet. Der Name blieb als „Markenzeichen" dieser Graphikart erhalten.7 Eine einfaches Rechteck mit den Koordinaten (x , y,) und (x2, y2) für zwei gegenüberliegende Ecke läßt sich, wie folgt, definieren:

III. Konstruktionsempfehlung

346 eval>

( D E F I N E RECHTECK (LAMBDA ( X _ l Y_1 X_2 X _ 2 )

(SET-VIDEO-MODE!

4)

(POSITION-PEN

X_1 Y_1)

(DRAW-LINE-TO

X_1 Y_2)

(DRAW-LINE-TO

X_2

Y_2)

(DRAW-LINE-TO

X_2

Y_l)

;Wir u n t e r s t e l l e n ganze Z a h l e n ; im g ü l t i g e n B i l d b e r e i c h . ;Graphikmodus

(DRAW-LINE-TO X_1 Y _ l ) ; ; Damit d a s B i l d e i n e b e l i e b i g l a n g e ; ; werden k a n n , w i r d a u f e i n e E i n g a b e ; ; den T e x t m o d u s g e s c h a l t e t w i r d . (READ-CHAR) ( S E T - V I D E O - M O D E ! 3 ) ) ) = = > RECHTECK

einschalten

Zeit betrachtet gewartet, bis in

Ein Struktogramm-Block zeichnen wir als ein Rechteck, wobei wir die linke untere Ecke in X,Y-Koordinaten, die Breite (X-Richtung) und die Höhe (Y-Richtung) angeben. Die beiden Iterationen: "while do od" und „do until od" sowie die Alternative „if then eise fi" positionieren wir entsprechend. Stets geben wir die linke untere Ecke, die Breite und die Höhe an.

13.2 Lösung: Nachrichtenversand In der Nachrichtenversand-Lösung ist unsere Zeichenaufgabe (vgl. Abschnitt 13.1) in eine Hierarchie von drei Klassen gegliedert (Bild 13.2-1). Die oberste Klasse heißt BASIC-GRAPHIK. In Flavor-Systemen kennzeichnet man den Flavor, auf den einen ganze Familie von Flavors aufbaut, mit dem Präfix BASIC. Die Klasse BASIC-GRAPHIK umfaßt Konstanten und Hilfsoperationen. Sie speichert z.B. die Methode GRAD->BOGEN, die eine Winkelangabe in Grad in einen Wert in Bogenmaß umrechnet. Auf der Klasse BASICGRAPHIK baut die Klasse ZEICHENSTIFT auf. Die Klasse ZEICHENSTIFT definiert ein Objekt, dessen Slots die aktuellen X,Y-Koordinaten, die Richtung und den Malzustand festhalten. Zusätzlich ist ein Slot für die Farbe des Zeichenstifts vorgesehen. Die dritte Hierarchieebene bildet die Klasse FIGUR. Sie enthält die Methoden zum Zeichen der Struktogrammfiguren. Einer Instanz der Klasse FIGUR werden die einzelnen Nachrichten geschickt. Sie führen zur Anwendung der Methoden, die das gewünschte Struktogramm auf dem Bildschirm erzeugen. Ist eine Struktogrammfigur zu zeichnen, dann ist die zugehörige Methode der Klasse FIGUR anzuwenden. Das Applizieren einer Methode erfolgt in SCOOPS mit Hilfe des SEND-Konstruktes. Beim Abarbeiten der Methode benötigen wir

13. Wechsel der Abbildungsbasis

347

Methoden:

Slots:

GRAD->BOGEN BOGEN ->GRAD NORMALISIERUNG GRAPHIK-MODUS TEXT-MODUS GET-X-GERUNDET GET-Y-GERUNDET SET-POSITION! VORWAERTS! ZURUECK! SET-RICHTUNG! LINKS-DREHEN! RECHTS-DREHEN! SET-COLOR!

RICHTUNG MALEN FARBE

RECHTECK UNTIL WHILE I F-THEN- ELSE

eval > (S->0 BILD-1 IF-THEN-ELSE -150 -90 300 180) ==> ... ; Zeichnet die I F - T H E N - E L S E - F i g u r auf dem B i l d s c h i r m Legende: Vgl. Bild 10-3. Vgl. Programm 11.2-1. Bild 13.2-1. Programm zum Zeichen von V e r e r b u n g s g r a p h der Lösung

Struktogrammen "Nachrichtenversand"

die Kenntnis, an welche Instanz die Nachricht gesendet wurde. Da SCOOPS über kein entsprechendes SELF-Konstrukt verfügt, helfen wir uns wieder mit der Bindung des Instanznamens an die erste LAMBDA-Variable jeder Methode (vgl. Abschnitt 10.1). Wir definieren daher alle Methoden einheitlich mit zumindest dieser einen LAMBDA-Variablen, auch wenn in der Methode der Instanzname nicht benötigt wird. Zur Vereinfachung der Schreibweise definieren wir das Makro S->0. Dieses Makro transformiert: (S->0 OBJEKT NACHRICHT ARG-1 . . . ARG-N) in das S C O O P S - K o n s t r u k t : (SEND O B J E K T NACHRICHT 'OBJEKT ARG-1 ... ARG-N).

348

III. Konstruktionsempfehlung

Wenn innerhalb einer Methodendefinition eine andere Methode anzuwenden ist, müssen wir beachten, daß ihre LAMBDA-Variablen noch nicht an die Werte ihrer Argumente gebunden sind. Da das SEND-Konstrukt sein erstes „Argument" (das Objekt, an das die Nachricht gesendet wird) nicht evaluiert, können wir nicht, wie folgt, formulieren: eval> (DEFINE-METHOD (FIGUR RECHTECK) (OBJEKT X-START Y-START X-LAENGE Y-LAENGE) (SET! MALEN NIL) (S->0 OBJEKT SET-POSITION! X-START Y-START) ¡Falsch !!! (SET! MALEN #T) (S->0 OBJEKT VORWAERTS! X-LAENGE) ¡Falsch !!! ... ) = = > RECHTECK Mit dieser Formulierung schicken wir die Nachricht an die nicht existierende Instanz OBJEKT statt an den Wert von OBJEKT. Erst wenn die Methode RECHTECK angewendet wird, hat OBJEKT die Instanz als Wert. Erst zu diesem Zeitpunkt kennen wir für unser S->0-Konstrukt die Instanz. Die Zeitpunktverschiebung können wir bekanntermaßen durch die Konstruktekombination QUOTE und EVAL erreichen (vgl. Abschnitt 2.3). Hier nutzen wir die READMakros QUASIQUOTE (Kurzform: ' ) und UNQUOTE (Kurzform:, ) als syntaktische Erleichterung (vgl. Abschnitt 8.3). Die Methode RECHTECK ist dann wie folgt zu definieren: eval> (DEFINE-METHOD (FIGUR (OBJEKT (SET! MALEN NIL) ( EVAL ' (S->0 .OBJEKT (SET! MALEN #T) (EVAL ' (S->0 .OBJEKT (EVAL '(S->0 .OBJEKT (EVAL '(S->0 .OBJEKT (EVAL '(S->0 .OBJEKT (EVAL ' ( s - > o .OBJEKT (EVAL '(S->0 .OBJEKT (EVAL '(S->0 .OBJEKT (EVAL '(S->0 .OBJEKT

RECHTECK) X-START Y-START X-LAENGE Y-LAENGE) SET-POSITION! .X-START

.Y-START))

VORWAERTS! .X-LAENGE)) LINKS-DREHEN! .90)) VORWAERTS! .Y-LAENGE)) LINKS-DREHEN! ,90)) VORWAERTS! .X-LAENGE)) LINKS-DREHEN! 90)) VORWAERTS! .Y-LAENGE)) LINKS-DREHEN! 90))) = = > RECHTECK

In diesem RECHTECK-Konstrukt ist die immer wiederkehrende Folge: (EVAL '(S->0 , ... )) durch ein Makro ersetzbar, so daß wir Schreibarbeit einsparen. Wir definieren daher S-> als Makro so, daß die folgende Transformation entsteht: (S-> OBJEKT MESSAGE ARG-1 ... ARG-N) expandiert zu (EVAL "(S->0 .OBJEKT MESSAGE ,ARG-1 ... .ARG-N)) Diese Schreibweise mit den Kurzformen ' und , entspricht folgender Formulierung (vgl. Abschnitt 8.3):

349

13. Wechsel der Abbildungsbasis (EVAL

(QUASIQUOTE ( S - > (UNQUOTE MESSAGE

OBJEKT)

(UNQUOTE

ARG-1)

(UNQUOTE

ARG-N))))

S-> soll für eine beliebige Anzahl von Argumenten benutzbar sein. Aus ARG-1 ... ARG-N ist die Liste: ((UNQUOTE A R G - 1 )

...

(UNQUOTE

ARG-N)

zu konstruieren. Für diese Iteration bietet sich das MAP-Konstrukt an. Es wendet die anonyme LISP-Funktion: (LAMDA

(X)

(LIST

'UNQUOTE

x))

an. S-> ist, wie folgt, definierbar: eval>

(MACRO S - > (LAMBDA ( S E X P R ) ( L E T ( ( O B ( L I S T - R E F SEXPR 1 ) ) (MES ( L I S T - R E F SEXPR 2 ) ) ( A R G - L I S T E (MAP (LAMBDA ( X ) ( L I S T 'UNQUOTE X ) ) (CDDDR S E X P R ) ) ) ) ( L I S T 'EVAL ( L I S T 'QUASIQUOTE (CONS " S - > 0 (CONS ( L I S T 'UNQUOTE OB) (CONS MES A R G - L I S T E ) ) ) ) ) ) ) ) = = > S - >

Dokument 1 3 . 2 - 1 T i t e l : Programm zum Z e i c h n e n von S t r u k t o g r a m m e n . L ö s u n g "NACHRICHTENVERSAND" E r s t e l l t am: 2 3 . 1 2 . 8 9 ¡ l e t z t e Ä n d e r u n g : 2 3 . 1 2 . 9 0 AI Al.l AI.2 AI.3 AI.4

NACHRICHTENVERSAND z e i c h n e t : ein Rechteck, e i n e I t e r a t i o n : DO . . . U N T I L . . . OD, e i n e I t e r a t i o n : WIHLE . . . DO . . . OD und e i n e A l t e r n a t i v e : I F . . . THEN . . . F I .

El

NACHRICHTENVERSAND v e r w e n d e t d i e K l a s s e n - H i e r a r c h i e B A S I C - G R A P H I K - > Z E I C H E N - S T I F T - > FIGUR (vgl. Bild 13.2-1)

E2

NACHRICHTERVERSAND v e r w e n d e t ( v g l . Abschnitt 10.1)

SCOOPS-Konstrukte.

E3

NACHRICHTENVERSAND P r i mi t i v e s : GET-VIDEO-MODE! SET-VIDEO-MODE! CLEAR-GRAPHICS DRAW-LINE-TO POSITION-PEN SET-PEN-COLOR!

folgende

E3.1 E3.2 E3.3 E3.4 E3.5 E3.6

verwendet

graphische

350

III. Konstruktionsempfehlung

; ; ; TI

Bei spi el

;; E i n e A l t e r n a t i v e , in d e r e n l i n k e m Z w e i g e i n e W h i 1 e - I t e r a t i on ;; u n d in i h r e m r e c h t e n Z w e i g e i n e Unti 1 - I t e r a t i on d a r g e s t e l l t ;; ist. B e i d e I t e r a t i o n e n e n t h a l t e n e i n e S e q u e n z ; ; (vgl. Bild 13.2-2). (BEGIN (S->0 BILD-1 G R A P H I K - M O D U S ) (S - > o B I L D - 1 I F - T H E N - E L S E - 1 5 0 - 9 0 3 0 0 1 8 0 ) 0 - 9 0 150 1 4 4 ) (S - > o B I L D - 1 U N T I L (S - > o B I L D - 1 W H I L E - 1 5 0 - 9 0 150 1 4 4 ) (S - > o B I L D - 1 R E C H T E C K 15 - 5 0 1 3 5 4 0 ) (S - > 0 B I L D - 1 R E C H T E C K -135 -50 135 40) (READ) (S->0 BILD-1 T E X T - M O D U S ) ) ;; L a d e n d e r S C O O P S - K o n s t r u k t e (LOAD "SCOOPS.FSL") ;;;;

(vgl.

E2)

Klassen-Definitionen

;; B A S I C - G R A P H I K v e r e r b t d i e K o n s t a n t e n und H i l f s o p e r a t i o n e n . (DEFINE-CLASS BASIC-GRAPHIK (CLASSVARS (*Pi* 3.141592654)) (OPTIONS GETTABLE-VARIABLES SETTABLE-VARIABLES INITTABLE-VARIABLES)) ;; Z E I C H E N S T I F T v e r e r b t d i e X , Y - K o o r d i n a t e n , d i e R i c h t u n g , ;; d e n Z u s t a n d , ob e i n e " S p u r " g e z o g e n w e r d e n soll o d e r n i c h t , ;; u n d d i e F a r b e d e r " S p u r " . D a z u v e r e r b t s i e d i e S e l e k t o r e n ;; u n d M u t a t o r e n ; s o w o h l d i e g e n e r i e r t e n w i e d i e s e l b s t ;; d e f i n i e r t e n Z u g r i f f s m e t h o d e n , z . B . G E T - X - G E R U N D E T . (DEFINE-CLASS ZEICHENSTIFT ( I N S T V A R S (X 0) (Y 0) ( R I C H T U N G (MIXINS BASIC-GRAPHIK) (OPTIONS GETTABLE- VARIABLES SETTABLE- VARIABLES INITTABLE-VARIABLES))

0)

(MALEN #T)

(FARBE

1))

;; F I G U R v e r e r b t d i e M e t h o d e n z u m Z e i c h n e n d e r S t r u k t o g r a m m e . ;; A u s ihr w e r d e n d i e I n s t a n z e n g e b i l d e t , an d i e m i t S - > 0 ;; d i e N a c h r i c h t e n g e s e n d e t w e r d e n . (DEFINE-CLASS FIGUR (MIXINS ZEICHENSTIFT)) ;; I n s t a n z - B e i s p i e l (DEFINE BILD-1 (MAKE-INSTANCE ;;;;

FIGUR))

Syntax-Vereinfachung

; ; ; Makro S->0 : ; ;; (S->0 OBJEKT M E S S A G E ;;; e x p a n d i e r t zu: ;;; (SEND O B J E K T M E S S A G E (MÄCRO S->0 (LAMBDA (SEXPR) ' ( S E N D . ( L I S T - R E F S E X P R 1) . ( L I S T - R E F S E X P R 2) ' . ( L I S T - R E F S E X P R 1) ,@(CDDDR SEXPR))))

ARG) 'OBJEKT

ARG)

351

13. Wechsel der Abbildungsbasis Makro

S->

:

( S - > OBJEKT MESSAGE A R G - 1 . . . ARG-N) zu: (EVAL 4 ( S - > 0 .OBJEKT MESSAGE , A R G - 1 . . . MACRO S - > (LAMBDA ( S E X P R ) ( L E T ( ( O B ( L I S T - R E F SEXPR 1 ) ) (MES ( L I S T - R E F SEXPR 2 ) ) ( A R G - L I S T E (MAP (LAMBDA ( X ) ( L I S T 'UNQUOTE X ) ) (CDDDR S E X P R ) ) ) ) (LIST 'EVAL ( L I S T 'QUASIQUOTE (CONS ' S - > 0 (CONS ( L I S T 'UNQUOTE OB) (CONS MES A R G - L I S T E ) ) ) ) ) ) ) ) expandiert

;;;;

.ARG-N))

Methoden-Definitionen

(DEFINE-METHOD ( B A S I C - G R A P H I K ( * WERT (/ * P I * 1 8 0 ) ) )

GRAD->BOGEN)

(OBJEKT

WERT)

(DEFINE-METHOD (BASIC-GRAPHIK ( * WERT (/ 180 * P I * ) ) )

BOGEN->GRAD)

(OBJEKT

WERT)

NORMALISIERUNG s t e l l t s i c h e r , daß f ü r d i e B o g e n m a ß - A n g a b e WERT s t e t s g i l t : 0 < = WERT OBJEKT GET-X-GERUNDET) ( S - > OBJEKT G E T - Y - G E R U N D E T ) ) ) ( S - > OBJEKT G E T - X - G E R U N D E T ) ( S - > OBJEKT G E T - Y - G E R U N D E T ) ) ) ) )

; VORWAERTS! b e r e c h n e t a u s d e r L ä n g e n a n g a b e den E n d p u n k t d e r ; L i n i e . Dazu v e r w e n d e t s i e den R i c h t u n g s w e r t des j e w e i l i g e n : Zeichenstiftes. DEFINE-METHOD ( Z E I C H E N S T I F T VORWAERTS!) (OBJEKT LAENGE) ( S - > OBJEKT S E T - P O S I T I O N ! ( + X ( * LAENGE (COS R I C H T U N G ) ) ) ( + Y ( * LAENGE ( S I N R I C H T U N G ) ) ) ) )

352

III. Konstruktionsempfehlung

(DEFINE-METHOD (ZEICHENSTIFT ZURUECK!) (OBJEKT LAENGE) (S-> OBJEKT V O R W A E R T S ! (- LAENGE))) (DEFINE-METHOD (ZEICHENSTIFT S E T - R I C H T U N G ! ) (OBJEKT GRAD) (LET ((BOGEN (S-> O B J E K T G R A D - > B O G E N GRAD))) (SET! RICHTUNG (S-> OBJEKT N O R M A L I S I E R U N G BOGEN)))) (DEFINE-METHOD ( Z E I C H E N S T I F T LINKS-DREHEN!) (OBJEKT GRAD) (LET ((BOGEN (S-> OBJEKT G R A D - > B O G E N GRAD))) (SET! RICHTUNG (S-> OBJEKT N O R M A L I S I E R U N G (+ RICHTUNG B O G E N ) ) ) ) ) (DEFINE-METHOD (ZEICHENSTIFT RECHTS - DREHEN!) (OBJEKT GRAD) (S-> OBJEKT L I N K S - D R E H E N ! (- GRAD))) (DEFINE-METHOD (ZEICHENSTIFT S E T - C O L O R ! ) (OBJEKT WERT) (SET! FARBE WERT) (SET-PEN-COLOR! WERT)) (DEFINE-METHOD (FIGUR RECHTECK) (OBJEKT X-START Y-START X - L A E N G E Y-LAENGE) (SET! MALEN N I L ) (S-> OBJEKT S E T - P O S I T I O N ! X-START Y-START) (SET! MALEN # T ) (S-> O B J E K T V O R W A E R T S ! X-LAENGE) (S-> OBJEKT L I N K S - D R E H E N ! 90) (S-> OBJEKT V O R W A E R T S ! Y - L A E N G E ) (S-> OBJEKT LINKS-DREHEN! 90) (S-> OBJEKT VORWAERTS! X-LAENGE) (S-> OBJEKT L I N K S - D R E H E N ! 90) (S-> OBJEKT V O R W A E R T S ! Y - L A E N G E ) (S-> OBJEKT LINKS-DREHEN! 9 0 ) ) (DEFINE-METHOD (FIGUR UNTIL) (OBJEKT X-START Y-START X-LAENGE Y-LAENGE) (S-> OBJEKT RECHTECK X-START Y - S T A R T X - L A E N G E Y - L A E N G E ) (S-> OBJEKT RECHTECK (+ X-START (* 0.1 X - L A E N G E ) ) (+ Y-START (* 0.1 Y - L A E N G E ) ) (- X-LAENGE (* 0.1 X-LAENGE)) (- Y - L A E N G E (* 0.1 Y - L A E N G E ) ) ) ) (DEFINE-METHOD (FIGUR WHILE) (OBJEKT X-START Y - S T A R T X - L A E N G E Y-LAENGE) (S-> OBJEKT RECHTECK X-START Y - S T A R T X - L A E N G E Y-LAENGE) (S-> OBJEKT RECHTECK (+ X-START (* 0.1 X-LAENGE)) (+ Y-START) (- X-LAENGE (* 0.1 X-LAENGE)) (- Y - L A E N G E (* 0.1 Y - L A E N G E ) ) ) ) (DEFINE-METHOD (FIGUR IF-THEN-ELSE) (OBJEKT X-START Y - S T A R T X - L A E N G E Y - L A E N G E ) (LET ((X-ZW (+ X-START (/ X - L A E N G E 2))) (Y-ZW (+ Y - S T A R T (* 0.8 Y - L A E N G E ) ) ) )

13. Wechsel der Abbildungsbasis (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T (SET! MALEN (S-> O B J E K T Programm

353

RECHTECK X-START Y-START X-LAENGE Y-LAENGE) ()) SET-POSITION! X-START Y-ZW) T) VORWAERTS! X-LAENGE) ()) SET-POSITION! X-ZW Y-ZW) T) S E T - P O S I T I O N ! X - S T A R T (+ Y - S T A R T Y - L A E N G E ) ) ()) SET-POSITION! X-ZW Y-ZW) T) S E T - P O S I T I O N ! (+ X - S T A R T X - L A E N G E ) (+ Y - S T A R T Y - L A E N G E ) ) ()) SET-POSITION! X-ZW Y-ZW) T) SET-POSITION! X-ZW Y-START) ()) SET-POSITION! X-START Y-START)))

13.2-1

Zeichnen - Lösung

von Struktogrammen "Nachrichtenversand"

Legende: Nassi/Shneiderman-Kontrol1 struktur, Bild

13.2-2 (vgl.

Struktogramm-Beispiel Programmfragment

vgl.

-

Bild

2.2.3-2.

13.2-1)

13.3 Lösung: Verzweigungsfunktion In der obigen Nachrichtenversand-Lösung ist das Abarbeiten der SEND-Konstrukte aufwendig. Wir verkürzen die Antwortzeit, indem wir den Zeichenstift auf eine DEFINE-STRUCTURE-Lösung umstellen und zusätzlich alle obigen Methoden zusammen an eine globale Variable *OPERATION* binden, die

354

III. Konstruktionsempfehlung

selbst die Selektion der jeweils benötigten Operation („Methode") vornimmt. (Dies beschleunigt die Ausführung bei einem I B M AT ungefähr um 1:25). Dabei stellen wir durch die Änderung des Makros S - > 0 sicher, daß die gleichen Kommandos verarbeitet werden. Unser Beispielbild erzeugen wir wieder durch das Konstrukt: eval>

(BEGIN (S->0 BILD-1 (S->0 BILD-1 (S->0 BILD-1 C S->0 BILD-1 (S->0 BILD-1 (S->0 BILD-1 (READ-CHAR) (S->0 BILD-1

GRAPHIK-MODUS) IF-THEN-ELSE -150 UNTIL 0 WHILE -150 RECHTECK 15 RECHTECK -135 TEXT-MODUS))

==>

-90 -90 -90 -50 -50

300 150 150 135 135

180) 144) 144) 40) 40)

; S t r u k t o g r a m m gemäß ; Bild 11.2-2.

Das Konstrukt *OPERATION* ist eine Funktion höherer Ordnung. Sie hat als Wert die nachgefragte Operation zum Zeichnen der Figur. Sie ist daher eine Verzweigungsfunktion (engl.: dispatch function). Der Rückgabewert ist diejenige Funktion, die anhand des Arguments (der „Nachricht") ausgewählt wird; z.B.: eval>

(^OPERATION* 'RECHTECK) = = > #

¡"Methode"

RECHTECK

Das Konstrukt O P E R A T I O N * hat folgende Struktur: eval>

(DEFINE ^OPERATION* (LET ( . . . (RECHTECK (LAMBDA (UNTIL (LAMBDA ( D I S P A T C H (LAMBDA (CASE OPERATION

( (

... ...

) ... ) ...

(OPERATION)

) )

13. Wechsel der Abbildungsbasis (RECHTECK (UNTIL

...

)

355 RECHTECK) UNTIL)

) ¡Ende d e r l o k a l e n DISPATCH)) ==> O P E R A T I O N *

Variablen

Ein Rechteck, dessen linke untere Ecke beispielsweise die Position X := -150 , Y := -90 hat und dessen Breite := 300 und Höhe := 180 ist, zeichnen wir, wie folgt: eval>

( ( ^ O P E R A T I O N * 'RECHTECK) BILD-1 -150 -90 300 180) = = > ... ; R e c h t e c k f i g u r a u f d e m B i l d s c h i r m

Das neue Makro S - > 0 hat aus unserem bisherigen Zeichenkommando einen solchen Ausdruck zu expandieren. Es hat die Syntax: (S->0 O B J E K T

MESSAGE ARG-1

...

in folgendes Konstrukt zu überführen: ((•OPERATION*

'MESSAGE)

OBJEKT

ARG-N)

ARG-1

...

ARG-N)

Mit Hilfe der Konstrukte Q U A S I Q U O T E (Kurzform: ' ), UNQUOTE (Kurzform: , ) und UNQUOTE-SPLICING (Kurzform: ) können wir das Makro S - > 0 einfach formulieren (vgl. Abschnitt 8.3): eval>

(MACR0 S->0 (LAMBDA (SEXPR) ' ( ^OPERATION* ' , ( L I S T - R E F S E X P R 2)) . ( L I S T - R E F S E X P R 1) ,@(CDDDR SEXPR)))) ==> S->0

;'MESSAGE ;0BJEKT ;ARG-1 ...

ARG-N

Dokument 13.3-1 T i t e l : P r o g r a m m zum Z e i c h n e n von S t r u k t o g r a m m e n und F r a k t a l f i g u r (vgl. A b s c h n i t t 13.4). Lösung "VERZWEIGUNGSFUNKTION" E r s t e l l t am: 2 3 . 1 2 . 8 9 ¡ l e t z t e Ä n d e r u n g : 2 3 . 1 2 . 9 0 AI VERZWEIGUNGSFUNKTION zeichnet: Al.l ein Rechteck, A I . 2 e i n e I t e r a t i o n : DO . .. U N T I L ... O D , A I . 3 e i n e I t e r a t i o n : W I H L E . . . DO . . . O D , A I . 4 e i n e A I t e r n a t i ve: IF ... T H E N .. . FI u n d AI.5 die Farktalfigur "Koch-Kurve".

einer

356

III. Konstruktionsempfehlung

;;; ;;; ;;;

El

VERZWEIGUNGSFUNKTION verwendet das D E F I N E - S T R U C T U R E - K o n s t r u k t ( v g l . A b s c h n i t t 9.2) zur D e f i n t i o n eines Zei c h e n s t i f t e s .

;;; ;;;

E2

VERZWEIGUNGSFUNKTION a r b e i t e t mit e i n e r "dispatching-Funktion OPERATION*.

;;; ;;; ; ;; ;;; ;;; ;;; ; ;; ;;;

E3

;;; ;;; ;;;

E4

Das Makro sprechend berei t.

;;; ;;; ;;; ;;; ;;; ;;; ;;; ;;;

T1 Tl.l Tl.2

Bei spi e l e v g l . Programm 1 3 . 2 - 1 Fraktalgeometrie "Schneeflocke" (vgl. Bild (BEGIN ( S - > 0 B I L D - 1 GRAPH I K - M O D U S ) ( S - > 0 B I L D - 1 KOCH-KURVE - 1 2 0 -47 4 1 5 8 ) (READ) ( S - > 0 B I L D - 1 TEXT-MODUS))

NACHRICHTENVERSAND Pr i mi t ives: E 3 . 1 GET - V I DEO - MODE! E 3 . 2 SET - V I DEO-MODE! E3.3 CLEAR-GRAPHICS E3.4 DRAW-LINE-TO E3.5 POSITION-PEN E 3 . 6 S E T - PEN - C O L O R !

verwendet

graphische

S->0 s t e l l t die Benutzeroberfläche entNACHRICHTENVERSAND ( v g l . Programm 1 3 . 2 - 1 )

(DEFINE-STRUCTURE ZEICHENSTIFT (X 0 ) (Y 0 ) ( R I C H T U N G 0 ) ( M A L E N T ) ;; B e i s p i e l (DEFINE BILD-1

folgende

globalen

(FARBE

13.4-1)

1))

(MAKE-ZEICHENSTIFT))

(DEFINE *0PERATI0N* (LET* ( ( * P I * 3.141592654) (GRAD->B0GEN (LAMBDA (OBJEKT

WERT)

(*

WERT

(/

*PI*

(BOGEN - > G R A D (LAMBDA (OBJEKT

WERT)

(*

WERT

(/

180

*PI*))))

( N O R M A L I S I E R U N G ( L A M B D A ( O B J E K T WERT) (LET ( ( 2 P I ( * 2 * p i * ) ) ) ( - WERT ( * ( F L O O R ( / WERT 2 P I ) )

2PI)))))

180))))

(GRAPHIK-MODUS (LAMBDA ( O B J E K T ) (COND ( ( = ( G E T - V I D E O - M O D E ) 4 ) ) (T ( S E T - V I D E O - M O D E ! 4 ) (CLEAR-GRAPHICS))))) (TEXT-MODUS (LAMBDA ( O B J E K T ) (SET-VIDEO-MODE! 3))) ( G E T - X - G E R U N D E T (LAMBDA ( O B J E K T ) (FLOOR ( + ( Z E I C H E N S T I F T - X OBJEKT)

0.5))))

13. Wechsel der Abbildungsbasis

357

(GET-Y-GERUNDET (LAMBDA (OBJEKT) (FLOOR (+ (ZEICHENSTIFT-Y OBJEKT) 0.5)))) (SET-POSITION! (LAMBDA (OBJEKT X-WERT Y-WERT) (SET! (ZEICHENSTIFT-X OBJEKT) X-WERT) (SET! (ZEICHENSTIFT-Y OBJEKT) Y-WERT) (COND ( ( Z E I C H E N S T I F T - M A L E N OBJEKT) (DRAW-LINE-TO (GET-X-GERUNDET OBJEKT) ( G E T - Y - G E R U N D E T OBJEKT))) (t (POSITION-PEN ( G E T - X - G E R U N D E T OBJEKT) (GET-Y-GERUNDET O B J E K T ) ) ) ) ) ) (VORWAERTS! (LAMBDA (OBJEKT LAENGE) ( S E T - P O S I T I O N ! OBJEKT (+ (ZEICHENSTIFT-X OBJEKT) (* LAENGE (COS (ZEICHENSTIFT - R I C H T U N G O B J E K T ) ) ) ) (+ (ZEICHENSTIFT-Y OBJEKT) (* LAENGE (SIN (ZEICHENSTI FT - R I C H T U N G O B J E K T ) ) ) ) ) (ZURUECK! (LAMBDA (OBJEKT LAENGE) (VORWAERTS! OBJEKT (- LAENGE)))) (SET-RICHTUNG! (LAMBDA (OBJEKT GRAD) (LET ((BOGEN (GRAD->BOGEN OBJEKT GRAD))) (SET! ( Z E I C H E N S T I F T - R I C H T U N G OBJEKT) ( N O R M A L I S I E R U N G OBJEKT BOGEN))))) (LINKS-DREHEN! (LAMBDA (OBJEKT GRAD) (LET ((BOGEN (GRAD->BOGEN OBJEKT GRAD))) (SET! ( Z E I C H E N S T I F T - R I C H T U N G OBJEKT) ( N O R M A L I S I E R U N G OBJEKT (+ ( Z E I C H E N S T I F T - R I C H T U N G OBJEKT)

BOGEN))))))

(RECHTS-DREHEN! (LAMBDA (OBJEKT GRAD) (LINKS-DREHEN! OBJEKT (- G R A D ) ) ) ) (SET-COLOR! (LAMBDA (OBJEKT WERT) (SET! ( Z E I C H E N S T I F T - F A R B E OBJEKT) WERT) ( S E T - P E N - C O L O R ! WERT))) (RECHTECK (LAMBDA (OBJEKT X-START Y-START X-LAENGE Y-LAENGE) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) ()) (SET-POSITION! OBJEKT X-START Y-START) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) T) (VORWAERTS! OBJEKT X-LAENGE) (LINKS-DREHEN! OBJEKT 90) (VORWAERTS! OBJEKT Y-LAENGE) ( L I N K S - D R E H E N ! OBJEKT 90) (VORWAERTS! OBJEKT X-LAENGE) (LINKS-DREHEN! OBJEKT 90) (VORWAERTS! OBJEKT Y - L A E N G E ) (LINKS-DREHEN! OBJEKT 9 0 ) ) )

358

III. Konstruktionsempfehlung (UNTIL (LAMBDA (OBJEKT X-START Y-START X - L A E N G E Y - L A E N G E ) (RECHTECK OBJEKT X-START Y-START X-LAENGE Y-LAENGE) (RECHTECK OBJEKT (+ X-START (* 0.1 X-LAENGE)) (+ Y-START (* 0.1 Y - L A E N G E ) ) (- X - L A E N G E (* 0.1 X-LAENGE)) (- Y - L A E N G E (* 0.1 Y - L A E N G E ) ) ) ) ) (WHILE (LAMBDA (OBJEKT X-START Y-START X - L A E N G E Y - L A E N G E ) (RECHTECK OBJEKT X-START Y-START X - L A E N G E Y-LAENGE) (RECHTECK OBJEKT (+ X-START (* 0.1 X-LAENGE)) (+ Y-START) (- X - L A E N G E (* 0.1 X-LAENGE)) (- Y - L A E N G E (* 0.1 Y - L A E N G E ) ) ) ) ) (IF-THEN- ELSE (LAMBDA (OBJEKT X-START Y-START X - L A E N G E Y - L A E N G E ) (LET ((X-ZW (+ X-START (/ X-LAENGE 2))) (Y-ZW (+ Y-START (* 0.8 Y - L A E N G E ) ) ) ) (RECHTECK OBJEKT X-START Y-START X-LAENGE Y-LAENGE) (SET! ( Z E I C H E N S T I F T - M A L E N O B J E K T ) ()) (SET-POSITION! O B J E K T X-START Y-ZW) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) T) (VORWAERTS! OBJEKT X-LAENGE) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) ()) (SET-POSITION! OBJEKT X-ZW Y-ZW) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) T) (SET-POSITION! OBJEKT X-START (+ Y-START Y - L A E N G E ) ) (SET! ( Z E I C H E N S T I F T - M A L E N O B J E K T ) ()) (SET-POSITION! OBJEKT X-ZW Y-ZW) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) T) (SET-POSITION! OBJEKT (+ X-START X-LAENGE) (+ Y-START Y - L A E N G E ) ) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) ()) (SET-POSITION! OBJEKT X-ZW Y-ZW) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) T) (SET-POSITION! O B J E K T X-ZW Y-START) (SET! ( Z E I C H E N S T I F T - M A L E N OBJEKT) ()) (SET-POSITION! O B J E K T X-START Y - S T A R T ) ) ) )

13. Wechsel der Abbildungsbasis

359

;; V g l . A b s c h n i t t 13.4 (KOCH-KURVE ( L A M B D A ( O B J E K T X - S T A R T Y - S T A R T ORDNUNG L A E N G E ) ( L E T R E C ( ( S C H R I T T ( L A M B D A ( 0 N L) (COND ( ( Z E R O ? N) ( V O R W A E R T S ! 0 L ) ) (T ( L E T ( ( M ( - 1 + N ) ) (WEG ( / L 3 . 0 ) ) ) ( S C H R I T T 0 M WEG) (RECHTS-DREHEN! 0 60) ( S C H R I T T 0 M WEG) (LINKS-DREHEN! 0 120) ( S C H R I T T 0 M WEG) (RECHTS-DREHEN! 0 60) (SCHRITT 0 M W E G ) ) ) ) ) ) ) (SET! (ZEICHENSTIFT-MALEN OBJEKT) ()) ( S E T - P O S I T I O N ! OBJEKT X-START Y - S T A R T ) (SET-RICHTUNG! OBJEKT 0) ( S E T ! ( Z E I C H E N S T I F T - M A L E N OBJEKT) T) ( S C H R I T T O B J E K T ORDNUNG L A E N G E ) ( L I N K S - D R E H E N ! OBJEKT 120) ( S C H R I T T O B J E K T ORDNUNG L A E N G E ) ( L I N K S - D R E H E N ! OBJEKT 120) ( S C H R I T T O B J E K T ORDNUNG L A E N G E ) ( L I N K S - D R E H E N ! OBJEKT 1 2 0 ) ) ) )

i ntern: i ntern: i ntern: ; ;

intern: intern:

( D I S P A T C H (LAMBDA ( O P E R A T I O N ) (CASE OPERATION (GRAD->BOGEN GRAD->BOGEN) (BOGEN->GRAD BOGEN->GRAD) (NORMALISIERUNG NORMALISIERUNG) (GRAPHIK-MODUS GRAPHIK-MODUS) (TEXT-MODUS TEXT-MODUS) (GET-X-GERUNDET GET-X-GERUNDET) (GET-Y-GERUNDET GET-Y-GERUNDET) (SET-POSITION! SET-POSITION ! ) (VORWAERTS! VORWAERTS!) (ZURUECK! ZURUECK!) (SET-RICHTUNG! SET-RICHTUNG!) (LINKS-DREHEN! LINKS-DREHEN!) (RECHTS-DREHEN! RECHTS-DREHEN!) (SET-COLOR! SET-COLOR!) (RECHTECK RECHTECK) (UNTIL UNTIL) (WHILE WHILE) (IF-THEN-ELSE IF-THEN-ELSE) (KOCH-KURVE KOCH-KURVE) ( E L S E (ERROR " U n b e k a n n t e O p e r a t i o n : OPERATION))

))))

DISPATCH))

"

III. Konstruktionsempfehlung

360 ;;;;

Benutzeroberfläche

(gemäß

Programm

13.2-1)

;;; Makro S - > 0 : ;;; ( S - > 0 OBJEKT MESSAGE ARG-1 . . . ;;; e x p a n d i e r t zu: ;;; ( ( * 0 P E R A T I 0 N * ' M E S S A G E ) OBJEKT (MACRO S - > 0 (LAMBDA ( S E X P R ) ' C O O P E R A T I O N * ' , C L I S T - R E F SEXPR 2 ) ) . ( L I S T - R E F SEXPR 1) ,@(CDDDR S E X P R ) ) ) ) d

Programm 1 3 . 3 - 1 Zeichnen -

Lösung

von

ARG-N) ARG-1

...

ARG-N)

Struktogrammen

"Verzweigungsfunktion"

-

Das DISPATCH-Konstrukt (Programm 13.3-1) ermöglicht auf einfache Weise, bestimmte Funktionen („Methoden") dem Benutzer vorzuenthalten. Eine Kennzeichnung als Kommentar, d.h. ein Semikolon in der entsprechenden Zeile des CASE-Konstruktes, genügt. Die Funktion wird dann nicht exportiert (vgl. Abschnitt 12.2). Im obigen Programm haben wir z.B. die Funktion GRAD->BOGEN so gesperrt. Sie wird nicht exportiert, kann jedoch intern angewendet werden.

13.4 Fraktalfigur Struktogramme sind nützliche, aber sehr nüchterne Figuren. Um uns an der Schönheit einer Graphik erfreuen zu können, zeichnen wir eine einfache Fraktalfigur, die wie eine Schneeflocke aussieht (Bild 13.4-2). Mit einer solchen Figur hat sich schon um 1900 der Mathematiker Helge von Koch befaßt. Sie wird ihm zu Ehren daher auch als tiradische Koch-Insel oder als Koch'sehe Schneeflocke bezeichnet. /Exkurs: Fraktale (Objekte). Der Begriff „fractals" stammt vom polnisch-französischen Mathematiker Benoit B. Mandelbrot (vgl. Mandelbrot, 1977). Man bezeichnet damit Objekte, die sich nicht mehr mit den Begriffen wie Linie oder Fläche beschreiben lassen. Solchen Objekten zwischen Linie (Dimension = 1) und Fläche (Dimension = 2) ordnet man eine nicht ganzahlige, eine „fraktale" (gebrochene) Dimension zwischen 1 und 2 zu. Aufgrund wissenschaftlicher Vorarbeiten des französischen Mathematikers Gaston Julia spricht man in diesem Zusammenhang auch von Julia-Mengen. Kennzeichned für „Fraktale" sind die beiden Eigenschaften: o „Selbstähnlichkeit", d.h. man findet die Form des Gesamten in jedem Detail wieder und o „Verkrumpelung", d.h. es treten kein glatte Begrenzungen auf, so daß eine Länge oder ein Flächeninhalt nicht zu bestimmen ist. Beim genauen Hinschauen, findet man solche „Fraktale" überall in der Natur

13. Wechsel der Abbildungsbasis

361

(vgl. Mandelbrot, 1983). Der Blumenkohl-Kopf ist ein populäres Beispiel. Ein praxisnahes Software-Konstruktionsgebiet ist die Computer-Animation. Man modelliert z.B. mit „stochastischen Fraktalen" detailreiche Gebirgsketten. Die Koch'sehe Schneefocke gehört (wie auch das populäre „Apfelmännchen") zur "deterministischen (kausal abhängigen) Fraktale", da sie mit einer einfachen Rekursionsformel beschreibbar ist. (Fraktale Kunstwerke vgl. z.B. Peitgen/Richter, 1986). ] Unsere Schneeflocke basiert auf einem gleichseitigen Dreieck. Die Dreieckseiten bestehen aus Fraktallinien der angegebenen Ordnung. Eine Fraktallinie der ersten Ordnung ist eine „gebrochene", also frakturierte Linie (vgl. Bild 13.4-1). Eine Fraktallinie 0-ter Ordnung ist eine Gerade.

Eine Fraktallinie n-ter Ordnung ist eine Linie, bei der jede Gerade durch eine Fraktallinie (n-l)ter Ordnung dargestellt ist. Jede Fraktallinie n-ter Ordnung vergrößert den Flächeninhalt der Figur aus Fraktallinien (n-l)ter Ordnung. Statt einer Geraden der Länge L zeichnen wir einen Streckenzug mit 4 Teilabschnitten, die eine Länge von jeweils 1/3 L haben. Nachdem der Zeichenstift den ersten Teilabschnit gezeichnet hat, drehen wir seine Richtung rechtsherum, um 60 Grad und zeichnen den zweiten Teilabschnitt. Anschließend drehen wir die Richtung linksherum um 120 Grad und zeichnen den dritten Teilabschnitt. Dann drehen wir die Richtung rechtsherum um 60 Grad und zeichnen den vierten Teilabschnitt. Wiederholt man dieses Verfahren auf alle entstehenden Teilabschnitte, so entsteht beim Grenzübergang zu unendlich vielen Wiederholungen die sogenannte Kochsche Kurve. Aufgrund der begrenzten Punktezahl im Graphikmodus können nicht beliebig kurze Teilstrecken dargestellt werden. Kürzere Strecken als ein Graphik„Punkt" sind nicht abbildbar. Die auflösbare Ordnung n unserer Fraktalfigur ist daher abhängig von der verfügbaren Hardware. Bild 13.4-2 zeigt eine Fraktalfigur der vierten Ordnung. Das obige KOCH-KURVE-Konstrukt (vgl. Programm 13.3-1) basiert auf der lokalen rekursiven Funktion SCHRITT. Ist die Ordnung N = 0, dann ist eine Gerade zu zeichnen (trivialer Fall der Rekursion). Ist N > 0 konstruieren wir eine Fraktallinie, wobei die Teilabschnitte jeweils aus Fraktallinen der (n-1 )ten

362

III. Konstruktionsempfehlung

Ordnung bestehen. Damit ist die „Rekursions-Route" (vgl. Abschnitt 3) definiert.

13.5 Zusammenfassung: Graphik, SEND- und DISPATCH-Konstruktion Effizienz, Transparenz, Wartbarkeit, Ergänzbarkeit oder Portabilität sind (teilweise konkurrierende) Anforderungen für die Auswahl der geeigneten Abbildungsbasis. Verschieben sich die Bewertungsgewichte, dann kommt ein Wechsel in Betracht. Objektgeprägte Konstruktionen (z.B. realisiert mit SCOOPS) haben im Vergleich zu imperativgeprägten einen größeren Speicher-und Rechenzeitbedarf. Eine Umstellung des Kommunikations-Konzeptes („message passing") z.B. durch ein explizites Ansteuerern der einzelnen Funktion, vermindert den Bedarf. Statt die Nachricht (mit dem SCOOPS-Konstrukt SEND) an das Objekt zu schikken, um damit die Applikation der gewünschten Methode zu erreichen, wird die Funktion über ein Verzweigungs-Konstrukt (engl.: dispatch procedure) ausgewählt und angewendet. Dabei kannt die bisherige Benutzoberfläche (Syntax des SEND) durch Makros simuliert werden. Mit den eingebauten grapischen „Primitives": GET-VIDEO-MODE, SETVIDEO-MODE!, CLEAR-GRAPHICS, DRAW-LINE-TO, POSITION-PEN und SET-PEN-COLOR! in Verbindung mit rekursiven Definitionen sind wunderschöne Figuren aus der Fraktalgeometrie abbildbar.

363

13. Wechsel der Abbildungsbasis Charakteristisches

Beispiel fiir Abschnitt 13:

;;;; D o k u m e n t 1 3 . 5 - 1 ;;;; T i t e l : Das H a u s d e s N i k o l a u s ;;;; E r s t e l l t a m : 1 9 . 0 4 . 9 0 ¡ l e t z t e Ä n d e r u n g : ;;; ;;; ;;; ;;; ;;; ;;; ;;;

AI Al.l AI.2 AI.3

23.12.90

NIKOLAUS zeichnet Linie für Linie, ohne den Zeichenstift a b z u s e t z e n , das "Haus des N i k o l a u s . D i e r e c h t e u n t e r e H a u s e c k e ist d e r S t a r t p u n k t . D i e K o o r d i n a t e n d e s S t a r t p u n k t e s s i n d als I n t e g e r z a h l e n im A n t w o r t - F e n s t e r a n z u g e b e n . D i e im A n t w o r t - F e n s t e r e r f r a g t e S e i t e n l a e n g e b e s t i m m t die G r o e s s e des H a u s e s .

;;; A2 ;;; ;;; A 2 . 1 ;;; ;;; A 2 . 2 ;;;

V o r g e g e b e n e E r s a t z w e r t e k o r r i g i e r e n nicht p l a u s i b l e Eingaben. Ein P o p u p - M e l d u n g s f e n s t e r v e r w e i s t a u f e i n e s o l c h e K o r rektur. Nach einer angemessenen Lesezeit verschwindet dieses Meldungsfenster.

;;: A 3 ;;;

Die Seiten des Druecken einer

Haus entstehen s c h r i t t w e i s e beliebigen Taste.

;;: ; ;; ;;; ;;;

El NIKOLAUS verwendet El.l SET - V I D E O - M O D E ! El.2 D R A W - L I N E - T O El.3 POSITION-PEN

;;; ;;; ; ;; ;;; ;:: ::; ; ;;

E2

nach

dem

folgende

graphische

Primitives:

NIKOLAUS verwendet folgende Konstrukte: E2.1 M A K E - W I N D O W E2.2 W I N D O W - P O P U P E2.3 WINDOW-POPUP-DELETE E2.4 W I N D O W - S E T - P O S I T I O N ! E2.5 W I N D O W - S E T - S I Z E !

eingebaute

WIND0W-

;;; T1 :;; (DEFINE (LET*

Beispiel (NIKOLAUS) ==>

... B i l d

NIKOLAUS (LAMBDA ( ) ((GRAPHIK-MODUS (LAMBDA (X-MIN -160) (Y-MIN -100) (X-MAX 159) (Y-MAX 99) ( T E X T - M O D U S ( L A M B D A ()

... ()

¡Startwerte

im

(SET-VIDEO-MODE!

(SET-VIDEO-MODE!

Dialog 4)))

3)))

(WARTEN (LAMBDA (LET*

(SEKUNDEN) ( ( A N F A N G ( R U N T I M E ) ) ¡vgl. A b s c h n i t t 8 . 5 ( E N D E (+ (* S E K U N D E N 1 0 0 ) A N F A N G ) ) ) (DO ( ( A K T U E L L E - Z E I T ( R U N T I M E ) ( R U N T I M E ) ) ) ( C O R (>= A K T U E L L E - Z E I T E N D E ) (< A K T U E L L E - Z E I T A N F A N G ) ) T) "Arbeite!"))))

;; U m L i n i e n n a c h e i n a n d e r z u z e i c h n e n ( W E I T E R ( L A M B D A () ( R E A D - C H A R ) ) )

(vgl.

A3)

364

III. Konstruktionsempfehlung (MELDUNG (LAMBDA ( ) (LET ((PROMPTER

(MAKE-WINDOW "Ni kolaus-Haus-Mel dung" # T ) ) ) ( W I N D O W - S E T - S I Z E ! PROMPTER 2 5 0 ) ( W I N D O W - S E T - P O S I T I O N ! PROMPTER 10 8 ) (WINDOW-POPUP PROMPTER) (DISPLAY " I h r e A n g a b e l i e g t n i c h t im a b b i l d b a r e n B e r e i c h ! ' PROMPTER) (NEWLINE PROMPTER) (DISPLAY " Es w i r d e i n E r s a t z w e r t a n g e n o m m e n . " PROMPTER) (WARTEN 4 ) (WINDOW-POPUP-DELETE PROMPTER))))

(ANTWORT (LAMBDA () (LET ((FENSTER

(MAKE-WINDOW "Nikolaus-Haus-Groesse" #T)) (X-ERSATZ 50) (Y-ERSATZ -60) (SEITEN-LAENGE-ERSATZ 80) (X-START-HAUS 0) (Y-START-HAUS 0) (SEITEN-LAENGE-HAUS 0)) ( W I N D O W - S E T - S I Z E ! F E N S T E R 10 4 5 ) ( W I N D O W - S E T - P O S I T I O N ! FENSTER 5 6) (WINDOW-POPUP F E N S T E R ) (DISPLAY " B i t t e rechte untere Hausecke angeben!" FENSTER) (NEWLINE FENSTER) (DISPLAY " I h r X - S t a r t w e r t : " FENSTER) (SET! X-START-HAUS (READ FENSTER)) ( I F (OR (NOT ( N U M B E R ? X - S T A R T - H A U S ) ) (= X-START-HAUS X-MAX)) (BEGIN (MELDUNG) • (SET! X-START-HAUS X-ERSATZ) ( D I S P L A Y " Der X - E r s a t z w e r t i s t : (DISPLAY X-ERSATZ FENSTER) (NEWLINE F E N S T E R ) ) )

(DISPLAY " I h r Y - S t a r t w e r t : " FENSTER) ( S E T ! Y-START-HAUS (READ FENSTER)) ( I F (OR (NOT ( N U M B E R ? Y - S T A R T - H A U S ) ) (= Y-START-HAUS Y-MAX)) (BEGIN (MELDUNG) (SET! Y-START-HAUS Y-ERSATZ) ( D I S P L A Y " Der Y - E r s a t z w e r t i s t : (DISPLAY Y-ERSATZ FENSTER) (NEWLINE F E N S T E R ) ) ) (NEWLINE FENSTER)

"

FENSTER)

"

FENSTER)

13. Wechsel der Abbildungsbasis

365

(DISPLAY " Bitte die Seitenlaenge angeben!" FENSTER) (NEWLINE FENSTER) (DISPLAY " I h r e S e i t e n l a e n g e : " FENSTER) ( S E T ! S E I T E N - L A E N G E - H A U S (READ FENSTER)) ( I F (OR (NOT ( N U M B E R ? S E I T E N - L A E N G E - H A U S ) ) (< S E I T E N - L A E N G E - H A U S 2) (> (+ Y-START-HAUS SEITEN-LAENGE-HAUS (/ SEITEN-LAENGE-HAUS 2 ) ) Y-MAX) (< ( - X-START-HAUS SEITEN-LAENGE-HAUS) X-MIN) ) (BEGIN (MELDUNG) (SET! SEITEN-LAENGE-HAUS (MIN (/ ( * 0 . 9 9 9 ( - Y-MAX Y - S T A R T - H A U S ) ) 1.5) ( * 0.999 ( - X-START-HAUS X - M I N ) ) ) ) ( I F (< S E I T E N - L A E N G E - H A U S 2) (BEGIN (DISPLAY " Keine s i n n v o l l e Seitenlaenge berechenbar!" FENSTER) (NEWLINE FENSTER) (DISPLAY " Es w i r d d a s S t a n d a r d h a u s gezeichnet!" FENSTER) (SET! X-START-HAUS X-ERSATZ) (SET! Y-START-HAUS Y-ERSATZ) (SET! SEITEN-LAENGE-HAUS SEITEN-LAENGE-ERSATZ)) (BEGIN (DISPLAY " D i e angenommen S e i t e n l a e n g e n i s t : " FENSTER) (DISPLAY SEITEN-LAENGE-HAUS FENSTER) (NEWLINE F E N S T E R ) ) ) ) ) (WARTEN

7)

¡Lesezeit

(WINDOW-POPUP-DELETE (LIST

;;;

ca.

7

Sekunden.

FENSTER)

X-START-HAUS Y-START-HAUS SEITEN-LAENGE-HAUS)) ) )

S t a r t w e r t e fuer das B i l d (XO-YO&LAENGE (ANTWORT)) ;; DRAW-LINE v e r l a n g t I n t e g e r - Z a h l e n . (XO ( T R U N C A T E ( L I S T - R E F X O - Y O & L A E N G E 0 ) ) ) (YO ( T R U N C A T E ( L I S T - R E F X O - Y O & L A E N G E 1 ) ) ) (LAENGE (TRUNCATE ( L I S T - R E F XO-YO&LAENGE 2 ) ) ) ) (GRAPHIK-MODUS) ( P O S I T I O N - P E N XO Y O )

366

III. Konstruktionsempfehlung Z e i c h n e n d e s H a u s e s vom N i k o l a u s ( D R A W - L I N E - T O XO ( + YO L A E N G E ) ) ¡Rechte Seitenwand (WEITER) (DRAW-LINE-TO Decke ( - XO L A E N G E ) ( + YO L A E N G E ) ) (WEITER) ( D R A W - L I N E - T O XO Y O ) D i a g o n a l e zum S t a r t p u n k t (WEITER) ( D R A W - L I N E - T O ( - XO L A E N G E ) Y O ) Grundlinie (WEITER) ( D R A W - L I N E - T O XO ( + YO L A E N G E ) ) D i a g o n a l e von l i n k s (WEITER) unten nach r e c h t s oben (DRAW-LINE-TO Rechte D a c h s e i t e ( - XO ( T R U N C A T E ( / LAENGE 2 ) ) ) ( + YO LAENGE ( + ( T R U N C A T E ( / LAENGE 2 ) ) ) ) ) (WEITER) (DRAW-LINE-TO ( - XO L A E N G E ) ( + YO L A E N G E ) ) ¡Linke Dachseite (WEITER) ( D R A W - L I N E - T O ( - XO L A E N G E ) Y O ) ¡Linke Seitenwand (WEITER) (TEXT-MODUS)))) Programm

13.5-1.

"Das

Haus

des

Nikolaus"

14. Ausblick Jeder Text von derartiger Länge und „Tiefe" verlangt ein abschließendes Wort für seinen getreuen Leser. Es wäre nicht fair, nach über 370 Seiten, die nächste aufzuschlagen und dann den Anhang zu finden. Daher zum Schluß ein kleiner Ausblick. LISP ist eine mächtige und „offene" Programmiersprache mit vielen Konzepten und Möglichkeiten. Sie haben sich einen großen Ausschnitt davon erarbeitet. Buchstabieren mit LISP-Konstrukten fällt Ihnen nicht schwer (APPLY, BEGIN, CLOSURE, DEFINE, EVAL, FALSE, GENSYM, ... , ZERO?). Sie durchschauen das Wurzelwerk von LISP: Die funktionale Wurzel mit ihrem nicht destruktiven Binden (Stichwort: Rekursion) und die imperative Wurzel mit ihrem destruktiven Zuweisen (Stichwort: Nebeneffekte). Beide zusammen führen zur objektgeprägten Konstruktion mit Klassen, Instanzen, Nachrichtenaustausch und vielfältigen Vererbungsmechanismen. Sie wissen wie Konstruktionsaufgaben zu spezifizieren und transparent zu dokumentieren sind. Was können wir in Zukunft von LISP erwarten? Oder LISPisch formuliert: Wie sieht CALL/CC für LISP aus? Eine sich konkret abzeichnende Erweiterung ist die Parallelverarbeitung (vgl. z.B. Harrison, 1989 oder Ito/Halstead, 1989).

367

14. Ausblick

Sie haben dafür einen von vielen erfolgversprechenden Ansatzpunkt kennengelernt: Das LET-Konstrukt (vgl. Halstaed, 1989). Es ist konsequent erweiterbar, wie z.B. der Dialekt QLISP (ßueue-based multiprocessing, vgl. Goldman/ Gabriel, 1988) zeigt: (QLET < p a r a l 1 e I > ( ( < v a r i a b l e _ 1 > ) ( < v a r i a b l e _ 2 > ) ( )

))

Wenn einen Wert ungleich NIL hat, dann erzeugt QLET für jedes einen Prozeß und fügt diese in die Schlange von schon bestehenden Prozessen ein, die auf ihre Ausführung warten. Diese Warteschlange wird entsprechend der bereitgestellten Hardware von mehreren Prozessoren gleichzeitig abgearbeitet. Der Ausführungsprozeß von Q L E T wartet dann so lange, bis alle von ihm erzeugten Prozesse fertig sind. Ist das der Fall, wird der QLET-Prozess wieder aktiviert, bindet die Variablen und evaluiert dann damit den . Hat den Wert NIL, verhält sich QLET wie das LET-Konstrukt. Während der Laufzeit kann man daher, z.B. abhängig vom Aufwand für das Erzeugen und Überwachen von neuen Prozessen, über die Parallelausführung entscheiden. Ein solcher „dynamischer Parallelismus" paßt nahtlos in das dynamische LISP, bei dem wir gewohnt sind, möglichst spät „Etwas" (z.B. Bindung oder Vererbung) festzulegen. Das Buch ist sicherlich (wie viele andere im Fachgebiet Informatik auch) eine Beschreibung, wie der Autor das LISP-Wissen gewonnen hat, das andere schon längst veröffentlicht haben. Trotz alledem wurde versucht, diese „Entdeckungsreise" aus eigenständiger Sicht zu zeigen. Ein Fachbuch wie dieses ist eigentlich niemals fertig: während man daran arbeitet, lernt man immer gerade genug, um seine Unzulänglichkeiten klarer zu sehen. Schließlich ist es jedoch, inclusive erkannter Unzulänglichkeiten, der Öffentlichkeit zu übergeben. Für diese Unzulänglichkeiten bitte ich Sie abschließend um Ihr Verständnis. End S e s s i o n

Anhang

A: Literaturverzeichnis /Hinweis: In der Literatur wird LISP nicht immer in Großbuchstaben geschrieben, obwohl es ein Akronym für LISI Processing ist. Die jeweilige Schreibweise ist hier beibehalten./ Abelson/Sussman/Sussman, 1985. Harold Abelson / Gerald Jay Sussman / Julie Sussman; Structure and Interpretation of Computer Programs, Cambridge, Massachusetts u.a. (The MIT Press/McGraw-Hill) 1985. Allen, 1978. John Allen; Anatomy of LISP, New York u.a. (McGraw-Hill) 1978. Allen, 1987. John R. Allen; The Death of Creativity, in: AI Expert, San Francisco 2(1987)2, p. 48 -61 Anderson u.a., 1984. John R. Anderson / Robert Farrell / Ron Sauers; Learning to Program in LISP, in: Cognitive Science, Norwood 8 (1984), pp. 87 - 129. Anderson u. a., 1987. John R. Anderson / Albert T. Corbett / Brian J. Reiser; Essential LISP, Reading, Massachusetts u.a. (Addison-Wesley) 1987. ANSI/IEEE Std. 830, 1984. American National Standard / Institute of Electrical and Electronics Engineers; Guide to Software Requirements Specifications, Standard 830, July 20, 1984. Backus, 1978. John Backus; Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs, Communications of the ACM, Vol. 21, No. 8, August 1978, pp. 613 - 641. Barr/Feigenbaum, 1982. Avron Barr / Edward A. Feigenbaum (Eds.); The Handbook of Artificial Intelligence, Volume II, Chapter VI: Programming Languages for AI, (HeurisTech Press/William Kaufmann) 1982. Beckstein, 1985. Clemens Beckstein; Integration objekt-orientierter Sprachmittel zur Wissensrepräsentation in LISP, Institut für Mathematische Maschinen

370

Anhang

und Datenverarbeitung, Friedrich-Alexander-Universität Erlagen-Niirnberg, Diplomarbeit im Fach Informatik 1985. Beichter u.a., 1981. F. Beichter / O. Buchegger / O. Herzog / N.E. Fuchs; SLAN-4, A Software Specification and Design Language, in: Floyd/Kopetz, 1981, S. 91 - 108. Belli/Bonin, 1987. Fevzi Belli / Hinrich Bonin; Qualitätsvorgaben im Hinblick auf Softwarefehler, in: M. Bartsch / D. Hildebrand (Hrsg.); Der EDV-Sachverständige, Workshop der GRVI, Schmitten 1986, Stuttgart (B.G.Teubner) 1987, S. 1 7 2 - 198. Belli/Bonin, 1989. Fevzi Belli / Hinrich Bonin; Probleme bei der Hinterlegung wissensbasierter Systeme bezüglich ihrer Dokumentation - Erstüberlegungen und Thesen - , in: D J . Hildebrand / T. Hoene (Hrsg.); Software - Hinterlegung in der Insolvenz, Workshop der DGIR, Stuttgart 1988, Stuttgart (B.G. Teubner) 1989, S. 2 9 - 5 1 . Berkeley/Bobrow, 1966. Edmund C. Berkeley / Daniel G. Bobrow (Editors); The Programming Language LISP: Its Operation and Applications, (The M.I.T. Press) 1966, First printing March 1964. Bitsch, 1989. Gerhard Bitsch; Wie man in LISP programmiert - Eine Einführung anhand von PC-Scheme 3.0, CHIP Wissen, Würzburg (Vogel Buchverlag) 1989. Bobrow, 1972. Daniel G. Bobrow; Requirements for Advanced Programming Systems for List Processing, Communications of ACM, Vol. 15, Number 7, July 1972, pp. 6 1 8 - 6 2 7 . Bobrow u.a., 1986. Daniel G. Bobrow / Kenneth Kahn / Gregor Kiczales / Larry Masinter / Mark Stefik / Frank Zdybel; Common Loops: Merging Lisp and Object-Oriented Programming, in: ACM Proceedings OOPSLA'86, SIGPLAN Notices, 21 (11) 1986, p. 17 - 29. Bobrow/Moon u.a., 1988. Daniel G. Bobrow / David Moon u.a.; Common Lisp Object System Specification, ANSI X3J13 Document 88-002R, American National Standards Institute, Washington, DC, Juni 1988 (veröffentlicht in: SIGPLAN Notices, Band 23, Special Issus, September 1988). Boehm, 1981. Barry W. Boehm; Software Engineering Economics, New Jersey 1981.

A: Literaturverzeichnis

371

Bonin, 1988. Hinrich Bonin; Die Planung komplexer Vorhaben der Verwaltungsautomation, Heidelberg (R.v.Decker & C.F. Müller) 1988 (Band 3 der Schriftenreihe „Verwaltungsinformatik"). Bonin, 1988a. Hinrich Bonin; Objekt-orientierte Programmierung mit LISP, Arbeitsbericht 1988/7 des Fachbereichs 2 (Systemanalyse) der Hochschule Bremerhaven (ISSN 0176-8158) Bonin, 1989. Hinrich Bonin; Objektorientierte Programmierung mit LISP, in: Handbuch der Modernen Datenverarbeitung (HMD), 26. Jahrgang, Heft 145, Januar 1989, S. 45 - 56. Brewka u.a., 1987. Gerhard Brewka / Franco di Primo / Eckehard Groß; BABYLON - Referenzhandbuch VI. 1/1, Institut für Angewandte Informationstechnik, Gesellschaft für Mathematik und Datenverarbeitung mbH, Bonn, 1987. Bromley/Lamson, 1987. Hank Bromley / Richard Lamson; LISP LORE: A Guide to Programming the LISP Machine, Second Edition, Boston, Dordrecht, Lancaster (Kluwer Academic Publishers) 1987. Brooks/Gabriel/Steele, 1982. Rodney A. Brooks / Richard P. Gabriel / Guy L. Steele Jr.; S-l Common Lisp Implementation, ACM LISP Conference New York, 1982, pp. 1 0 8 - 1 1 3 . Brooks/Gabriel, 1984. Rodney A. Brooks / Richard P. Gabriel; A Critique of Common Lisp, Conference record of ACM symposium on LISP and functional Programming: Proceedings Salt Lake City, Utha 1984, pp. 1 - 8. Brooks, 1987. Rodney A. Brooks; LISP - Programmieren in Common Lisp, München Wien (R. Oldenbourg Verlag) 1987 - Original 1985 "Programming in Common Lisp" (John Wiley). Bürge, 1975. William H. Bürge; Recursive Programming Techniques, Reading, Massachusetts u.a. (Addison-Wesley) 1975. Burstall u.a., 1980. R. M. Burstall / D. B. MacQueen / D. T. Sannells; HOPE: An Experimental Applicative Language, LISP Conference, Stanford/Redwood Est 1980, pp. 1 3 6 - 143. Calculemus, 1986. Firma Calculemus; Comments on TLC-LISP/86 Ver. 1.51, July 1986. Carte, 1973. James Allen Carte; Filtering Typographic Noise from Technical

372

Anhang

Literature, in: Technical Communication, Third Quarter, Vol. 20, pp. 12 - 13, 1973 (auch erschienen in: Harkins/Plung (Eds.); A Guide for Writing Better Technical Papers, New York (IEEE Press selected reprint series) 1981, pp. 1 5 4 - 155. Charniak u.a., 1987. Eugene Charniak / Christopher K. Riesbeck / Drew V. McDermott / James R. Meehan; Artificial Intelligence Programming, Second Edition, Hillsdale, New Jersey, Hove and London (Lawrence Erlbaum Associates) 1987. Clark/Green, 1977. Douglas W. Clark / C. Cordell Green; An Empirical Study of List Structure in Lisp, Communications of ACM, Vol. 20, No. 2, February 1977, pp. 7 8 - 8 7 . Claus, 1987. Volker Claus; Total unstrukturierte Programme, in: Der GMDSpiegel 4/87 (Gesellschaft für Mathematik und datenverarbeitung mbH, St. Augustin), S. 46 -50. Clinger, 1988. William Clinger; Semantics of Scheme, in: Byte, Febraury 1988, pp. 221 -227. CLOS 1988. Common LISP Object System, vgl. Bobrow / Moon u.a., 1988. Church, 1941. Alonzo Church; The Calculi of LAMBDA-Conversion; Princeton University Press, New Jersey, 1941. Curry u.a., 1958. H.B. Curry / R. Feys; Combinatory Logic, Vol. I, Studies in Logic and the Foundations of Mathematics, Amsterdam (North-Holland) 1958. Danicic, 1983. I. Danicic; Lisp Programming, Oxford London Edinburgh u.a. (Blackwell Scientific Publications), reprinted with corrections 1984. Darlington u.a., 1982. J. Darlington / P. Henderson, / D.A. Turner (Eds.); Functional programming and its applications - An advanced course, Cambridge, London u.a. (Cambridge University Press), auch als UMI Out-of-Print Books on Demand 1989. Denert, 1979. Ernst Denert; Software-Modularisierung, in: Informatik-Spektrum 2, 1979, S. 2 0 4 - 2 1 8 . DeRemer/Kron, 1976. F. L. De Remer / H. Kron; Programming-in-the-Large versus Programming-in-the-Small, in: Progammiersprachen, 4. Fachtagung der Gl, Erlangen, Informatik-Fachberichte 1, (Springer Verlag) 1976, pp. 80 - 89.

A: Literaturverzeichnis

373

Deutsch, 1978. L.P. Deutsch; Experience with Microprogrammed Interlisp System, in: Proc. 1 Ith Ann. Microprogramming Workshop, Nov. 1978, pp. 128 129. Dijkstra, 1968. Edsger W. Dijkstra; Go To Considered Harmful, in: Communications of the ACM, Volume 11 / Number 3 / March 1968, pp. 147 -148. DIN 66241, 1979. Deutsches Institut für Normung e.V.; Entscheidungstabelle Beschreibungsmittel, Berlin, Köln (Beuth Verlag). DIN 66261, 1984. Deutsches Institut für Normung e.V.; Sinnbilder nach NassiShneiderman und ihre Anwendung in Programmablaufplänen, Berlin, Köln (Beuth Verlag) DiPrimo/Christaller, 1983. Franco di Primo / Thomas Christaller; A Poor Man's Flavor System, Institut Dalle Molle ISSCO, Universite de Geneve, Working Paper No 47, May 1983. Domain, 1986. Domain/Common LISP User's Guide - A Concise Reference Manual, Order No. 008791 (Product developed by Lucid, Inc. of Menlo Park, California) 1986. Eisenbach, 1987. Susan Eisenbach (editor); Functional Programming: Languages, Tools and Architectures, Chichester (Ellis Horwood Limited) 1987. Eisenberg, 1990. Michael Eisenberg; Programming in Scheme, Cambridge, Massachusetts, London, England (MIT Press) paperback 1990 (1988 by The Scientific Press). Eggers/Zimmermann, 1984. Eggers / Zimmermann; LISP, Manuskript der Vorlesung WS 1981/82 und WS 1983/84, Technische Universität Berlin, Fachbereich Informatik. Esser/Feldmar, 1989. Rüdiger Esser / Elisabeth Feldmar; LISP - Fallbeispiele mit Anwendungen in der Künstlichen Intelligenz, Paul Schmitz (Hrsg.): „Reihe „Künstliche Intelligenz", Braunschweig Wiesbaden (Vieweg&Sohn) 1989. Felleisen/Friedman, 1986. Matthias Felleisen / Daniel P. Friedman; A Closer Look at Export and Import Statements, Computer Languages, Vol. 11, No. 1, 1986, pp. 29 - 37. FISCH, 1988. Flavor Interface to SCHeme, Konzeption und Konstruktion einer LISP-Umgebung für die objektgeprägte Modellsicht der Softwareentwicklung,

374

Anhang

Projektbericht des Projektes FLAVOR Fachbereich 2, Hochschule Bremerhaven 1988. Floyd/Kopetz, 1981. Christiane Floyd / Hermann Kopetz (Hrsg.); Software Engineering - Entwurf und Spezifikation, Stuttgart (B.G. Teubner) 1981. Foderaro/Sklower/Layer, 1983. John K. Foderaro / Keith L. Sklower / Kevin Layer; The FRANZ LISP Manual, June 1983 (University of California). Forgy, 1981. Charles L. Forgy; OPS5 User's Manual, Department of Computer Science, Carnegie-Mellon University Pittsburg, Pennsylvania 15213, 1981. Friedman, 1974. Daniel P. Friedmann; The 0-574-19165-8, Science Research Associates, 1974.

Little

LISPer,

ISBN:

Gabriel, 1985. Richard P. Gabriel; Performance and Evaluation of Lisp Systems, Cambridge, Massachusetts (The MIT Press), 1985 (Third printing 1986). Gabriel, 1988. Richard P. Gabriel; The Why of Y, in: LISP Pointers, Volume 2 Number 2 October-November-December 1988, p. 15 - 25. Gabriel/Masinter, 1982. Richard P. Gabriel / Larry M. Masinter; Performance of Lisp Systems, ACM LISP Conference New York, 1982, pp. 123 - 142. Gabriel/Pitman, 1988. Richard P. Gabriel / Kent M. Pitman; Endpaper: Technical Issues of Separation in Function Cells and Vaule Cells, in: LISP and Symbolic Computation, Vol. 1, Number 1, June 1988, pp. 81 - 101. Gnosis, 1984. Learning LISP, Engelwood Cliffs, New Jersey (Prentice-Hall) 1984 (Handbuch der Firma Gnosis zu LISP auf Apple II). Griss/Hearn, 1981. Martin L. Griss / Anthony C. Hearn; A Portable LISP Compiler, Software Practice and Experience, Vol. 11, 1981, pp. 541 - 605. Goldberg/Robson, 1983. Adele Goldberg / Dave Robson; Smalltalk-80: the language, Reading, Massachusetts u.a. (Addison-Wesley) 1983. Goldman/Gabriel, 1988. Ron Goldman / Richard P. Gabriel; Qlisp: Experience and New Directions, in: ACM/SIGPLAN PPEALS (Parallel Programming: Experience with Applications, Languages and systems) Volume 23, Number 9, September 1988, pp. I l l - 123.

A: Literaturverzeichnis

375

Gordon u.a., 1984. M. Gordon / R. Milner / C. Wadsworth / G. Cosineau / G. Huet / L. Paulson: The ML-Handbook, Version 5.1, Paris (INRIA), 1984. Gutierrez, 1982. Claudio Gutierrez; PROLOG Compared with LISP, ACM LISP Conference New York, 1982, pp. 143 - 149. Guttag, 1980. John Guttag; Notes on Type Abstraction (Version 2), IEEE Transactions on Software Engineering, Vol. SE-6, No. 1, January 1980, pp. 1 3 - 2 3 . Haesmer, 1984. Tony Hasemer; A Beginner's Guide to Lisp, Workingham, Bershire u.a.(Addison-Wesley), 1984. Hall, 1989. Patrick J. Hall; How to Solve it in LISP, Wilmslow, England (Sigma Press) 1989. Halstead, 1984. Robert H. Halstead, Jr.; Implementation of Multilisp: Lisp on a Multiprocessor, Conference record of ACM Symposium on LISP and Functional Programming: Proceedings Salt Lake City, Utha 1984, pp. 9 - 17. Halstead, 1989. Robert H. Halstead, Jr.; New Ideas in Parallel Lisp: Language Design, Implementation, and Programming Tools, in: Ito/Halstead, 1989, pp. 2-57. Hamann, 1982. Christian-Michael Hamann; Einführung in das Programmieren in LISP, Berlin New York (Walter de Gruyter) 1982. Handke, 1987. Jürgen Handke; Sprachverarbeitung mit LISP und PROLOG auf dem PC, Band 27: Programmieren von Mikrocomputern, Braunschweig, Wiesbaden (Vieweg&Sohn) 1987. Harrison, 1989. Williams Ludwell Harrison III; The Interprocedural Analysis and Automatic Parallelization of Scheme Programs, in: LISP And Symbolic Computation, Volume 2, Number 3/4, October 1989, pp. 179 - 396. Haugg/Omlor, 1987. Friedrich Haugg / Stefan Omlor; LISP auf PC's - Methoden und Techniken der Symbolischen Datenverarbeitung, München Wien (Carl Hanser Verlag) 1987. Hearn, 1969. Anthony C. Hearn; Standard LISP, in: ACM SIGPLAN Notices, Vol. 4, No. 9, 1969 (auch Technical report AIM-90, Artificial Intelligence Project, Stanford University). Henderson, 1980. Peter Henderson; FUNCTIONAL Programming - Applica-

376

Anhang

tion and Implementation, Englewood Cliffs, New Jersey (Prentice/Hall International) 1980. Hennessey, 1989. Wade L. Hennessey; COMMON LISP, New York, St.Louis San Francisco u.a. (McGraw-Hill) 1989. Henson, 1987. Martin C. Henson; Elements of Functional Languages; Computer Science Texts, Oxford, London u.a. (Blackwell Scientific) 1987. Hesse u.a., 1984. Wolfgang Hesse / Hans Keutgen / Alfred L. Luft / H. Dieter Rombach; Ein Begriffsystem für die Softwaretechnik, in: Informatik-Spektrum, Heft 7 1984, S. 200 - 223 (Arbeitskreis: "Begriffsbestimmung" der Fachgruppe „Software Engineering" im FB 2 der Gl) Hoare, 1975. C. A. R. Hoare; Recursive Data Structures, International Journal of Computer and Information Sciences, Vol. 4, No. 2, 1975, pp. 105 - 132. Hofstadter, 1983. Douglas R. Hofstadter; Metamagikum, in: Spektrum der Wissenschaft, April 1983 (S.14-19), Mai 1983 (S.13-19), Juni 1983 (S.10-13), Juli 1983 (S.6-10); Original in Scientific American 1983. Holtz, 1985. Frederick Holtz; LISP, the language of artificial intelligence (TAB Books, Inc.) 1985. Horowitz, 1984. Ellis Horowitz; Fundamentals of Programming Language, Second Edition, Berlin Heidelberg u.a. (Springer) 1984. Hughes, 1987. Sheila Hughes; TerminalBuch LISP, München Wien (R. Oldenbourg Verlag) 1987. Hußmann/Schefe/Fittschen, 1988. Michael Hußmann / Peter Scheie / Andreas Fittschen; Das LISP-Buch, Hamburg (McGraw-Hill) 1988. Ito/Halstead, 1989. Takayasu Ito / Robert H. Halstead, Jr. (Eds.); Parallel Lisp: Languages and Systems, Proceedings US/Japan Workshop on Parallel Lisp Sendai, Japan, June 5-8, 1989, Lecture Notes in Computer Science 441, Berlin Heidelberg u.a. (Springer-Verlag) 1989. Jackson, 1979. M.A. Jackson; Grundsätze des Programmentwurfs, 7. Auflage 1986, Darmstadt (Orginaltitel: Principles of Program Design; Übersetzung von R. Schaefer und G. Weber) Jones, 1982. Simon L. Peyton Jones; An Investigation of the Relative Efficien-

A: Literaturverzeichnis

377

cies of Combinatore and Lambda Expressions, LISP Conference New York 1982, pp. 1 5 0 - 158. Kaeblbling, 1988. Michael J. Kaelbling; Programming Languages Should NOT Have Comment Statements, in: SIGPLAN Notices, Vol. 23, No. 10, October 1988, pp. 59 - 60. Keene, 1989. Sonya E. Keene; Object-Oriented Programming in COMMON LISP: A Programmer's Guide to CLOS, Reading, Massachusetts u.a. (AddisonWesley) 1989. Keller, 1980. Robert M. Keller; Divide an CONCer: Data Structuring in Applicative Multiprocessing System, LISP Conference, Stanford/Redwood 1980, pp. 196 - 202. Kernighan/Plauger, 1978. B.W. Kernighan /P.J. Plauger; The Elements of Programming Style, New York (McGraw-Hill), Second Edition 1978. Kessler, 1988. Robert R. Kessler; LISP - Objects, and Symbolic Programming, Glenview, Illinois Boston London (Scott, Foresman and Compamny) 1988. Klaus/Liebscher, 1979. Georg Klaus / Heinz Liebscher (Hrsg.); Wörterbuch der Kybernetik, Frankfurt am Main (Fischer Taschenbuch Verlag), Orginal Berlin (Dietz Verlag) 1967, (4. überarbeitete Fassung 1976). Kolb, 1985. Dieter Kolb; Interlisp-D, Siemens AG, München, 17.07.85. Kreowski, 1981. H.-J. Kreowski; Algebraische Spezifikation von Softwaresystemen, in: Floyd/Kopetz, 1981, S. 46 - 74. Kruse, 1984. Robert L. Kruse; Data Structures and Program Design, Englewood Cliffs, New Jersey (Prentice/Hall International) 1984. Landin, 1964. P.J. Landin; The mechanical evaluation of expressions, in: The Computer Journal, Vol. 6, No. 4, 1964, pp. 308 - 320. Leckebusch, 1988. Johannes Leckebusch; XLisp - Die Programmiersprache der KI-Profis, München (Systhema Verlag) 1988. MacQueen/Sethi, 1982. D. B. MacQueen / Ravi Sethi; A semantic of types for applicative Languages, ACM LISP Conference New York, 1982, pp. 243 - 252.

378

Anhang

MacLennan, 1990. Bruce J. MacLennan; Functional Programming, Practice and Theory, Reading, Massachusetts (Addison-Wesley) 1990. Mandelbrot, 1977. Benoit B. Mandelbrot; Fractals: Form, Chance, and Dimension, San Franzisko (Freeman Press) 1977. Mandelbrot, 1983. Benoit B. Mandelbrot; The Fractal Geometry of Nature, New York (Freeman Press) 1983. Marti u.a., 1979. J.B. Marti / A.C. Hearn / M.L. Griss / C. Griss; Standard Lisp Report, ACM SIGPLAN Notices, Volume 14, Number 10, 1979. Mason, 1986. Ian A. Mason; The Semantics of Destructive LISP, Menlo Park (CSLI Lecture Notes Number 5) 1986. Mayer, 1988. Otto Mayer; Programmieren in Common LISP, Mannheim Wien Zürich (Bibliographisches Institut) 1988. Maurer, 1975. W. D. Maurer; The Programmer's Introduction to LISP, New York London (American Elsevier), Reissued 1975 (first 1972). McCarthy, 1960. John McCarthy; Recursive Function of Symbolic Expression and Their Computation by Machine, Part I, Comm. ACM 3,4 (April 1960),pp. 1 8 4 - 195. McCarthy u.a., 1966. John McCarthy / Paul W. Abrahams / Timothy P. Hart / Michael I. Levin; LISP 1.5 Programmer's Manual, Massachusetts (The M.I.T. Press), Second Edition , Second printing, January 1966. McCarthy, 1980. John McCarthy; LISP-Notes on Its Past and Future, Conference Record of the 1980 LISP Conference. McKay/Shapiro, 1980. Donald P. McKay / Stuart C. Shapiro; MULTI - A LISP Based Multiprocessing System, LISP Conference, Stanford/Redwood Est 1980, pp. 29 - 37. Miller, 1987. Richard K. Miller; Computers for Artificial Intelligence, A Technology Assessment and Forecast, second edition, SEAI Technical Publications (ISBN 0-89671-081-5) 1987. Minsky, 1975. M. Minsky; A Framework for Representing Knowledge, in: P.H. Winston (Ed.); The Psychology of Computer Vision, New York (McGraw-Hill) 1975.

A: Literaturverzeichnis

379

Model, 1980. Mitchell L. Model; Multiprocessing via Intercommunicating LISP Systems, LISP Conference, Stanford/Redwood 1980, pp. 188 - 195. Moon, 1986. David Moon; Object-Oriented Programming with Flavors, in: ACM Proceedings OOPSLA'86, SIGPLAN Notices, 21(11) 1986, p. 1-8. Moses, 1970. Joel Moses; The Function of FUNCTION in LISP or WHY the FUN ARG Problem Should be Called the Environment Problem, in: SIGSAM Bulletin, New York July 1970, pp. 13 - 27. Muchnick/Pleban, 1980. Steven S. Muchnick / Uwe F. Pleban; A Semantic Comparison of LISP and SCHEME, LISP Conference, Stanford/Redwood Est 1980, pp. 56 - 64. Mühlbacher, 1975. Jörg Mühlbacher; Datenstrukturen, München Wien (Carl Hanser) 1975. Müller, 1985. Dieter Müller; LISP - Eine elementare Einführung in die Programmierung nichtnumerischer Aufgaben, Mannheim Wien Zürich (Bibliographisches Institut) 1985. Narayanan/Sharkey, 1985. A. Narayanan / N. E. Sharkey; An Introduction to LISP, Chichester (Ellis Horwood) 1985. Nassi/Shneiderman, 1973. I. Nassi / B. Shneiderman; Flowchart Techniques for Structured Programming, in: SIGPLAN Notices 8 (1973) 8, p. 12- 26. Peitgen/Richter, 1986. H.-O. Peitgen / P.H. Richter; The Beauty of Fractals, Berlin Heidelberg New York (Springer Verlag) 1986. Péter, 1976. Rözsa Péter; Rekursive Funktionen in der Komputer-Theorie, Budapest (Akadémiai Kiadö) 1976. Pirsig, 1974. Robert M. Pirsig; Zen and the Art of Motorcycle Maintenance An Inquiry Into Values, Taschenbuchausgabe: Corgi Books, Deutsche Ausgabe: Zen und die Kunst ein Motorrad zu warten - Ein Versuch über Werte, übersetzt von Rudolf Hermstein, Frankfurt/Main (S.Fischer) 1976. Pitman, 1980. Kent M. Pitman; Special Forms in LISP, LISP Conference, Stanford/Redwood Est 1980, pp. 179 - 187. Pleszkun/Thazhuthaveetil,

1987. Andrew R. Pleszkun / Matthew J. Thazhutha-

380

Anhang

veetil; The Architecture of Lisp Machines, Computer, Vol. 20, No. 3, March 1987, pp. 3 5 - 4 4 . Pratt, 1979. Vaughan R. Pratt; A Mathematician's View of LISP, BYTE August 1979, pp. 162 - 168. Quayle u.a., 1984. Mary Ann Quayle / William Weil / Jeffrey Bonar / Alan Lesgolg; The Friendly Dandelion Primer, Tutoring Systems Gruop University of Pittsburgh 1984. Queinnec, 1984. Christian Queinnec; LISP, übersetzt ins Englisch von Tracy A. Lewis, London (Macmillan Publishers Ltd) 1984 (französische Orginal 1983, Eyrolles Paris). Queinnec/Chailloux, 1988. Christian Queinnec /Jérome Chailloux (Eds.); LISP Evolution and Standardization - Proceedings of the First International Workshop, 22-23 February 1988, Paris, France, Amsterdam (AFCET ISO) 1988. Rees, 1982. Jonathan A. Ross; T: A Dialect of Lisp - or, LAMBDA: The Ultimate Software Tool, LISP Conference New York, 1982, pp. 114 - 122. Rees/Clinger, 1986. Jonathan Rees / William Clinger (Editors); Revised 3 Report on the Algorithmic Language Scheme, AI Memo 848a, Artificial Intelligence Laboratory of the Massachusetts Institute of Technology, September 1986. Rogers, 1988. G.R. Rogers; COBOL-Handbuch, München Wien (R. Oldenbourg Verlag) 1988. Rome u.a., 1988. Erich Rome / Thomas Uthmann / Joachim Diederich; KIWorkstations: Überblick - Marktsituation - Entwicklungstrends, Bonn, Reading, Massachusetts u.a. (Addison-Wesley Deutschland) 1988. Sandewall, 1975. Erik Sandewall; Ideas about Management of LISP Data Bases, Int. Joint Conf. on Artificial Intelligence 1975, pp. 585 - 592. Sandewall, 1978. Erik Sandwall; Programming in an Interactive Environment: the „LISP" Experience, Computing Surveys, Vol. 10, No. 1 March 1978, pp 35-71. Schachter-Radig, 1987. Mina-Jaqueline Schachter-Radig, Entwicklungs- und Ablaufumgebungen für die Künstliche Intelligenz - Arbeitsplatzrechner für die Wissensverarbeitung, in: Informationstechnik it, 29. Jahrgang, Heft 5/1987, S. 334 - 349.

A: Literaturverzeichnis

381

Schefe, 1985. Peter Scheie; Informatik - Eine konstruktive Einführung - LISP. PROLOG und andere Konzepte der Programmierung, Mannheim Wien Zürich (Bibliographisches Institut) 1985. Schefe, 1986. Peter Schefe; Künstliche Intelligenz - Überblick und Grundlagen - Grundlegende Konzepte und Methoden zur Realisierung von Systemen der künstlichen Intelligenz, Mannheim Wien Zürich (Bibliographisches Institut) 1986. Scheid, 1985. Harald Scheid (Bearbeiter); DUDEN, Rechnen und Mathematik, 4. völlig neu bearbeitete Auflage, Mannheim Wien Zürich (Bibliographisches Institut) 1985. Schmitter, 1987. E. D. Schmitter; Praktische Einführung in LISP - LISP die Sprache der künstlichen Intelligenz, Holzkirchen (Hofacker) 1987. Schnupp/Floyd, 1979. Peter Schnupp / Christiane Floyd; Software - Programmentwicklung und Projektorganisation, 2. durchgesehene Auflage, Berlin New York (Walter de Gruyter) 1979 Schoffa, 1987. Georg Schoffa; Die Programmiersprache Lisp - Eine Einführung in die Sprache der künstlichen Intelligenz, München (Franzis) 1987. Shaw u.a., 1975. David E. Shaw /William R. Swartout / C. Cordeil Green; Inferring LISP Programs from Examples, International joint conference on artificial intelligence: Proceedings. Tbilisi, Georgia 4 (1975), pp. 260 - 267. Siklossy, 1976. Laurent Siklössy; Let's Talk Lisp, Englewood Cliffs, New Jersey (Prentice-Hall) 1976. Siemens, 1981. Siemens AG München; INTERLISP - Interaktives Programmiersystem BS2000 Benutzerhandbuch, Bestellnummer: U90015-J-Z17-1, Ausgabe September 1981, Version 4. Slade, 1987. Stephen Slade; The T Programming Language: A Dialect of LISP, Englewood Cliffs, New Jersey (Prentice-Hall, Inc.) 1987. Smith, 1988. Peter Smith; An Introduction to LISP, A Chartwell-Bratt Student Text, Lund (Studentlitteratur) 1988. Springer/Friedman, 1989. George Springer / Daniel P. Friedman; Scheme and The Art Of Programming, Cambridge, Massachusetts, London, England (MIT Press) 1989.

382

Anhang

Steele, 1976. Guy Lewis Steele Jr.; LAMBDA The Ultimate Declarative, Massachusetts Institute of Technology Artificial Intelligence Laboratory, AI Memo 379, November 1976. Steele, B., 1980. Barbara K. Steele; Strategies for Data Abstraction in LISP, LISP Conference, Stanford/redwood Est 1980, pp. 173 - 178. Steele u.a., 1984. Guy L. Steele Jr. / Scott E. Fahlman / Richard P. Gabriel / David A. Moon / Daniel L Weinreb; COMMON LISP The Language, (Digital Press) 1984. Stoyan, 1980. Herbert Stoyan; LISP - Anwendungsgebiete, Grundbegriffe, Geschichte, Berlin (Akademie-Verlag) 1980. Stoyan, 1986. Herbert Stoyan; Programmierstile und ihre Unterstützung durch sog. Expertensystem-Werkzeuge, in: Arno Schulz (Hrsg.); Die Zukunft der Informationssysteme - Lehren der 80er Jahre, Berlin Heidelberg New York u.a. (Springer-Verlag) 1986, S. 265 - 275. Stoyan u.a., 1987. Herbert Stoyan / Jerome Chailloux / John Fitch /Tim Krumnack / Eugen Neidl / Julian Padget; Towards a LISP Standard, in: Rundbrief des FA 1.2 Künstliche Intelligenz und Mustererkennung der Gesellschaft für Informatik e.V. Bonn, Nr. 44, Januar 1987. Stoyan/Görz, 1984. Herbert Stoyan / Günter Görz; LISP - Eine Einführung in die Programmierung, Berlin Heidelberg New York u.a. (Springer) 1984. Summers, 1977. Phillip D. Summers; A Methodology for LISP Program Construction from Examples, in: Journal of Association for Computing Machinery, Vol. 24, No. 1, January 1977, pp. 161 - 175. Tanimoto, 1987. Steven L. Tanimoto; The Elements Of Artificial Intelligence An Introduction Using LISP, Rockville, Maryland 1987 (Computer Science Press). Tatar, 1987. Deborah G. Tatar; A Programmers's Guide to COMMON LISP, Digital Equipment Corporation (Digital Press) 1987. Teitelman, 1975. Warren Teitelman / A. K. Hartley / J. W. Goodwin / D. C. Lewis / D. G. Bobrow / L. M. Masinter; INTERLISP Reference Manual, XEROX Palo Alto Research Center 1974, revised October 1974, revised December 1975.

A: Literaturverzeichnis

383

TLC-LISP, 1985. The Lisp Company Pob 487 Redwood Estates, CA 95044; TLC-LISP Documentation, Primer, Metaphysics and Reference Manual 1985. Touretzky, 1984. David S. Touretzky; LISP A Gentle Introduction to Symbolic Computation, New York u.a. (Harper&Row) 1984. Touretzky, 1986. David S. Touretzky; The Mathematics of Inheritance Systems, Research Notes in Artificial Intelligence, London (Pitman) 1986. Wagner, 1987. Jürgen Wagner; Einführung in die Programmiersprache LISP Ein Tutorial, Vaterstetten (IWT) 1987. Weinreb/Moon, 1981. Daniel Weinreb / David Moon; Lisp Machine Manual, Third Edition March 1981 (Massachusetts Institute of Technology, Cambridge). Weissman, 1967. Clark Weissman; LISP 1.5 Primer, Boston (PWS Publishers) 1967. Winston/Horn, 1984. Patrick Henry Winston / Berthold Klaus Paul Horn; LISP - Second Edition, Reading, Massachusetts (Addison-Wesley) 1984 (Deutsche Fassung 1987; Übersetzung von B. Gaertner u.a). Wirth, 1983. Nikiaus Wirth; Algorithmen und Datenstrukturen, Pascal-Version, 3. überarbeitete Auflage, Stuttgart (B.G. Teubner Verlag) 1983 (1. Auflage 1975). White, 1977. Jon L. White; LISP: Program Is Data - A Historical Perspective On MACLISP, Proceedings of the MACSYMA. Berkeley, Calif. 1977, pp. 1 8 0 - 189. Wong, 1985. William G. Wong; TLC-LISP - A fully featured LISP implementation, BYTE , October 1985, pp. 287 - 292. Wong, 1987. William G. Wong; PC Scheme: A Lexical LISP, MARCH 1987, BYTE, pp. 223 - 226. Yuasa/Hagiya, 1987 Taiichi Yuasa / Masami Hagiya; Introduction to Common Lisp, Boston Orland u.a. (Academic Press, Inc,), orginally published in Japanese 1986.

384

Anhang

B: L I S P - S y s t e m e

1. Einführung Unterschiedliche Probleme erfordern unterschiedliche Rechnerleistungen, kombiniert mit problemangepaßten LISP-Systemen. Ein Allzweckrechner mit einem Allzweck-LISP-System, bestehend aus LISP-Interpreter und/oder LlSP-Compiler, stellt stets ein Kompromiß dar, wobei im Einzelfall mehr oder weniger Nachteile in Kauf zu nehmen sind. Für die jeweilige LISP-Hard-/Software-Kombination bestehen zumindest vier Optimierungsaufgaben (vgl. z.B. Pleszkun/Thazhuthaveetil, 1987): o effizienter Funktionsaufruf o Verwalten der Umgebung („deep access" oder „shallow access", vgl. Abschnitt 8) o effizienter Zugriff auf Listenelemente bei ökonomischer Listenrepräsentation o Speicherplatzverwaltung („heap maintenance" mit zweckmäßigem"garbage collection") Evaluieren wir z.B.: (- FOO BAR), dann können die Werte von FOO und BAR vom Typ Integer oder Real sein, jeweils sind dann andere Operationen durchzuführen. Die Typprüfung zur Laufzeit ist möglichst effizient zu realisieren, da es in LISP-Konstruktionen nur so „wimmelt" von Funktionen. Spezielle LISPMaschinen (vgl. Abschnitt B:2) nutzen dabei Zusatzbits im Speicher („tagged memories") und prüfen damit hardwaremäßig den Typ. Der Rechner Symbolics 3600 verfügt z.B. über eine Hardware, die 34 Typen (Symbole, Listen, komplexe Zahlen etc.) unterstützt. Das einzelne Datenwort hat zusätzlich 6 „type tag"Bits, deren Auswertung gleichzeitig mit der eigentlichen Berechnung geschieht. Die klassische Listenabbildung mit CONS-Zellen aus zwei Zeigern (vgl. Abschnitte 2.1 und 5) ist nicht effizient in Bezug auf Speicherplatz und Zugriffszeit. Wenn es gilt, auf viele Listenelemente zuzugreifen, wenn wir also entlang der Liste „traversieren", dann ist die Adresse der Zelle, auf die wir als nächste zuzugreifen, in der Zelle enthalten, die gerade im Zugriff ist. Die Nachfolgeradresse kann erst an den Speicher geschickt werden, wenn der vorhergehende Zugriff abgeschlossen ist („addressing bottleneck"). Zusätzlich verbraucht diese klassische Abbildung viel Speicherplatz, da sowohl der CAR-Zeiger wie der CDR-Zeiger den gesamten Adressraum abdecken müssen und dazu entsprechend viele Bits benötigen. Dies ist nicht notwendig, wenn eine Liste kompakter abgebildet wird. Üblich sind sogenannte vektor-codierte und struktur-codierte Abbildungen.

B: LISP-Systeme

385

Das Konzept der Vektorcodierung geht zunächst von einer „linearen Liste" aus. Sie enthält keine Sublisten, d.h. keines ihrer Elemente ist wiederum eine Liste. Die einzelnen Elemente sind dann benachbart als Vektorfelder speicherbar. Ist ein Element jedoch wiederum eine Liste, dann wird dies als Ausnahme gekennzeichnet. Jedes Vektorfeld weist durch einen Zusatz („tag") aus, ob es ein Element enthält oder eine Adresse, die auf einen neuen Vektor verweist, oder unbenutzt ist oder das Ende (NIL) darstellt. Das Optimierungsproblem liegt in der fixen Länge eines Vektors (vgl. Abschnitt 6). Eine Lösung ist das sogenannte „CDR coding representation"-Schema, das LISP-Maschinen, wie z.B. der Rechner Symbolics 3600, nutzen. Hierbei verwendet man „CDR-codierte" Zellen, zusammengesetzt aus einem kleinen CDR-Teil und einem relativ großen CAR-Teil. Z.B. ist der CDR-Teil 2 Bits und der CAR-Teil 29 Bits. Die vier Möglichkeiten im CDR-Teil sind: CDR-normal, CDR-error, CDR-next und CDR-NIL. CDR-next und CDR-NIL approximieren die Vektorcodierung, CDR-normal entspricht der klassischen LISP-Zelle. Eine CDR-Codierung mit größerem CDR-Teil kann die Seitengröße der Speicherverwaltung des Betriebssystems berücksichtigen (vgl. z.B. Deutsch, 1978). Das Konzept der Strukturcodierung geht davon aus, daß in einer Zelle zusätzlich die Position innerhalb der Liste abgebildet ist. Die Listenstruktur ist als Knoteninformationen eines Baumes gespeichert. Die Listenelemente selbst sind dann als Menge von Tupeln: „Knotennummer - Wert" speicherbar. Das Suchen im Strukturbaum ist effizient gestaltbar, so daß der Zugriff auf Listenelemente im Durchschnitt wesentlich schneller als bei der klassischen Zweizeiger-Zelle ist. Welche Listenabbildung ist vorzuziehen? Vektorcodierung hat Speicherplatzvorteile, Strukturcodierung hat Zugriffsvorteile. Offensichtlich ist die Wahl davon abhängig, welche Listen und Zugriffe für das jeweilige LISP-Programm typisch sind. LISP selbst und nicht der Programmierer ist für die Speicherplatzverwaltung verantwortlich, insbesondere für die Bereitstellung (engl.: allocation) und Freigabe (engl.: deallocation) von CONS-Zellen im sogenannten „Heap"-Speicher (deutsch: Haufen). Die Freigabe im Sinne einer Speicherbereinigung (engl.: garbage collection) ist ein zweistufiges Verfahren mit „garbage"-Erkennung und „garbage"-Rückgabe. Das Ziel ist es, daß diese "garbage"-Bearbeitung keinesfalls kritische Ausführungen verzögert. Der Zeitpunkt der „garbage"-Bearbeitung und die „Heap"-Teilbereiche, die erfolgversprechend untersucht werden, sind zu optimieren (effiziente „Absterbeordnung"). Im Laufe der langen LISP-Entwicklung erzielte man wesentliche Verbesserungen bei den skizzierten Optimierungsaspekten: Funktionsaufruf, Umgebungsmanagement, Listenrepräsentation und Speicherplatzmanagement (zur Geschichte von LISP vgl. z.B. Stoyan, 1980). So ist McCarthy's LISP 7.5, quasi bis Mitte der 60iger Jahre der weltweite LISP-Standard, kaum mit LISP-Systemen, wie T oder Allegro LISP, vergleichbar. Die Ahnenreihe heutiger LISP-Systeme

386

Anhang

ist lang. Aus dem Stammvater LISP 1.5 entwickelte die Universität Stanford das LISP 1.6. Ebenfalls aus dem LISP 1.5 entstand am Artificial Intelligence Laboratory des Massachusetts Institute of Technology, Cambridge (kurz: MIT) der weit verbreitete Dialekt MacLISP. Die Universität von California, Irvine entwickelte das UCI LISP aus dem LISP 1.6. D. Bobrow und W. Teitelman integrierten in LISP eine mächtige Unterstützung des Programmierens; zunächst als BBN LISP später als InterLISP (vgl. Teitelman, 1975). Mit den LISP-Maschinen (vgl. Abschnitt B:2) entstanden zusätzlich zum MacLISP-Umfang speziell auf die Graphikfähigkeit ausgerichtete LlSP-Implementationen, z.B. ZetaLISP. Eine wesentliche Komponente von ZetaLISP ist das Flavor-System, das eine objektgeprägte Programmierung ermöglicht (vgl. Bonin, 1988a). Für die VAX-Rechner entstand aus dem MacLISP das Franz LISP, das sich auch am ZetaLISP orientierte. Mit NIL (New /mplementation of MacLisp) wurde die dynamische Bindungsstrategie durch die lexikalische ersetzt. Sie ist auch Kern für Implementationen wie z.B. Lucid (Common) LISP oder T (Scheme Implementation). In der Praxis stellt sich für jede Programmiersprache die Frage: Gibt es einen möglichst überall akzeptierten Standard? Für LISP lautet die Antwort „jein" (vgl. Queinnec/Chailloux, 1988). Es gibt eine Reihe von Bemühungen für LISP einen Standard zu definieren; zu nennen sind z.B: o Standard LISP (Stanford University, AI Projekt, vgl. Hearn, 1969, später Portable Standard LISP (PSL), vgl. Marti u.a., 1979) o Scheme (vgl. Reees/Clinger, 1986) o Common LISP (vgl. Steele u.a., 1984) o EuLISP (europäischer LISP-Standard, vgl. Stoyan u.a.,1987) In den 70iger Jahren reiften neue Konzepte, so daß die Standardbemühungen laufend überrollt wurden. Erst mit Common LISP konnten diese Verbesserungen, z.B. die lexikalische Bindungsstrategie oder generische Funktionen, im Standard integriert werden. Trotzdem bleibt Common LISP in wichtigen Punkten hinter Dialekten wie Scheme und TLC-LISP zurück. Z.B. hat Common LISP das schon bei MacLISP kritisierte Funktionen-Konzept. Seinen Funktionen fehlen die „first-class"-Eigenschaft (vgl. Abschnitt 2.2). Bei Common LISP gab man der Kompatibilität mit existierenden LISP-Dialekten besondere Priorität, um die große Menge vorhandener Anwendungssoftware leichter auf den Standard umstellen zu können. Beiden Bemühungen, ein neues (europäisches) LISP zu standardisiern, hat die Stringenz der Spezifikation vor der Kompatibilität mit vorhandenen LISPProgrammen (zunächst?) Priorität. Aus den Erfahrungen mit Common LISP hat man gelernt und spezifiziert den Standard nicht als monolithischen Block eines „großen" LISP-Systems. Die Spezifikation sieht verschiedene Leistungs-Schichten vor, z.B. (vgl. Stoyan u.a., 1987): Level 0: Ein „Pure LISP"-System im Umfange von Scheme.

B: LISP-Systeme

387

Level 1: Ein „mittleres" LISP im Umfange von PSL. Level 2: Ein „großes" LISP im Umfange von Common LISP.

2. Rechner für LISP-Systeme Wir skizzieren hier Rechner für LISP-Systeme ohne eine Bewertung in Bezug auf einzelne Aufgabenklassen (vgl. Abschnitt 12). Auch sind keine Leistungskennwerte angegeben. Dazu sei auf den LISP-speziiischen „Benchmark"Vorschlag von R. G. Gabriel verwiesen (vgl. Abschnitt 8.5; Gabriel, 1985). LISP-Systeme sind heute auf allen gebräuchlichen Rechnern verfügbar. Neben sogenannten „Symbolic Processors" (LISP-Maschinen) kann erfolgreich mit Mainframes, Workstations, Personalcomputern und Supercomputern in LISP Software konstruiert werden. Diese Rechnereinteilung in vier grobe Leistungsklassen benutzen wir, um die Entwicklung und spezielle Eigenschaften zu erörtern. Eine Kurzbeschreibung verbreiteter LISP-System enthält der anschließende Abschnitt B: 3, in dem auch auf die Rechnerklassen verwiesen wird. LISP-Maschinen

Mitte der 70iger Jahre entstand am MIT ein Processor, speziell ausgerichtet auf die Anforderungen der Symbolverarbeitung. Dieser Rechner wurde unter dem Namen „LISP-Maschine" bekannt. Das MIT vergab an die Firmen Symbolics, Inc. und an LISP Machine, Inc. die Lizenz zum Bau und Vertrieb dieses Prozessors. In Konkurrenz zum MIT-Projekt entwickelte man bei Xerox (Palo Alto Research Center, kurz: PARC) ebenfalls eine kommerziell verfügbare LISPMaschine. Im Jahre 1984 stellte Texas Instruments den „Explorer" vor, der auf den Arbeiten vom MIT (und PARC) fußt. Unter dem Begriff "Symbolic Processor" fallen auch die Ankündigungen der „SM4500" (Inference Maschine) und die „Melcom PSI machine" (Mitsubishi), die erste PROLOG-basierte Maschine. Bei den LISP-Maschinen war z.B. im Jahre 1987 Symbolics, Inc. der Marktführer (ca. 2000 Maschinen, vgl. Miller, 1987). Der Markterfolg ist vornehmlich auf die hervorragende Software-Entwicklungsumgebung zurückzuführen (vgl. z.B. Bromley/Lamson, 1987). Das Common LISP, entwickelt aus dem ursprünglichen ZetaLISP, ist durch ein leistungsfähiges FLAVOR-System ergänzt. Mit diesem ist ein dynamisches Windowsystem implementiert. Ein incrementeller Compiler erleichtert die EDIT-COMPILE-DEBUG-Abläufe. Eine Vielzahl von „Werkzeugen" aus der Disziplin „Künstliche Intelligenz (KI)" ist auf diesen LISP-Maschinen lauffähig, z.B. OPS5 (Verac), KEE (IntelliCorp) oder ART (Inference Corporation). Hervorzuheben ist die ausgezeichnete Graphik-Unterstützung, sowohl schwarz-weiß wie farbig. Der „Explorer" verfügt über Common LISP mit der FLAVOR-Erweiterung der ursprünglichen MIT LISP-Maschine. Ähnlich wie bei der Symbolics-Fami-

388

Anhang

lie sind auch für den „Explorer" der große Arbeitsspeicher (bis 16 Megabyte) und der große virtuelle Adressraum (bis 128 Megabyte) charakteristisch. Der „Explorer" läuft mit einem von Tl-implementierten UNIX System V. Netzanschlüsse zu IBM SNA und DECnet sind ebenso vorhanden wie eine hochauflösende Graphik. Die Xerox „1100-Familie" entstammt nicht direkt von der MIT LISPMaschine ab. Sie wurde parallel dazu von Xerox entwickelt. Obwohl ein Common LISP verfügbar ist, liegt der Schwerpunkt auf InterLISP-D, eine Software-Entwicklungsumgebung mit neuartiger Unterstützung für den Programmierer. Beispielsweise ist in InterLISP-D ein „Programmierassistent" integriert, der „Schreibfehler" erkennt und beim „Debugging" behilflich ist. Für die objektorientierte Programmierung gibt es (statt Flavors) Common LOOPS, eines der Ausgangssysteme für den Standard CLOS (Common LISP Object System, vgl. Abschnitt 10). Neben LISP ist PROLOG verfügbar und über den Anschluß zur VAX-Familie von Digital Equipment Corporation gibt es Schnittstellen zu FORTRAN, C und Pascal. Marktbekannte Kl-Software z.B. KEE (IntelliCorp) ist ebenso lauffähig, wie noch weniger bekannte Software, z.B. Epitool (Epitec AB, Sweden). Vom unteren Leistungsende erwächst diesen Maschinen Konkurrenz durch LISP-Prozessorkarten, die Personalcomputer zu LISP-Maschinen erweitern. Zu nennen sind hier der microExplorer von Texas Instruments und Maclvory von Symbolics. Beide erweitern den Rechner Apple Macintosh II zu einer leistungsstarken LISP-Maschine. Z.B. verfügt der Maclvory über den 40 Bit-IvoryLlSP-Chip und verwendet Symbolics Common LISP mit New Flavors, Windowsystem, Multitasking in einem Adressraum, Zmacs-Editor, Graphik-Funktionen, Netzwerk-Funktionen (incl. Zmail). Die LISP-Prozessorkarten transportieren die gelungene Software-Entwicklungsumgebung der großen LISP-Maschinen (z.B. Genera) auf Personalcomputer. Der notwendige PC-Ausbau verursacht jedoch Kosten in der Höhe einer gut ausgebauten Workstation. Mainframes

Sowohl für die IBM-Welt (LISP/VM, FRANZLISP, Le LISP etc.) als auch für die Siemens-BS2000-Welt sind leistungsfähige (Common) LISP- und InterLlSP-Systeme vorhanden (vgl. z.B. Siemens, 1981). Gravierende Nachteile gegenüber den LISP-Maschinen liegen in der geringen (oder sogar ganz fehlenden) Graphik-Unterstützung. Ihr Vorteil gegenüber diesen dezidierten Maschinen ist die problemlose Integration mit bestehenden Datenbanken und Anwendungspaketen. Trotz der leistungsfähigen Software-Entwicklungsumgebung, die z.B. InterLISP im Vergleich zu COBOL auch auf Mainframes bietet („Do What I Mean", Programmierassistent, Debugger, etc.), gibt es vergleichsweise sehr we-

B: LISP-Systeme

389

nig Implementationen. Der berechtigte Ruf, viel Kapazität des Mainframes zu benötigen, wirkt abschreckend. Workstations Hier sind mit dem Etikett „Workstation" Rechner bezeichnet, die mindestens 32 Bit Wortlänge haben und bei denen z.B. ein Betriebssystem wie UNIX (erfolgversprechend) eingesetzt werden kann (vgl. Rome u.a., 1988). Hierzu zählen z.B. (ohne Anspruch auf Vollständigkeit!): Apollo (DN4000), Data General (MV/ECLIPSE), Digital Equipment (VAX-Familie), Hewlett-Packard (HP9000), IBM (RT-Familie), NCR (Tower Familie), SUN (Sun-4/260). Für diese Rechner gibt es LISP-Systeme in großer Zahl (vgl. Abschnitt B:3). Ihr Vorteil gegenüber den dezidierten LISP-Maschinen liegt einerseits in den geringeren Einstiegskosten und andererseits in der einfachen Integration in bestehende Automationen. Im Gegensatz zu normalen, nicht mit LISP-Prozessorkarten erweiterten Personalcomputern können mit Workstations nützliche Aufgaben in LISP realisiert werden, insbesondere dann, wenn auch die Graphikoption einzusetzen ist. Personalcomputer Zur Klasse Personalcomputer sollen hier Rechner zählen, die im Regelfall mit dem Betriebssystem MS-DOS (PC-DOS) gefahren werden. Neben diesen IBM-PC/XT/AT-Rechnern gehören ebenfalls dazu die Rechner der Apple-Welt, insbesondere der MAC(intosh). Sowohl für die IBM-PCs (bzw. kompatiblen Rechner) als auch für die MACs gibt es mehrere Common LISP-Systeme, wie Abschnitt B:3 ausweist. Hauptproblem in der PC-Welt ist die Adressierbarkeit eines ausreichenden Arbeitsspeichers z.B., wenn die Intel-Chips 8088 / 8086 eingesetzt werden. Praxisrelevante Anwendungen können hier nur bedingt entwickelt und gefahren werden. Für Schulungs- und Probierzwecke sind PCs jedoch gut geeignet. Die zunehmende Verfügbarkeit von PCs mit den Mikroprozessoren vom Typ 80386 oder vom Typ MC68020 entschärft diese Restriktion. Supercomputer Für Supercomputer sind Rechner der Firma Cray ein Maßstab. Cray bietet das Cray LISP an. In Abweichung von den obigen Ausführungen soll hier doch eine

390

Anhang

Leistungsangabe erfolgen, weil Supercomputer heute ausschließlich aufgrund ihrer Rechengeschwindigkeit in Betracht kommen. Von dem Cray LISP wird berichtet (Robort J. Douglas, vgl. Miller, 1987), daß es 15 bis 30 mal schneller ist als LISP auf einer VAX 11/780 und noch 5 bis 15 mal schneller als auf einer Symbolics 3600.

3. Software In der folgenden tabellarischen Aufzählung ist für den jeweiligen Interpreter und/oder Compiler der Hersteller bzw. der Vertreiber genannt und die Rechnerklasse, für die das System (ursprünglich) konzipiert wurde. Zusätzlich sind Merkmale und Besonderheiten des Systems skizziert. Die Auswahl der Systeme ist mehr oder weniger zufällig. Berücksichtigt sind Systeme mit vielen Installationen. Die folgende Kurzübersicht erhebt keinen Anspruch auf vollständige Nennung der Marktführer. Die Systeme sind in alphabetischer Reihenfolge genannt. Allegro Common LISP Rechnerklasse: Workstation, PC Hersteller. Coral Software Corp., P.O. Box 307, Cambridge, MA 02142, USA Merkmale: Allegro Common LISP enthält eine Programmierumgebung abgestimmt auf die Macintosh-Welt. Das System ist ein inkrementeller Compiler. BYSO LISP Rechnerklasse: PC Hersteller. Levien Instrument Co., Sitlington Hill, P.O. Box 31, McDowell, VA 24458, USA. Merkmale: BYSO LISP ist an Common LISP ausgerichtet,hat jedoch starke Wurzeln im MacLISP und im klassischen LISP 1.5. Der Interpreter hat daher dynamische Bindungsstrategie. Der Compiler hat sowohl lexikalische als auch dynamische Bindung. Das CLOSURE-Konstrukt ermöglicht eine objektgeprägt Programmierung. Cambridge LISP Rechnerklasse: PC Bezugsquelle: Philgerma GmbH, Barerstraße 32, D-8000 München 2. Merkmale: Cambridge LISP basiert auf PSL (Portable Standard LISP). Exper LISP Rechnerklasse: PC Hersteller: ExpeiTelligence, Inc., 559 San Ysidro Road, Santa Barbara, CA 93108, USA. Merkmale: Exper LISP enthält eine Graphik, die unter Exper LOGO bekannt wurde. Diese Graphik ermöglicht 3D-Abbildungen. Neben ExperLISP gibt es vom gleichen Hersteller einen Common LISP Compiler. Franz LISP Rechnerklassen: Mainframe und Workstation Hersteller: Franz, Inc. 1141 Harbr Bay Parkway, Alameda, CA 94501, USA. Merkmale: Franz LISP ist ein sehr weit verbreiteter, klassischer LISP-Dialekt

B: LISP-Systeme

391

mit starker Common LISP Ähnlichkeit. Während Common LISP lexikalische Bindung hat, bindet Franz LISP dynamisch. Golden Common LISP (GC LISP) Rechnerklasse: PC Hersteller: Gold Hill Computers, Inc. 163 Harvard St., Cambridge, MA 02139, USA. Merkmale-. GC LISP 286/386 ist ein Common LISP für die PC-Welt. Mit HALO steht eine leistungsfähige Graphik-Toolbox zur Verfügung. Aufgrund des Common LISP-Umfanges ist GCLISP wesentlich größer und zum Teil nicht so schnell wie z.B. muLISP. IBUKI Common LISP Rechnerklasse: Workstation Hersteller: Ibuki Inc., 1447 N. Shoreline Blvd. Mountain View, CA 94043, USA Merkmale: Ibuki umfaßt keinen vollständigen Compiler, sondern ein Preprozessor für C Compiler. Der LISP-Code wird in C übersetzt. InterLISP-D Rechnerklasse: LISP-Maschine (Xerox) Hersteller: Xerox, Palo Alto Research Center, 3333 Coyote Hill Road, Palo Alto, California 94304, USA Merkmale: vgl. Abschnitt B:2 IQ-LISP / IQ-CLISP Rechnerklasse: PC Hersteller: Integral Quality, Inc. P.O. Box 31970, Seattle, WA 98103-0070, USA. Merkmale: IQ-LISP ist ähnlich zu UCI LISP, einem Dialekt von MacLISP. IQLISP unterstützt den 8087 Arithmetikprozessor. IQ-CLISP ist die Common LISP Version. Es verfügt über ein einfaches Window-System. Kyoto Common LISP Rechnerklasse: Workstation Hersteller: Kyoto Common LISP (KCL) wurde am „Research Institute for Mathematical Sciences, Kyoto University, Japan" entwickelt. Merkmale: KCL ist ein vollständiges Common LISP. Es hat bei geladenem Interpreter und Compiler einen Bedarf von 1.4 Megabyte Arbeitsspeicher. Der Kern von KCL ist in C geschrieben. KCL hat einen zweistufigen Compiler. Zunächst wird nach C umgesetzt und dann von C in den compilierten Code. Siemens vertreibt KCL für ihre MX-Serie. Le LISP Rechnerklassen: Mainframe (IBM unter VM/UTS), Workstation,PC Hersteller: Le LISP wurde im Europäischen KI-Zentrum INRIA, Frankreich entwickelt. Die Portierung auf PCs erfolgte durch Act Informatique. Merkmale: Eine große Untermenge von Common LISP ist abgedeckt. Das Konzept der virtuellen Maschine erleichtert eine Portierung zwischen den Rechnerklassen. Le LISP enthält ein Paket-Konzept, Stringverarbeitung, Vektoren und Konstrukte für nicht-lokale Kontrollstrukturen.

392

Anhang

Lucid Common LISP Rechnerklasse: Workstation Hersteller: Lucid, Inc. 707 Laurel Street, Menlo Park, CA 94025, USA. Merkmale: Lucid Common LISP ist eine Entwicklungsumgebung für den professionellen Produktionseinsatz. Neben dem vollen Common LISP Sprachumfang sind EMACS-Stil-Editor, Window-System und ein Flavor-System vorhanden. Dieses Produkt ist auch unter dem Namen des Workstation-Herstellers bekannt (vgl. z.B. für Apollo Computer DOMAIN, 1986). muLlSP Rechnerklasse: PC Hersteller: Soft Warehouse, Inc. POB 11174, Honolulu, Hawaii 96828; Microsoft, Inc. 10700 Northrup Way, Bellevue, WA 98004, USA. Merkmale: muLISP deckt ca. 400 der ca. 800 Common LISP Konstrukte ab. MuLISP hat den Ruf besonders schnell zu sein und wenig Speicherplatz zu benötigen. Aufgrund der Pseudocode-Compilation ist der Speicherbedarf relativ gering. Nil's LISP Rechnerklasse: PC Hersteller: A. Fittschen, Weusthoffstraße 6, D-2100 Hamburg 90. Merkmale: Nil's LISP basiert primär auf TLC-LISP und enthält Komponenten von UCI LISP. Ein Flavor-System ist verfügbar. Nil's LISP wird an der Universität Hamburg eingesetzt. PSL Rechnerklasse: Workstation Hersteller: University of Utah, Computer Science Department, Salt Lake City, UT 84112, USA. Merkmale: Versuch eines LISP-Standards vor dem Common LISP Standard. Starker Einfluß von FranzLISP und MacLISP. PC Scheme Rechnerklasse: PCs: MS-DOS Rechner Hersteller: Texas Instruments, Dallas, USA. (Bezugsquelle: The Knowledge Base, Hochberg la, D-8404 Wörth/Donau) Merkmale: Ein modernes (gestrafftes) LISP mit lexikalischer Bindungsstrategie (vgl. Abschnitt C). Unterstützt wird die objekt-orientierte Programmierung durch SCOOPS. Scheme wurde von Gerald Jay Sussman und Guy Lewis Steele Jr. am MIT für Experimentierzwecke mit Programmierparadigmen entworfen. Scheme verzichtet auf Kompatibilität mit klassischen LISP-Konzepten zugunsten eines klaren Konzeptes. Die Portierung von Common LISP Programmen ist im Regelfall unproblematisch. Power LISP Rechnerklasse: PC Hersteller: MicroProducts, Inc. 370W. Camino Gardens Boulevard, Boca Raton, Florida 33432, USA. Merkmale: Vollständige Implemetation von Interlisp (vgl. Teitelman, 1975). Enthält CLISP („conversational LISP"), das laut Hersteller eine LISP-Syntax ermöglicht, die mehr an konventionelle Programmiersprachen angepaßt ist.

B: LISP-Systeme

393

SoftWave LISP Rechnerklasse' PC Hersteller: SoftWave, Seattle, WA 98103-1607, USA Merkmale: Einfacher LISP-Interpreter, der sich am LISP 1.5 orientiert. Nur für Schulungszwecke geeignet. T Rechnerklasse: Workstation Hersteller. T Project, Yale Department of Computer Science, Box 2158, New Häven, CT 06520, USA Merkmale: T ist eine Scheme Implementation, wobei Scheme eine Untermenge von T bildet. T hat objektgeprägte Konstrukte und Makros eingebaut, verfügt über einen „optimierten" Compiler und unterstützt insbesondere die Fehlersuche (vgl. Slade, 1987). TLC-LISP Rechnerklasse: PC Hersteller: The LISP Company, Redwood Estates, CA 95044, USA (Bezugsquelle (mit Lieferproblemen): Calculemus (M. Voltenauer-Lagemann), Hans-Graessel-Weg 1, D-8000 München 70) Merkmale: TLC-LISP zeichnet sich durch eine klare Grundkonzeption aus, die die Realisierung von „first class"-Objekten zum Ziel hat. Es weicht daher in einigen Punkten von Common LISP ab. Versucht wird das ZetaLISP für PCs verfügbar zu machen. Integriert sind daher ein Klassensystem und ein PaketKonzept. Zusätzlich enthält TLC-LISP die von LOGO aus bekannte „Turtle Graphik" (vgl. Abschnitt 13.1). Der Lieferumfang umfaßt auch den Compiler und Interpreter in LISP-Quellecode. UC1LISP Rechnerklasse: PC (ursprünglich für PDP-10 entwickelt) Bezugsquelle: H. Peters, Eielkampsweg 50, D-2083 Halstenbeck. Merkmale: Eine Implementation des UCI LISP (vgl. Abschnitt B:l) für PCs in vollem Umfang der ursprünglichen PDP-10-Version. XLISP Rechnerklasse: PC Hersteller: David Betz, Public Domain Programm Merkmale: XLISP integriert Konzepte von Scheme und Common LISP (vgl. z.B. Leckebusch, 1988). Es enthält Konstrukte für die objekt-orientierte Programmierung. Eine Programmierumgebung fehlt bisher. ZetaLISP Rechnerklasse: LISP-Maschine Hersteller: Hersteller der jeweiligen LISP Maschine, Grundlage bildet die MIT LISP Maschine (vgl. Abschnitt B:2). Merkmale: Flavor-Konzept (vgl. Abschnitt 10)

394

Anhang

C: PC Scheme Übersicht Systemarchitektur:

Legende:

[1] Beim Aufruf von PCS wird die Datei SCHEME.INI evaluiert. [2] Bestehen noch nicht gesicherte Modifikationen des EDWIN-Puffers, dann ist die Sicherung nachholbar. [3] Mit DOS-CALL sind MS-DOS-Kommandos ausführbar. Das Beispiel zeigt den Einsatz des Editors WordStar. [4] (EDWIN) ruft einen Scheme Texteditor auf. Enthält der Puffer Eintragungen, dann werden diese zum Bearbeiten angezeigt. [5] Mit dem Drücken der Tasten Esc und danach Buchstaben O wird der gesamte Puffer evaluiert und nach Scheme verzweigt. [6] Tastenfolge Esc dann Ctrl und zusätzlich X bewirkt: Der nächste symbolische Ausdruck betrachtet von der aktuellen Cursorposition aus, d.h. häufig von „(" bis zur korrespondierenden „)", wird evaluiert und nach Scheme verzweigt. [7] Tastenfolge Ctrl und zusätzlich X danach Ctrl und zusätzlich S [für save] sichert den Puffer in einer Datei, deren Name EDWIN abfragt. [8] Tastenfolge Ctrl und zusätzlich X danach Ctrl und zusätzlich V [für visit file] liest eine Datei in den Puffer, deren Name EDWIN abfragt. [9] Einige EDWIN-Kommandos: Esc dann < ==> Cursor auf Anfang des Puffers setzen Esc dann > ==> Cursor auf Ende des Puffers setzen

C: PC Scheme Übersicht

395

Esc dann Ctrl und F ==> Cursor auf nächsten symbol. Ausdruck Esc dann Ctrl und B ==> Cursor einen symbol. Ausdruck zurück Ctrl und K ==> löscht Zeile Ctrl und Y ==> fügt aktuell Gelöschtes an Curs.Position ein Ctrl und X und / ==> teilt Bildschirm in EDWIN und Scheme oder hebt Teilung auf [10] Scheme-Konstrukte (nächster Abschnitt). Eingabekorrektur mit Ins, Del, , da letzte Eingabe im Puffer steht. [11] Tastenfolge Ctrl und Q führt zum Verlassen der Testhilfe Ausgewählte Scheme-Konstrukte: Darstellung der Konstrukte anhand von Beispielen in der verkürzten Notation: statt: eval> ==> ;Kommentar (vgl. Abschnitt 1.2) kurz: ==> ;Kommentar Konstruktoren: (CONS 'PROGRAMMIEREN ' ( I S T

SCHWIERIG)) ==> (PROGRAMMIEREN IST SCHWIERIG) ( L I S T (* 2 3) 7 (+ 4 4) 9) ==> (6 7 8 9) (APPEND ' ( A B) ' ( C D ) ) ==> (A B C D) b i n d e t F00 an den Wert 5 (DEFINE F00 ( + 2 3 ) ) ==> F00 (LAMBOA (X Y) ( - X Y ) ) ==> # anonyme F u n k t i o n F u n k t i o n s a p p l i k a t i on ((LAMBDA (X Y) ( - X Y ) ) 3 2) ==> 1 l o k a l e V a r i a b l e n X und Y (LET ( ( X 3) (Y 2 ) ) ( - X Y ) ) ==> 1 l o k a l e V a r i a b l e n X und Y (LET* ( ( X 2) (Y (* 3 X ) ) ) (+ X Y ) ) s e q u e n t i e l l gebunden. ==> 8 ; ; R e k u r s i v e r Bezug auf l o k a l e V a r i a b l e F00 (LETREC C C F00 (LAMBDA ( L ) (COND ((NULL? 1) 0) (T (+ 1 (F00 (CDR L ) ) ) ) ) ) ) ) (F00 ' ( A B ) ) ) ==> 2 (DEFINE KARL (LAMBDA (X Y) (* ( - X 4) Y ) ) ) ==> KARL (DEFINE (KARL X Y) (* ( - X 4) Y ) ) ==> KARL ¡ k ü r z e r e S c h r e i b w e i s e (KARL 2 3) ==> -6 (PUTPROP 'MARX "Berühmter Mann" 'DOKU) ==> "Berühmter Mann" (GETPROP 'MARX 'DOKU) ==> "Berühmter Mann" (DEFINE-STRUCTURE KONTO (NUMMER 0) (STAND 5 0 . 2 3 )

INHABER) ==> KONTO (DEFINE K l (MAKE-KONTO 'NUMMER 1 'INHABER 'OTTO)) ==> K l (KONTO-INHABER K l ) ==> OTTO ( S E T ! (KONTO-INHABER K l ) " W i l l i " ) ==> # (KONTO-INHABER K l ) ==> " W i l l i "

Selektoren und Mutatoren: (DEFINE MOTTO ' ( L I S P MACHT FREUDE)) ==> MOTTO (DEFINE MEIN-SYMBOL MOTTO) ==> MEIN-SYMBOL (CAR MOTTO) ==> L I S P (CDR MOTTO) ==> (MACHT FREUDE) (SET-CAR! MOTTO 'LERNEN) ==> (LERNEN MACHT FREUDE) MEIN-SYMBOL ==> (LERNEN MACHT FREUDE) ; N e b e n e f f e k t ! ! (SET-CDR! MOTTO ' ( I S T MÜHSAM)) ==> ( I S T MÜHSAM) MEIN-SYMBOL ==> (LERNEN IST MÜHSAM) ;Nebeneffekt!!

396 Prädikate

Anhang

und

Fallunterscheidung:

(DEFINE FOO *A) ==> F00 (DEFINE BAZ FOO) ==> BAZ (EQ? BAZ FOO) ==> #T ¡benennen dasselbe "Objekt" (EQ? '(A B) '(A B)) ==> () ¡leere Liste steht für "false" (EQ? (CONS 'A -B) (CONS 'A 'B)) ==> () ¡verschiedene C O N S - Z e l l e n (EQUAL? (CONS 'A 'B) (CONS A 'B)) ==> #T ¡vgl. A b s c h n i t t 2.1 (ZERO? (- 2 2)) ==> #T ¡prüft numerisch 0 (NULL? '()) ==> #T ¡prüft auf leere Liste, entspricht NOT (NOT (+ 2 3)) ==> () ¡Alles ungleich () ist wahr (NUMBER? (+ 3 4)) ==> #T (MEMBER? 'B '(A B C)) ==> (B C) benutzt EQUAL? (MEMQ (LIST 'B) '(A (B) C)) ==> () benutzt EQ? (PROC? (LAMBDA (X) (* X X))) ==> #T prüft ob Funktion Für Zahlen: < >- EVEN? ODD? (DEFINE A N Z A H L (LAMBDA (L) (COND ((NULL? L) 0) (T (+ 1 (ANZAHL (CDR L)))) ))) ==> A N Z A H L (ANZAHL '(ER SIE ES)) ==> 3 (AND 1 2 3) ==> 3 (AND 0 NIL (/ 1 0)) ==> () (OR NIL 2 (/ 1 0)) ==> 2

Sequenz und

¡1. Klausel ¡2. Klausel

"true", da ungleich () A b b r u c h nach NIL-Erkennung A b b r u c h nach (NOT NIL)

Iteration:

(DEFINE FOO (BEGIN '(A B) '(- 3 4) ( + 2 3))) ==> FOO FOO ==> 5 ¡BEGIN gibt letzten Wert (DEFINE FOO (BEGINO '(A B) '(- 3 4) (+ 2 3))) ==> FOO FOO ==> (A B) ¡BEGINO gibt ersten Wert

zurück zurück

(MAP ) ==> ¡wendet die Funktion auf jedes ; Element der Liste an und gibt die Ergebnisse als Liste aus. (MAP (LAMBDA (X) (+ 2 X)) '(1 2 3)) ==> (3 4 5) (DO (( < a n f a n g s w e r t > ) ... ) ( ... ) ¡Abbruchklausel ) ==> < v a l u e - s e x p r _ n > (DO ((I 1 (+ I 1))) ((> I 5) I) (DISPLAY " ") (DISPLAY I)) ==> 1 2 3 4 56

Input-/Output-Interface: (DEFINE M E I N E - A U S G A B E

(OPEN-OUTPUT-FILE

"C:\\TI\\SCHROTT.LSP")) ==> M E I N E - A U S G A B E (WRITE 'DI ES -1 ST-SEXPR-1 M E I N E - A U S G A B E ) ==> # < P 0 R T > (NEWLINE M E I N E - A U S G A B E ) ==> # < P 0 R T > (WRITE 'DI E S - I S T - S E X P R - 2 M E I N E - A U S G A B E ) ==> # < P 0 R T > ( C L O S E - O U T P U T - P O R T M E I N E - A U S G A B E ) ==> # (WRITELN (* 2 3) " ist mehr als" (- 7 2))==> ;Zei1envorschub 6"ist mehr als"5 () ¡Rückgabewert (DISPLAY "Mein Wert") ==> Mein Wert ¡ohne doppeltes Hochkomma (PRINT "Mein Wert") ==> ¡mit Vorschub und d o p p e l t e m Hochkomma "Mein Wert" () (PP ) ==> ... ¡Pretty Print von < v a l u e - s e x p r >

397

C: PC Scheme Übersicht (DEFINE MEINE-EINGABE

(OPEN-INPUT-FILE

"C:WTIWSCHROTT.LSP")) ==> MEINE-EINGABE (READ M E I N E - E I N G A B E ) ==> D I E S - I S T - S E X P R - 1 ( R E A D M E I N E - E I N G A B E ) = = > DI ES -1 S T - S E X P R - 2 (READ M E I N E - E I N G A B E ) ==> # ! E O F ;End of f i l e (CLOSE-INPUT-PORT MEINE-EINGABE) ==> # (PORT? 'CONSOLE) ==> #T ¡ T a s t a t u r / B i l d s c h i r m sind D e f a u l t - P o r t (READ-CHAR) ==> (READ-ATOM) ==> ( R E A D - L I N E ) = = > < z e i 1 e - v o n - t a s t a t u r > ; R ü c k g a b e w e r t ist S t r i n g (DEFINE M E I N - F E N S T E R (MAKE-WINDOW "Otto" #T)) ==> MEIN-FENSTER ;mit Label " O t t o " u n d R a n d ( W I N D O W - S E T - P O S I T I O N ! M E I N - F E N S T E R 2 3) ==> # ¡ l i n k e o b e r e E c k e in Z e i l e 2 u n d S p a l t e 3 ( W I N D O W - G E T - P O S I T I O N ! M E I N - F E N S T E R ) = = > (2 . 3) ( W I N D O W - S E T - S I Z E ! M E I N - F E N S T E R 10 4 0 ) ==> # ¡ G r ö ß e 10 Z e i l e n u n d 40 S p a l t e n p r o Z e i l e ( W I N D O W - G E T - S I Z E M E I N - F E N S T E R ) = = > (10 . 4 0 ) (WINDOW-CLEAR MEIN-FENSTER) ==> # ( W I N D O W - S E T - C U R S O R ! M E I N - F E N S T E R 6 12) ==> # ¡ s e t z t C u r s o r a u f Z e i l e 6 u n d S p a l t e 12 ( W I N D O W - G E T - C U R S O R M E I N - F E N S T E R ) = = > (6 . 12) (WINDOW-POPUP MEIN-FENSTER) = = > # < P 0 R T > ¡ s i c h e r t ü b e r d e c k t e D a t e n & g i b t M E I N - F E N S T E R aus (WINDOW-POPUP-DELETE MEIN-FENSTER) = = > # < P 0 R T > ¡ l ö s c h t M E I N - F E N S T E R und s t e l l t d e n l e t z t e n ; Z u s t a n d w i e d e r her (WINDOW? MEIN-FENSTER) ==> #T

Graphik'. Hinweis: Farben und Auflösung systemabhängig (CGA / EGA / VGA) [CGA ::= -160 () ¡ X - W E R T / Y - W E R T geben rechte obere Ecke an, Cursor ; stellt linke U n t e r e Ecke dar ( D R A W - F I L L E D - B O X - T O X - W E R T Y - W E R T ) = = > () ¡ z e i c h n e t S c h r a f f u r b o x ( D R A W - L I N E - T O X - W E R T Y - W E R T ) = = > () ¡vom C u r s o r z u m X - W E R T / Y - W E R T ( D R A W - P O I N T X - W E R T Y - W E R T ) = = > () ¡zeichnet Punkt (IS-POINT-ON? X-WERT Y-WERT) ==> #T ¡falls dort g e m a l t wurde ( P O S I T I O N - P E N X - W E R T Y - W E R T ) = = > () ¡ p o s i t i o n i e r t C u r s o r ( G E T - P E N - P O S I T I O N ) = = > (12 . 23) ¡(X-WERT . Y-WERT) ( S E T - P A L E T T E ! 0 2) = = > () ¡0 ::= V o r d e r g r u n d 2 ::= F a r b e ; Hintergrund wäre 1 ( S E T - P E N - C O L O R ! 2) = = > 2 ¡ F a r b e g e s e t z t , rot (GET-PEN-COLOR) ==> 2

398

Anhang

D: Schlagwörter A-Liste 143 Abarbeitungsaufwand 295 Abbruch-Bedingung 71 Ablaufsteuerung 46 abstrakter Datentyp 258 Abstraktion 219,288 Abstraktionsmittel 109 ACCESS 26,214 ACTIVE 274 Adressat 306 AFFIX-Empfehlungen 311 after daemon 297 Aktionsteil 58 Akumulator 75 ALGOL 239 Algorithmus 13 ALIAS-Name 318 Aliasname 30 ALL-CLASSVARS 296 ALL-METHODS 296 Allegro Common LISP 390 allocation 385 Alternative 11 AND 34,63 anonyme Funktion 22 APPEND 98 Applikation 19,21,211 APPLY 23 Arbeits technik 331 Argument 17, 20, 23 array 167 ASCII 235 ASCII->SYMBOL 235 Assembler 233 assignment 29 ASSOC 143 Assoziation 12,26 ASSQ 143 ASSV 143 Attribut 141,240 Aufgabenart 331 Aufgabengröße 331 Ausgeglichenheit: 173 Ausrufezeichen 25 Auswertungsblocker 14 AVL-Baum 173 A*-Verfahren 159

Backus-Naur-Form 47 balanced tree 173 BAR 27 Bauart 105 Baukasten-Konstruktionsprinzip 303, 308 Baumstruktur 92,94 Baustein 19 BAZ 27 BBN LISP 386 Bedienungskomplexität 335 Bedingte Schleife 71 Bedingungsteil 58 before daemon 297 BEGIN 55 BEGIN0 57 begrenzte ET 59 Begriffslexikon 323 Benchmark 387 Benennung 22 Benennungsoperator 12 Benutzerfreundlichkeit 335 Berechnungszeitpunkt 76 binary predicate 62 Binärbaum 94 Bindung 29,53 Bindungsstrategie 212 Blank 188 BNF-Metasprach-Gleichheit 47 bottom up approach 298 bottom-element 216 47 Buchungsprogramm 14 BYSO LISP 390 C...R 39 C++ 109 CADR 39 CALL-WITH-CURRENT-CONTINUATION 213,227 CALL/CC 227 Cambridge LISP 390 CAND 63 CAR 39, 48, 214 CASE 65,360 CDDDR 39

D: Schlagwörter CDR 39, 48, 214 CDR-Codierung 385 CGA 345 CGA-Modus 344 CHAR=? 189 CHAR? 188 character 4, 9, 188 CLASS COMPILED 284 CLASS INHERITED 285 class precedence list 288 CLASS-OF-OBJECT 278 CLASS? 277 CLASSVARS 274,296 CLOS 271,274,282,292,388 closure 30,212 CLOSURE-Konzept 30 COBOL 2, 13, 109, 258-259 Common LISP 3, 17, 22, 127, 320, 386 Common LISP Object System 271 Common LOOPS 271 compiler 251 COND 37, 48, 65 CONS 40,48 CONS-Zelle 42,384 continuation 227 control structure 45 COPY 140,245 COR 63 Cray 389 Ctrl 394 Curryfizieren 220 currying 221 Cursor 344 Datenlexikon 141 Datenreprasentation 344 Datenstruktur 258 DE 22 deallocation 385 decision table 58 deep access 212 default value 142, 261 DEFINE 12, 22-24, 26, 48 DEFINE-CLASS 274 DEFINE-INTEGRABLE 262 DEFINE-METHOD 274-275 DEFINE-STRUCTURE 261,344, 353 Definionsmenge 46 Definitionsumgebung 215

399 DEFSTRUCT 261 DEFUN 22,320 deklarative Methodenkombination 274 DELQ! 151 Denkrahmen 258,260 depth-first search 153 Destruktive Konstrukt 25 DIN66261 11,71 Diskriminator 43 dispatch function 354 dispatch procedure 344 DO 66-67, 107 Documentation string 320 Dokumentation 303, 305, 308 Dokumentationsrichtlinie 324 Dokumentationsstrategie 305 Dokumentnummer 325 dotted pair 40, 143 downward funarg 31 Do What I Mean 388 DRAW-LINE-TO 344-345 Durchschaubarkeit 335 dynamische Vererbung 269, 282 dynamische Bindung 31 EDWIN 6,394 Effizienz 251,280 EGA 344 Eigenschaftsliste 145, 147, 314 Eindeutigkeit 323 einfache Fall 86 einfache Vererbung 290 Eingabe-Schnittstelle 16 Einkapselung 280 Eintreffer-ET 59 elementare Konstrukte 108 Embryonal-Fall 85 encapsulation 280 Entscheidungstabelle 58 Entwicklungsfähigkeit 34 ENVIRONMENT-BINDINGS 224 ENVIRONMENT-PARENT 237, 244 EQ? 41-42, 129 EQUAL? 41-42 Ergonomie 335 Erkennungskonstrukt 113 Ersatzwert 142 Esc 394 ET 58, 62, 78-79, 91-92

400 EuLISP 386 EVAL 8, 15, 19, 26, 48 EVAL-Regel 1 9 EVAL-Regel 2 10 EVAL-Regel 3 11 EVAL-Regel 4 12 evaluation function 159 Evolutions-Konzept 333 EXPAND-MACRO 52, 69, 234, 236, 262, 266 EXPAND-MACRO-1 283 Exper LISP 390 EXPLODE 196 Explorer 387 Faktorisierung 284, 293, 296-297 Fallunterscheidung 37,396 Feld 267 Feldwert 261,267 Fernwirkung 280 First-class-Objekt 49 Fixpunktoperator 219 Flavor 109,271 Flavor-System 288 Flexibilität 335 flow of control 46 Fluchtsymbol 195,317 fluid binding 31 FOO 27 FOR 66 FOR-EACH 74 form 20 formaleParameter 18 FORTRAN 109 FP 212 Fragezeichen 43, 186 Fraktale 360 Fraktalfigur 360 Fraktallinie 361 Franz LISP 386, 390 FUNARG-Problem 30,31 Funktion 10,219 Funktion höherer Ordnung 74, 354 Funktionale Anforderung 333 Funktionsapplikation 311 Funktionsdefinition 22 Funktionsgeprägte Konstruktion 310 Funktionsname 312-313 Funktionsobjekt 21

Anhang garbage 49 garbage collection 384, 385 GENSYM 203 GETCV 296 GETPROP 147 GETTABLE-VARIABLES 275 Gleichheit 41, 143 Gleitkommazahl 41 Glossary 323 GO 112 Golden Common LISP 391 Graphik 397 Graphikmodus 344 Groß/Kleinschreibung 316 Grundprozedur 344 Handhabbarkeit 324,335 Heap 385 heap maintenance 384 Hierarchie von Konstrukten 44 higher-order function 74,213 HOPE 212 IBUKI Common LISP 391 Identifier 325 Identität 41, 143 IF 11,37 IMPLODE 196 Imperativgeprägte Konstruktion 310 imperativgeprägte Paradigma 258 Implementation 18,212 INCLUDE 265,269 infinite Sequenz 129 Initialisierungswert 276 INITTABLE-VARIABLES 275 Input-/Output-Interface 396 INSPECT 394 INSTANCE? 278 Instanzvariable 285 Instrument 331 INSTVARS 274 interface 337 InterLISP 386 InterLISP-D 391 Internmachen 202 IPL 2 IQ-CLISP 391 Irrelevanz-Zeichen 60

401

D: Schlagwörter Iteration

46, 67, 71, 73, 396

Jackson-Notation 50,67 Julia-Menge 360 Klammernzählen 6 Klassen-Instanz-Modell 271 Klassentyp 288 Klassenvariable 285 Kleinbuchstaben 195 Komfort 335 Komma 234 Kommentar 47,321 Kommentarzeile 307,319 Kommunikation 1,273 Komponenten-Flavor 291 Komposition 46, 109, 212, 226 Konsistenz 323 Konstante 15 Konstituenten 105 Konstrukt 18-19 Konstruktion 33, 41, 105, 305 Konstruktions-Dokumentation 305 Konstruktions-Prozeßdokumentation 305 Konstruktionsaspekte 34 konstruktionsbedingter Aspekt 309 Konstruktionsgröße 332-333 Konstruktions Vorschrift 105 Konstruktor 40,110,395 Kontrollstruktur 226 KoopA-ADV-Rahmenrichtlinien 308 Koordinatensystem 345 Kyoto Common LISP 391 LAMBDA 26, 48, 52, 56, 86, 175 LAMBDA-Abstraktion 311 LAMBDA-Variable 20, 22, 53 Lebenszyklus 34, 45, 330 Lesbarkeit 316 LET 52 LETREC 55,218 LET* 54 lexikalische Bindung 31,215,386 Lexikon 314-315 Le LISP 391 LIFO-Prinzip 58 Linguistik 105

LISP 1.5 385 LISP 1.6 386 LISP-Dialekte 3 LISP-Maschine 387 LlSP-Prozessorkarte 388 LIST 28,48 LIST->VECTOR 168 LIST-REF 96, 142 Liste 4 , 4 1 , 1 2 3 47 Literalatom 4 LOC 334 local precedence order 292 local slot 285 LOGO 345 LOOP 112 • Lucid Common LISP 392 Maclvory 388 MacLISP 320,386 MACRO 235,283 Mainframe 387-388 MAKE- 261 MAKE-INSTANCE 274-275 MAKE-STRING 192 MAKE-VECTOR 168 Makro 52, 233-234, 245, 261, 314, 348 Mannjahre 334 MAP 72,74 MAPCON 74 MAPLIST 74 mapping function 72 match variable 185, 195 Mehrfachverwendbarkeit 308 Mehrtreffer-ET 325 MEMBER-OF-CLASS? 278 message handling 274 message passing 279 Meta-Klasse 288 Methode 331 methods 273,296 microExplorer 388 MIT 2,386 MIXINS 274, 284, 291 MJ 334 ML 109,212 mnemotechnischer Aspekt 309 Modifizierbarkeit 323 Modul 45,337 Modularisierung 45,50

402

Anhang

muLISP 392 multiple values 17 multiple Vererbung 269, 288 Multiplizität 124, 145 Mustervariable 195 Mustervergleich 188, 195 Mutator 110,127,395 Nachfolgeknoten 282 Nachricht 273 Nachrichtenübermittlung 273 name 309-310 NAME->CLASS 296 Namenslänge 311 Namensraum 239 Nassi/Shneiderman 11, 71, 90, 344 Nebeneffekt 17-18, 149 Negation 63 New Flavors 293 NichtUnterscheidbarkeit 41 NIL 4, 37, 42, 386 NIL-Zeiger 128 Nil's LISP 392 nonterminal symbols 47 nonterminals 47 NOT 63 Notation 8 NTH 96 NULL? 63, 85, 216 47 Nutzungsflexibilität 335 Oberklasse 269 Objekt 49, 142 Objektgeprägte Konstruktion one-based 96 Operanden 36 Operatoren 36 OPS5 304 Optimierungsaufgabe 384 OPTIONS 274,276 OR 63 Orientierungspunkte 36 # 20 P-Liste 147 PAIR? 215 Paket 239 Paradigma 107, 258, 309

Parallelverarbeitung 366 PARC 387 Pascal 109 pattern matching 185 PC Scheme 392 PCS *PRIMOP-HANDLER 262 pending class 285 Personalcomputer 387,389 Pflichtenheft 308 Portable Standard LISP 386 POSITION-PEN-Konstrukt 345 Power LISP 392 PP-Konstrukt 317 Prädikat 41,110,263,396 Präfix-Notation 10,21 Precompiler 185 Pretty-Print 317 primary method 297 primitive 108,344 PRINT 8 PRINT-Name 185, 195 Prinzip 331 Prioritätenfolge 292 Problemart 333 Produktionssystem 304 Programmierassistent 388 Programmieren im Großen 45 Programmierparadigma 107 Programmierung im Kleinen 45 Propagieren 269,295 PROPLIST 147 Pseudocode 304 PSL 386,392 Punkt-Paar 40, 176 Pure LISP 3, 39, 100, 211, 212, 386 PUTPROP 147

310 QLET 367 QLISP 367 Qualität 34,335 QUASIQUOTE 233-234, 348, 355 Quellcodetext 334 QUOTE 14, 48, 233 quote mark 15 Quotierung 15 RANDOM 71 READ 8 READ-EVAL-PRINT-Zyklus 12, 25, 129, 195, 233

8-9,

D: Schlagwörter READ-Makro 233 READ-Phase 233 20 recognizer 113 referential transparency 212 Regel 58 Regelanzeigerteil 59 Reichweite 320 Reihenfolge 124 Reinschrift 305 Rekursion 66,361 Rekursions-Route 85 Rekursionstiefe 86 rekursive Problemlösungs-Methode 89 REMPROP 147 REPEAT 66 Repetition 66 Repräsentation 15 Restrekursion 86-87 RETURN 112 REVERSE 97 Robustheit 335 ROUND 74 RPLACA 127 RPLACD 127 RUNTIME 251 Rückgabewert 281 Rückübersetzung 251 #\SPACE 188 Schachtelung 212 Scheme 3,386 Scheme-Konstrukte 395 SCHEME.INI 394 Schildkröte 345 Schneeflocke 361 Schnittstelle 17-18, 20, 175, 337 SCOOPS 272, 274, 344, 346 SCOOPS.FSL 274 Selbstähnlichkeit 360 Selbstbezug 85,220 Selbstübergabe 220 SELECTQ 65 Selektion 46 Selektionswert 144 Selektor 39, 110, 263, 395 SELF 283 Semantik 85 Semikolon 47,319 SEND 272, 274, 276, 280, 346

403 SEND-IF-HANDLES 296 SEND-WITH-OBJECT 283 Sequenz 46, 50, 54, 226, 396 SET! 25,27,48,128,243 SET-CAR! 126,216 SET-CDR! 126 SET-VIDEO-MODE! 344 SETCV 296 SETQ 12 SETTABLE-VARIABLES 275 47-48 shallow access 212 shared slot 285 slots 147, 261, 273 SmallTalk 109,288 Softwarekonstruktion 303 SoftWave LISP 393 47 SORT! 245 Sortierbarkeit 316 Sozialverträglichkeit 34 Space 188 Spezialisierung 284, 293, 297 splicing 235 sprachliche Einheit 105 Stack 58,224 Standard LISP 386 statische Bindung 31 Stellungsparameter 22 Stern 186 Steuerungsstruktur 46 *THE-NON-PRINTING-OBJECT* 96 string 9, 184 STRING->SYMBOL 204 STRING->UNINTERNED-SYMBOL 203 STRING-APPEND 190 STRING-CI=? 177 STRING-LENGTH 188 STRING-NULL? 188 STRING-REF 188 STRING=? 188 STRING? 188 - 261 ? 261 Struktogramm 11, 71, 90, 346 Strukturcodierung 385 strukturierte Programmierung 319 Subklasse 297 Subliste 144 SUBSTRING 190

404 Supercomputer 387,389 Superklasse 269, 284, 288 47 symbolic expression 4 Symbolics 387,390 Symbolic Processor 387 symbolische Ausdruck 38 syntaktische Erleichterung 348 Syntax 5, 85, 233, 245 System 333 T 386 T-Klausel 38 tail-recursion 86 Term 20 terminal symbols 47 terminals 47 Terminologie 306 Texas Instruments 387 THE-ENVIRONMENT 214,241 Thunk 76, 176 Tiefensuche 153 Tiefensuche-Algorithmus 291 TLC-LISP 386,393 top down approach 298 TRACE 87 TRACE-BOTH 87 TRACE-ENTRY 87 Transparenz 309,319 Turtle-Graphik 345 #!UNASSIGNED 26 UCI LISP 386, 393 Umfangreduktion 307 Umgebung 26 UNQUOTE 233 unary function 46, 74 Unbenutzbarkeit 49 UNBIND 243 Ungleichheit 41 uninterned symbol 203, 208 UNQUOTE 234, 348, 355 UNQUOTE-SPLICING 233,355 UNTIL 66 until-Konstrukt 71 upward funarg 31 USER-GLOBAL-ENVIRONMENT 26 USER-INITIAL-ENVIRONMENT 26, 240

Anhang überschatten 284 Übertragbarkeit 34 value cell 147 Variable 21 VECTOR 168 VECTOR->LIST 168 VECTOR-LENGTH 168 VECTOR-REF 168 VECTOR-SET! 169 VECTOR? 169 Vektorcodierung 385 Vererbung 265 Vererbungsbaum 288 Vererbungsgraph 268,282 Vererbungsrichtung 268 Verifizierbarkeit 323 Verkettung 46 Verknüpfungsmittel 109 Verkrumpelung 360 Verkürzungsvorteil 318 VGA 344 Vollständigkeit 60,323 Vollzugsproblem 333 Vorgehensweise 331 Vorübersetzer 185 Werkzeug 331 Wert 17, 142 Wertemenge 46 Wertermittlung 54 Wertzelle 147 WHILE 66 while-Konstrukt 71 whopper 297 Widerspruchsfreiheit 323 Wiederholungs-Bedingung 71 Wiederverwendung 303 WITH-INPUT-FROM-FILE 176 WITH-OUTPUT-TO-FILE 176 WordStar 394 Workstation 387,389 WRITELN 44,50 Xerox XLISP Zahlatom

387 393 4, 42, 48

D: Schlagwörter 47 Zeichen 4,9 Zeichenkette 4, 184 ZEITMESSUNG 251 Zerlegungsgrad 114 zero-based 96 ZetaLISP 386,393 47 zirkuläre Liste 129 Zugriffsoperation 267 Zurückführbarkeit 324 Zweckausrichtung 308

Zwischenraum

188

' 233-234, 348, 355 { - } 47 [-.] 47 , 233, 348, 355 ::= 47 ; 47 @ 233,283 355

Programmierung komplexer Systeme Herausgegeben von Fevzi Belli und Hinrich Bonin Die Reihe beschäftigt sich mit Realisierungs- und Zuverlässigkeitsaspekten komplexer Software-Systeme. Den Schwerpunkt bilden konkrete Handlungsgrundsätze und implementierungsnahe Techniken fur Informations- und wissensbasierte Systeme. Dabei rücken Probleme bei der Modellierung, Analyse, Konzeption, Konstruktion und Validation komplexer Systeme in den Mittelpunkt, vor allem im Hinblick auf Programmierungsaspekte. Eine gemeinsame Eigenschaft der Einzelbände ist ihre Innovationskomponente. Diese Komponente wird auch durch die Einbeziehung von Werken interdisziplinären Charakters gewährleistet. Konkrete Anwendungssysteme, insbesondere aus technischen Bereichen einschließlich Büro- und Verwaltungautomation, vermitteln den Praxisbezug. Band 2 Günter Becker

Softwarezuverlässigkeit Quantitative Modelle und Nachweisverfahren

15,5 x 23 cm. IX, 162 Seiten. Mit 35 Abbildungen. 1989. Gebunden. ISBN 3-11-012227-8 Band 4 Horst Zuse

Software Complexity Measures and Methods

17 x 24 cm. XVI, 605 Seiten. Mit 498 Abbüdungen. 1991. Gebunden. ISBN 3-11-012226-X Band 5 Ulrich Hoffmann

Einführung in die systemnahe Programmierung Anwenderprogramme und Datenstrukturen

15,5 x 23 cm. XII, 371 Seiten. Mit 136 Abbüdungen. 1990. Paperback. ISBN 3-11-012466-1 In Vorbereitung Band 3 Günter Matthiessen

Logik für Software-Ingenieure 15,5 x 23 cm. Ca. 270 Seiten. 1991. Paperback. ISBN 3-11-012228-6

WALTER D E GRUYTER • BERLIN • NEW YORK Genthiner Straße 13, D-1000 Berlin 30, Tel.:(030)26005-0, Fax:260-05-251

Studien zur Wirtschaftsinformatik Herausgegeben von Karl Kurbel, Uwe Pape, Hans-Jochen Schneider Die Wirtschaftsinformatik steht als interdisziplinäres Fachgebiet zwischen den Wirtschaftswissenschaften, insbesondere der Betriebswirtschaftslehre, und der Informatik. Sie behandelt die Entwicklung und den Einsatz computergestützter Anwendungssysteme in Unternehmen und Verwaltungen. Neben Systemen der operativen Ebene gehören dazu Planungssysteme und Entscheidungsunterstützungssysteme ebenso wie inner- und zwischenbetriebliche Informations-und Kommunikationssysteme. Ziel dieser Buchreihe ist es, den „State of the art" darzustellen, die Forschung zu fordern, die Lehre zu unterstützen und zu einer Strukturierung des Wissensgebiets beizutragen. Die Bände der Reihe wenden sich an Wissenschaftler, Entwickler, Anwender und an Studenten der Wirtschaftswissenschaften, der Informatik und der Wirtschaftsinformatik. Band 1 Detlef Karras/Lutz Kredel/Uwe Pape

Entwicklungsumgebungen für Expertensysteme Vergleichende Darstellung ausgewählter Systeme 15,5 x 23 cm. X, 217 Seiten. Mit einigen Abbildungen. 1987. Gebunden. ISBN 3-11-011294-9 Band 2 Lutz Kredel

Wirtschaftlichkeit von Bürokommunikationssystemen 15,5 x 23 cm. XVI, 368 Seiten. Mit 48 Abbüdungen. 1988. Gebunden. ISBN 3-11-011767-3 Band 3 Karl Kurbel/Peter Mertens/August-Wilhelm Scheer (Herausgeber)

Interaktive betriebswirtschaftliche Informationsund Steuerungssysteme 15,5 x 23 cm. VI, 354 Seiten. Mit 115 Abbüdungen. 1989. Gebunden. ISBN 3-11-012100-X Band 4 Peter Pfeiffer

Technologische Grundlage, Strategie und Organisation des Informationsmanagements 15,5 x 23 cm. XV, 337 Seiten. Mit 91 Abbüdungen. 1990. Gebunden. ISBN 3-11-012362-2

WALTER DE GRUYTER • BERLIN • NEW YORK Genthiner Straße 13, D-1000 Berlin 30, Tel.: (0 30) 2 60 05-0, Fax: 2 60-05-2 51