diff options
| -rw-r--r-- | doc/r5rs/Makefile.am | 4 | ||||
| -rw-r--r-- | doc/r5rs/r5rs.de.texi | 8805 | ||||
| -rw-r--r-- | doc/translation-rationale-de | 263 |
3 files changed, 9071 insertions, 1 deletions
diff --git a/doc/r5rs/Makefile.am b/doc/r5rs/Makefile.am index c64e4ffb1..8f33c47f5 100644 --- a/doc/r5rs/Makefile.am +++ b/doc/r5rs/Makefile.am @@ -21,6 +21,8 @@ AUTOMAKE_OPTIONS = gnu -info_TEXINFOS = r5rs.texi +info_TEXINFOS = \ + r5rs.texi \ + r5rs.de.texi EXTRA_DIST = ChangeLog-2008 diff --git a/doc/r5rs/r5rs.de.texi b/doc/r5rs/r5rs.de.texi new file mode 100644 index 000000000..d5b8a1246 --- /dev/null +++ b/doc/r5rs/r5rs.de.texi @@ -0,0 +1,8805 @@ +\input texinfo @c -*-texinfo-*- +@c %**start of header +@setfilename r5rs.de.info +@documentlanguage de +@documentencoding UTF-8 +@settitle Revised(5) Scheme + +@c Translation of Guile's copy of r5rs.texi, see doc/r5rs/r5rs.texi. + +@c \documentclass[twoside]{algol60} + +@c \pagestyle{headings} +@c \showboxdepth=0 + + + +@c \def\headertitle{Revised$^{5}$ Scheme} +@c \def\integerversion{5} + +@c Sizes and dimensions + +@c \topmargin -.375in % Nominal distance from top of page to top of + +@c box containing running head. +@c \headsep 15pt % Space between running head and text. + +@c \textheight 663pt % Height of text (including footnotes and figures, + +@c excluding running head and foot). + +@c \textwidth 523pt % Width of text line. +@c \columnsep 15pt % Space between columns +@c \columnseprule 0pt % Width of rule between columns. + +@c \parskip 5pt plus 2pt minus 2pt % Extra vertical space between paragraphs. +@c \parindent 0pt % Width of paragraph indentation. +@c \topsep 0pt plus 2pt % Extra vertical space, in addition to + +@c \parskip, added above and below list and + +@c paragraphing environments. + +@c \oddsidemargin -.5in % Left margin on odd-numbered pages. +@c \evensidemargin -.5in % Left margin on even-numbered pages. + +@c % End of sizes and dimensions + +@paragraphindent 0 +@c %**end of header +@c syncodeindex fn cp + +@ifinfo +@dircategory Die Algorithmische Sprache Scheme +@direntry +* R5RS-de: (r5rs-de). Der Revised(5) Report on Scheme (deutsch). +@end direntry +@end ifinfo + + +@c \parindent 0pt %!! 15pt % Width of paragraph indentation. + + @b{20. Februar 1998} +@c \hfil \today{} + +@c @include{first} +@titlepage + +@c HTML first page +@title Scheme +@subtitle Revised(5) Report on the Algorithmic Language Scheme +@c First page + +@c \thispagestyle{empty} + +@c \todo{"another" report?} + +@quotation +Überarbeiteter^5 Bericht über die Algorithmische Sprache Scheme. +@end quotation + + +@author R@sc{ICHARD} K@sc{ELSEY}, W@sc{ILLIAM} C@sc{LINGER} +@author @sc{UND} J@sc{ONATHAN} R@sc{EES} (@i{Herausgeber}) +@author H. A@sc{BELSON} +@author R. K. D@sc{YBVIG} +@author C. T. H@sc{AYNES} +@author G. J. R@sc{OZAS} +@author N. I. A@sc{DAMS IV} +@author D. P. F@sc{RIEDMAN} +@author E. K@sc{OHLBECKER} +@author G. L. S@sc{TEELE} J@sc{R}. +@author D. H. B@sc{ARTLEY} +@author R. H@sc{ALSTEAD} +@author D. O@sc{XLEY} +@author G. J. S@sc{USSMAN} +@author G. B@sc{ROOKS} +@author C. H@sc{ANSON} +@author K. M. P@sc{ITMAN} +@author M. W@sc{AND} + + +@c {\it Dedicated to the Memory of ALGOL 60} +@i{Der Erinnerung an Robert Hieb gewidmet} +@c [For the macros in R5RS -RK] + + + + +@majorheading Zusammenfassung + + +[Der englische Originaltext dieses Berichts] enthält eine normative +Beschreibung der Programmiersprache Scheme. Scheme ist ein Dialekt der +Lisp-Programmiersprache mit statischen Sichtbarkeitsbereichen und echter +Endrekursion, der von Guy Lewis Steele Jr.@: und Gerald Jay Sussman +erfunden wurde. Er wurde mit einem Augenmerk auf besonders klarer und +einfacher Semantik entworfen mit nur wenigen verschiedenen Arten, +Ausdrücke zu bilden. Eine große Vielfalt von Programmierparadigmen, +unter ihnen imperative, funktionale und nachrichtenübermitteltende +Stile, finden in Scheme eine gelegene Ausdrucksweise. + +Diese Einleitung bietet eine kurze Geschichte der Sprache und des +Berichts. + +Die ersten drei Kapitel zeigen die grundlegenden Ideen der Sprache und +beschreiben die Konventionen der Notation, mit der die Sprache +beschrieben und Programme in der Sprache geschrieben werden. + +Die Kapitel @ref{Ausdrücke} und @ref{Programmstruktur} beschreiben +Syntax und Semantik von Ausdrücken, Programmen und Definitionen. + +Das Kapitel @ref{Standardprozeduren} beschreibt die in Scheme +eingebauten Prozeduren, wozu alle Grundbausteine der Sprache zur +Datenmanipulation und zur Ein- und Ausgabe gehören. + +Das Kapitel @ref{Formale Syntax und Semantik} bietet eine formale Syntax +für Scheme, geschrieben in erweiterter BNF, zusammen mit einer formalen +denotationellen Semantik. Auf die formale Syntax und Semantik folgt ein +Beispiel der Nutzung der Sprache. + +Der Bericht endet mit einer Liste von Verweisen und einem alphabetischen +Register. + +@ignore todo +expand the summary so that it fills up the column. +@end ignore + + +@c \vfill +@c \begin{center} +@c {\large \bf +@c *** DRAFT*** \\ +@c %August 31, 1989 +@c \today +@c }\end{center} + + + + + +@c \addvspace{3.5pt} % don't shrink this gap +@c \renewcommand{\tocshrink}{-3.5pt} % value determined experimentally + + + + + + +@page + +@end titlepage + +@c INFO first page +@ifnottex + +@c First page + +@c \thispagestyle{empty} + +@c \todo{"another" report?} + + +@node top, Einleitung, (dir), (dir) +@top Revised(5) Report on the Algorithmic Language Scheme + +@sp 1 + + +@quotation +Überarbeiteter^5 Bericht über die Algorithmische Sprache Scheme. + +R@sc{ichard} K@sc{elsey}, W@sc{illiam} C@sc{linger und} J@sc{onathan} R@sc{ees} (@i{Herausgeber}) +@sp 1 +@multitable @columnfractions 0.25 0.25 0.25 0.25 +@item H. A@sc{belson} @tab R. K. D@sc{ybvig} @tab C. T. H@sc{aynes} @tab G. J. R@sc{ozas} +@item N. I. A@sc{dams IV} @tab D. P. F@sc{riedman} @tab E. K@sc{ohlbecker} @tab G. L. S@sc{teele} J@sc{r}. +@item D. H. B@sc{artley} @tab R. H@sc{alstead} @tab D. O@sc{xley} @tab G. J. S@sc{ussman} +@item G. B@sc{rooks} @tab C. H@sc{anson} @tab K. M. P@sc{itman} @tab M. W@sc{and} +@item +@end multitable +@end quotation + + +@sp 2 + +@c {\it Dedicated to the Memory of ALGOL 60} +@i{Der Erinnerung an Robert Hieb gewidmet} +@c [For the macros in R5RS -RK] + +@sp 3 + + + + +@majorheading Zusammenfassung + + +[Der englische Originaltext dieses Berichts] enthält eine normative +Beschreibung der Programmiersprache Scheme. Scheme ist ein Dialekt der +Lisp-Programmiersprache mit statischen Sichtbarkeitsbereichen und echter +Endrekursion, der von Guy Lewis Steele Jr.@: und Gerald Jay Sussman +erfunden wurde. Er wurde mit einem Augenmerk auf besonders klarer und +einfacher Semantik entworfen mit nur wenigen verschiedenen Arten, +Ausdrücke zu bilden. Eine große Vielfalt von Programmierparadigmen, +unter ihnen imperative, funktionale und nachrichtenübermitteltende +Stile, finden in Scheme eine gelegene Ausdrucksweise. + +Diese Einleitung bietet eine kurze Geschichte der Sprache und des +Berichts. + +Die ersten drei Kapitel zeigen die grundlegenden Ideen der Sprache und +beschreiben die Konventionen der Notation, mit der die Sprache +beschrieben und Programme in der Sprache geschrieben werden. + +Die Kapitel @ref{Ausdrücke} und @ref{Programmstruktur} beschreiben +Syntax und Semantik von Ausdrücken, Programmen und Definitionen. + +Das Kapitel @ref{Standardprozeduren} beschreibt die in Scheme +eingebauten Prozeduren, wozu alle Grundbausteine der Sprache zur +Datenmanipulation und zur Ein- und Ausgabe gehören. + +Das Kapitel @ref{Formale Syntax und Semantik} bietet eine formale Syntax +für Scheme, geschrieben in erweiterter BNF, zusammen mit einer formalen +denotationellen Semantik. Auf die formale Syntax und Semantik folgt ein +Beispiel der Nutzung der Sprache. + +Der Bericht endet mit einer Liste von Verweisen und einem alphabetischen +Register. + +@ignore todo +expand the summary so that it fills up the column. +@end ignore + + +@c \vfill +@c \begin{center} +@c {\large \bf +@c *** DRAFT*** \\ +@c %August 31, 1989 +@c \today +@c }\end{center} + + + + + +@c \addvspace{3.5pt} % don't shrink this gap +@c \renewcommand{\tocshrink}{-3.5pt} % value determined experimentally + +@unnumbered Inhalt + +@menu +* Einleitung:: +* Übersicht von Scheme:: +* Schreibkonventionen:: +* Grundkonzepte:: +* Ausdrücke:: +* Programmstruktur:: +* Standardprozeduren:: +* Formale Syntax und Semantik:: +* Bemerkungen:: +* Weiteres Material:: +* Beispiel:: +* Bibliographie:: +* Register:: +@end menu + + + + + +@page + +@end ifnottex + + +@c @include{intro} +@node Einleitung, Übersicht von Scheme, top, top +@unnumbered Einleitung + +@menu +* Hintergrund:: +* Anerkennungen:: +@end menu + + + + +Programmiersprachen sollten nicht entworfen werden, indem man +Funktionalitäten über Funktionalitäten schichtet, sondern indem man +Schwächen und Einschränkungen entfernt, die es so erscheinen lassen, +als wären weitere Funktionalitäten nötig. Scheme demonstriert, dass +eine sehr kleine Zahl von Regeln, wie Ausdrücke gebildet werden, ohne +Einschränkungen, wie man sie zusammenfügt, genügen, um eine praktische +und effiziente Programmiersprache zu bilden, die flexibel genug ist, +die meisten größeren Programmierparadigmen, die heute genutzt werden, +zu bedienen. + +@c Scheme hat die Entwicklung von Lisp beeinflusst. +Scheme +war eine der ersten Programmiersprachen, die Prozeduren erster Klasse +wie im Lambda-Kalkül enthält, und hat so bewiesen, wie nützlich +statische Sichtbarkeitsregeln und eine Blockstruktur in einer dynamisch +typisierten Sprache sind. Scheme war der erste größere Dialekt von +Lisp, der Prozeduren von Lambda-Ausdrücken und Symbolen unterscheidet, +der eine einzelne lexikalische Umgebung für alle Variablen benutzt und +der die Operatorposition eines Prozeduraufrufs auf gleiche Weise +auswertet wie eine Operandenposition. Indem Scheme Iterationen allein +mit Prozeduraufrufen ausdrückt, betonte Scheme, dass endrekursive +Prozeduraufrufe im Kern goto-Ausdrücke, die Argumente übergeben, sind. +Scheme war die erste weit verbreitete Programmiersprache, die +Ausstiegsprozeduren erster Klasse, aus denen alle anderen +Programmflussstrukturen synthetisiert werden können, rückhaltlos +unterstützte. Eine spätere Fassung von Scheme führte das Konzept +exakter und inexakter Zahlen ein, eine Erweiterung der generischen +Arithmetik von Common Lisp. Vor weniger langer Zeit wurde Scheme zur +ersten Programmiersprache, die hygienische Makros unterstützt, welche +Syntaxerweiterungen von in Blöcken strukturierten Sprachen auf +konsistente und zuverlässige Weise zulassen. + + +@node Hintergrund, Anerkennungen, Einleitung, Einleitung +@unnumberedsec Hintergrund + + +Die erste Beschreibung von Scheme wurde im Jahr 1975 [Scheme75] +geschrieben. Ein überarbeiteter Bericht („revised report``) [Scheme78] +@ignore todo +italicize or not? +@end ignore +erschien 1978. Er beschrieb die Entwicklung der Sprache, als seine +MIT-Implementierung ausgebaut wurde, um einen innovativen Übersetzer +(Compiler) [Rabbit]. Drei separate Projekte begannen 1981 und 1982, um +Varianten von Scheme für Kurse am MIT, Yale und der Indiana University +zu benutzen [Rees82], [MITScheme], [Scheme311]. Ein einführendes +Informatiklehrbuch, das Scheme benutzt, wurde 1984 veröffentlicht +[SICP]. + + +Als sich Scheme weiter verbreitete, +fingen lokale Dialekte an, auseinanderzugehen, bis Studenten und +Forscher Probleme bekamen, den an anderen Orten geschriebenen Code zu +verstehen. +Fünfzehn Repräsentanten der größeren Implementierungen von Scheme +versammelten sich deshalb im Oktober 1984, um an einem besseren und von +mehr Leuten anerkannten Standard für Scheme zu arbeiten. + +Ihr Bericht [RRRS] wurde am MIT und der Indiana University im Sommer +1985 veröffentlicht. Weitere Revisionen fanden im Frühling 1986 [R3RS] +und im Frühling 1988 [R4RS] statt. Der vorliegende Bericht entspricht +weiteren Revisionen, auf die man sich in einer Besprechung bei Xerox +PARC im Juni 1992 geeinigt hat. + + +@sp 3 + +Wir beabsichtigen, dass dieser Bericht der gesamten Scheme-Gemeinschaft +gehören soll, und erteilen damit die Erlaubnis, ihn gänzlich oder in +Teilen ohne Gebühr zu kopieren. Insbesondere ermutigen wir +Implementierer von Scheme, diesen Bericht als Ausgangspunkt für +Handbücher und andere Dokumentation zu benutzen und nach Bedarf zu +verändern. + + + + +@node Anerkennungen, , Hintergrund, Einleitung +@unnumberedsec Anerkennungen + + +Wir möchten den folgenden Leuten für ihre Hilfe danken: Alan Bawden, Michael +Blair, George Carrette, Andy Cromarty, Pavel Curtis, Jeff Dalton, Olivier Danvy, +Ken Dickey, Bruce Duba, Marc Feeley, +Andy Freeman, Richard Gabriel, Yekta G"ursel, Ken Haase, Robert +Hieb, Paul Hudak, Morry Katz, Chris Lindblad, Mark Meyer, Jim Miller, Jim Philbin, +John Ramsdell, Mike Shaff, Jonathan Shapiro, Julie Sussman, +Perry Wagle, Daniel Weise, Henry Wu und Ozan Yigit. +Wir danken Carol Fessenden, Daniel +Friedman und Christopher Haynes für die Erlaubnis, Text aus dem +Referenzhandbuch von Scheme 311 Version 4 zu verwenden. Wir danken +Texas Instruments, Inc. für die Erlaubnis, Text aus dem @emph{TI Scheme +Language Reference Manual}[TImanual85] zu verwenden. Wir erkennen gerne +den Einfluss der Handbücher für MIT Scheme[MITScheme], T[Rees84], Scheme +84[Scheme84], Common Lisp[CLtL] und Algol 60[Naur63] an. + +Wir danken auch Betty Dexter für die enorme Mühe, mit der sie diesen +Bericht in @TeX{} gesetzt hat, und Donald Knuth für den Entwurf des +Programms, dass ihr Ärger bereitet hat. + +Das Artificial Intelligence Laboratory des Massachusetts Institute of +Technology, das Computer Science Department der Indiana University, das +Computer and Information Sciences Department der University of Oregon +und das NEC Research Institute haben die Vorbereitung dieses Berichts +unterstützt. Unterstützung für die Arbeit des MIT kam in Teilen von der +Advanced Research Projects Agency des Department of Defense unter dem +Vertrag N00014-80-C-0505 des Office of Naval Research. Unterstützung +für die Arbeit der Indiana University gab es durch NSF-Förderungen NCS +83-04567 und NCS 83-03325. + + + + +@sp 2 + +@c \clearchapterstar{Description of the language} %\unskip\vskip -2ex +@c @include{struct} + +@c 1. Structure of the language + +@node Übersicht von Scheme, Schreibkonventionen, Einleitung, top +@chapter Übersicht von Scheme + +@menu +* Semantik:: +* Syntax:: +* Notation und Terminologie:: +@end menu + + +@node Semantik, Syntax, Übersicht von Scheme, Übersicht von Scheme +@section Semantik + + + +Dieser Abschnitt vermittelt eine Übersicht über die Semantik von Scheme. +Eine detaillierte informelle Semantik ist Thema der Kapitel +@ref{Grundkonzepte} bis @ref{Standardprozeduren}. Als Referenz bietet +der Abschnitt @ref{Formale Semantik} eine formale Semantik von Scheme. + +Scheme folgt Algol darin, dass es eine Programmiersprache mit statischen +Sichtbarkeitsbereichen ist. Jede Nutzung einer Variable wird mit einer +lexikalisch offenbaren Bindung dieser Variablen assoziiert. + +Scheme benutzt latente statt ausdrücklicher Typisierung. Typen werden +mit Werten (auch Objekte genannt) assoziiert +@cindex @w{Objekt} +statt mit Variablen. (Manche Autoren nennen latent typisierte Sprachen +auch schwach typisierte oder dynamisch typisierte Sprachen.) Andere +Sprachen mit latenten Typen sind APL, Snobol und andere Lisp-Dialekte. +Sprachen mit ausdrücklichen Typen (manchmal stark typisierte oder +statisch typisierte Sprachen genannt) sind unter Anderem Algol 60, +Pascal und C. + +Alle Objekte, die im Laufe einer Scheme-Berechnung erzeugt werden, +einschließlich Prozeduren und Fortsetzungen, haben einen +unbeschränkten Gültigkeitsbereich. Kein Scheme-Objekt wird jemals +zerstört. Der Grund dafür, dass Scheme-Implementierungen (meistens!) +nicht der Speicher ausgeht, ist, dass sie sich den von einem Objekt +belegten Speicher zurückholen dürfen, wenn sie beweisen können, dass +das Objekt keinen Einfluss auf jegliche zukünftige Berechnung haben +kann. Andere Sprachen, in denen die meisten Objekte einen +unbeschränkten Gültigkeitsbereich haben, sind unter Anderem APL und +andere Lisp-Dialekte. + +Scheme-Implementierungen sind verpflichtet, echt endrekursiv zu sein. +Dadurch kann die Ausführung einer iterativen Berechnung mit konstantem +Speicher auskommen, selbst wenn die iterative Berechnung syntaktisch +durch eine rekursive Prozedur beschrieben wird. Somit kann mit einer +echt endrekursiven Implementierung die Iteration mit der herkömmlichen +Mechanik von Prozeduraufrufen ausgedrückt werden, so dass besondere +Konstrukte für die Iteration nur als syntaktischer Zucker nützlich sind. +Siehe den Abschnitt @ref{Echte Endrekursion}. + +Scheme-Prozeduren sind selbst auch Objekte. Prozeduren können dynamisch +erstellt werden, in Datenstrukturen gespeichert werden, als Ergebnisse +von Prozeduren zurückgegeben werden und so weiter. Andere Sprachen mit +diesen Eigenschaften sind unter Anderem Common Lisp und ML. +@ignore todo +Rozas: Scheme had them first. +@end ignore + + +Eine Scheme auszeichnende Funktionalität ist, dass Fortsetzungen +(Continuations), welche in den meisten anderen Sprachen nur im +Hintergrund bestehen, auch als Objekte „erster Klasse`` gelten. +Fortsetzungen sind nützlich bei der Implementierung einer großen +Vielzahl von fortgeschrittenen Programmflussstrukturen, einschließlich +nicht-lokaler Sprünge, Rücksetzverfahren (@abbr{engl.} Backtracking) und +Ko-Routinen. Siehe den Abschnitt @ref{Programmflussfunktionalitäten}. + +Argumente an Scheme-Prozeduren werden immer als Wertparameter übergeben. +Das bedeutet, die eigentlichen Argument-Ausdrücke werden zuerst +ausgewertet, bevor die Prozedur ausgeführt wird, egal ob die Prozedur +die Ergebnisse der Auswertung überhaupt benutzt. ML, C und APL sind +drei andere Sprachen, die auch Argumente immer als Wertparameter +übergeben. Dies unterscheidet sich von Haskells verzögerter Auswertung +oder den Namensparametern von Algol 60, bei denen ein Argument-Ausdruck +erst dann ausgewertet wird, wenn sein Wert von der Prozedur gebraucht +wird. + +@ignore todo +Lisp's call by value should be explained more +accurately. What's funny is that all values are references. +@end ignore + + +Schemes Modell der Arithmetik wurde so gestaltet, dass es möglichst +unabhängig davon ist, welche bestimmten Zahlendarstellungen ein Rechner +benutzt. In Scheme ist jede ganze Zahl eine rationale Zahl, jede +rationale Zahl ist eine reelle Zahl und jede reelle Zahl ist eine +komplexe Zahl. Daher besteht in Scheme kein Unterschied zwischen +ganzzahliger und reeller Arithmetik, welcher für andere Sprachen so +wichtig ist. Stattdessen unterscheidet Scheme zwischen exakter +Arithmetik, welche dem mathematischen Ideal entspricht, und nicht +exakter Arithmetik, die Annäherungen macht. Wie in Common Lisp ist +exakte Arithmetik nicht auf ganze Zahlen beschränkt. + +@node Syntax, Notation und Terminologie, Semantik, Übersicht von Scheme +@section Syntax + + +Scheme benutzt wie die meisten Lisp-Dialekte eine vollständig +geklammerte Präfix-Notation für Programme und (andere) Daten; die +Grammatik von Scheme erzeugt eine Untersprache der für Daten benutzten +Sprache. Eine wichtige Folge dieser einfachen, einheitlichen +Darstellung ist, dass Scheme-Programme und Daten von anderen +Scheme-Programmen oft gleich behandelt werden. Zum Beispiel wertet die +@samp{Eval}-Prozedur ein als Daten ausgedrücktes Scheme-Programm aus. + +Die @samp{Read}-Prozedur führt syntaktische sowie lexikalische +Aufgliederung der von ihr gelesenen Daten durch. Die +@samp{Read}-Prozedur versteht ihre Eingabe als Daten (Abschnitt +@pxref{Externe Darstellung}) und nicht als Programm. + +Die formale Syntax von Scheme ist im Abschnitt @ref{Formale Syntax} +beschrieben. + + +@node Notation und Terminologie, , Syntax, Übersicht von Scheme +@section Notation und Terminologie + +@menu +* Grundlegende; Bibliotheks- und optionale Funktionalitäten:: +* Fehlersituationen und unbestimmtes Verhalten:: +* Eintragsformat:: +* Auswertungsbeispiele:: +* Namenskonventionen:: +@end menu + + + +@node Grundlegende; Bibliotheks- und optionale Funktionalitäten, Fehlersituationen und unbestimmtes Verhalten, Notation und Terminologie, Notation und Terminologie +@subsection Grundlegende; Bibliotheks- und optionale Funktionalitäten + + + +Jede Implementierung von Scheme muss alle nicht als @dfn{optional} +markierten Funktionalitäten von Scheme unterstützen. Implementierungen +steht es +@cindex @w{optional} +frei, optionale Funktionalitäten von Scheme wegzulassen oder +Erweiterungen anzubieten, solange diese Erweiterungen nicht im Konflikt +mit der Sprache steht, über die hier berichtet wird. Insbesondere +müssen Implementierungen portablen Code unterstützen, indem sie einen +syntaktischen Modus anbieten, der keinen Schreibkonventionen dieses +Berichts zuvorkommt. + +Um das Verständnis und die Implementierung von Scheme zu erleichtern, +sind manche Funktionalitäten als @dfn{Bibliothek}sfunktionalitäten +markiert. Diese können leicht unter Benutzung der anderen, +@cindex @w{Bibliothek} +grundlegenden, Funktionalitäten implementiert werden. Streng genommen +sind sie überflüssig, aber sie fassen übliche Muster, wie Scheme benutzt +wird, und werden daher als bequeme Kurzschreibweisen angeboten. + +@node Fehlersituationen und unbestimmtes Verhalten, Eintragsformat, Grundlegende; Bibliotheks- und optionale Funktionalitäten, Notation und Terminologie +@subsection Fehlersituationen und unbestimmtes Verhalten + + + +@cindex @w{Fehler} +Wenn dieser Bericht von einer Fehlersituation spricht, zeigt der Bericht +mit „ein Fehler wird signalisiert`` an, dass Implementierungen den +Fehler feststellen und melden müssen. Wenn in der Diskussion eines +Fehlers keine solche Formulierung auftaucht, dann müssen +Implementierungen den Fehler nicht feststellen oder melden, sind aber +dazu angehalten. Eine Fehlersituation, die Implementierungen nicht +feststellen müssen, wird in der Regel einfach als „ein Fehler`` +bezeichnet. + +Zum Beispiel ist es ein Fehler, wenn einer Prozedur ein Argument +übergeben wird, für das nicht spezifiziert wurde, dass die Prozedur +damit umgehen kann, selbst wenn solche Definitionsbereichsfehler in +diesem Bericht nur selten erwähnt werden. Implementierungen dürfen den +Definitionsbereich einer Prozedur erweitern, so dass er solche Argumente +auch einschließt. + +Dieser Bericht verwendet die Formulierung „darf eine Verletzung einer +Implementierungseinschränkung melden``, um Umstände anzuzeigen, unter +denen eine Implementierung melden darf, dass sie die Ausführung eines +korrekten Programms wegen einer von der Implementierung geforderten +Einschränkung nicht fortführen kann. Von +Implementierungseinschränkungen wird selbstverständlich abgeraten, aber +Implementierungen werden ermutigt, Verletzungen solcher +Implementierungseinschränkungen zu melden. +@cindex @w{Implementierungseinschränkung} + +Zum Beispiel darf eine Implementierung eine Verletzung einer +Implementierungseinschränkung melden, wenn sie nicht genug +Speicherkapazität hat, um ein Programm auszuführen. + +Wenn der Wert eines Ausdrucks als „unbestimmt`` angegeben wird, dann +muss dieser Ausdruck zu irgendeinem Objekt ausgewertet werden, ohne +einen Fehler zu signalisieren, aber zu welchem Wert hängt von der +Implementierung ab; dieser Bericht schreibt ausdrücklich nicht vor, +welcher Wert zurückgegeben werden sollte. +@cindex @w{unbestimmt} + +@ignore todo +Talk about unspecified behavior vs. unspecified values. +@end ignore + + +@ignore todo +Look at KMP's situations paper. +@end ignore + + + +@node Eintragsformat, Auswertungsbeispiele, Fehlersituationen und unbestimmtes Verhalten, Notation und Terminologie +@subsection Eintragsformat + + +Die Kapitel @ref{Ausdrücke} und @ref{Standardprozeduren} sind in +Einträge unterteilt. Jeder Eintrag beschreibt eine Funktionalität der +Sprache oder eine Gruppe zusammengehöriger Funktionalitäten, wobei eine +Funktionalität entweder ein syntaktisches Konstrukt oder eine eingebaute +Prozedur ist. Ein Eintrag beginnt mit einer oder mehreren Kopfzeilen +der Form + + +@noindent +@deffn {@var{Kategorie}} @var{Schablone} + +@end deffn + +für verpflichtende, grundlegende Funktionalitäten oder + + +@noindent +@deffn {@var{Qualifikator} @var{Kategorie}} @var{Schablone} + +@end deffn + +wobei @var{Qualifikator} entweder „Bibliotheks`` oder „optionale`` sein +kann gemäß der Definition im Abschnitt @ref{Grundlegende; Bibliotheks- +und optionale Funktionalitäten}. + +Wenn die @var{Kategorie} als „Syntax`` angegeben ist, beschreibt der +Eintrag einen Ausdruckstyp und die Schablone gibt die Syntax des +Ausdruckstyps an. Bestandteile von Ausdrücken werden als syntaktische +Variablen ausgezeichnet, welche mit spitzen Klammern geschrieben werden, +zum Beispiel @r{<Ausdruck>} oder @r{<Variable>}. Syntaktische Variable +sollten verstanden werden als etwas, was Programmtextsegmente +bezeichnet; zum Beispiel steht @r{<Ausdruck>} für eine beliebige +Zeichenkette, die einen syntaktisch gültigen Ausdruck darstellt. Die +Notation + +@format + @r{<Ding1>} @dots{} +@end format + +zeigt null oder mehr Vorkommen eines @r{<Ding>} an, wogegen + +@format + @r{<Ding1>} @r{<Ding2>} @dots{} +@end format + +eines oder mehr Vorkommen eines @r{<Ding>} anzeigt. + +Wenn @var{Kategorie} „Prozedur`` ist, dann beschreibt der Eintrag eine +Prozedur und die Kopfzeile gibt eine Schablone eines Aufrufs der +Prozedur an. Argumentnamen in der Schablone sind @var{kursiv}. Somit +zeigt die Kopfzeile + + +@noindent +@deffn {Prozedur} vector-ref @var{vector} @var{k} + +@end deffn + +an, dass die eingebaute Prozedur @t{vector-ref} zwei Argumente nimmt, +einen Vektor @var{Vector} und eine exakte nicht negative ganze Zahl +@var{k} (siehe unten). Die Kopfzeilen + + +@noindent + +@deffn {Prozedur} make-vector @var{k} + + +@deffnx {Prozedur} make-vector @var{k} @var{fill} + +@end deffn + +zeigen an, dass die Prozedur @t{Make-vector} so definiert werden muss, +dass sie entweder ein oder zwei Argumente nimmt. + + +Es ist ein Fehler, wenn einer Operation ein Argument vorgelegt wird, +wofür nicht spezifiziert wurde, dass sie damit umgehen kann. Der Kürze +wegen folgen wir der Konvention, dass wenn ein Argumentname auch der +Name eines im Abschnitt @ref{Typfremdheit} aufgeführten Typs ist, dieses +Argument vom genannten Typen sein muss. Zum Beispiel schreibt obige +Kopfzeile für @t{Vector-ref} vor, dass das erste Argument an +@t{Vector-ref} ein Vektor sein muss. Die folgenden Namenskonventionen +implizieren ebenfalls Typeinschränkungen: +@c \newcommand{\foo}[1]{\vr{#1}, \vri{#1}, $\ldots$ \vrj{#1}, $\ldots$} + + +@c @center @c begin-tabular +@quotation +@table @asis +@item @var{Objekt} +ein beliebiges Objekt +@item @var{Liste}, @var{Liste1}, @dots{} @var{Listej}, @dots{} +Liste (siehe Abschnitt @pxref{Paare und Listen}) +@item @var{z}, @var{z1}, @dots{} @var{zj}, @dots{} +komplexe Zahl +@item @var{x}, @var{x1}, @dots{} @var{xj}, @dots{} +reelle Zahl +@item @var{y}, @var{y1}, @dots{} @var{yj}, @dots{} +reelle Zahl +@item @var{q}, @var{q1}, @dots{} @var{qj}, @dots{} +rationale Zahl +@item @var{n}, @var{n1}, @dots{} @var{nj}, @dots{} +ganze Zahl +@item @var{k}, @var{k1}, @dots{} @var{kj}, @dots{} +exakte, nicht negative ganze Zahl +@c @item +@end table +@end quotation + + + + +@ignore todo +Provide an example entry?? +@end ignore + + + +@node Auswertungsbeispiele, Namenskonventionen, Eintragsformat, Notation und Terminologie +@subsection Auswertungsbeispiele + + +Das in Programmbeispielen benutzte Symbol „@result{}`` sollte als +„wird ausgewertet zu`` gelesen werden. Zum Beispiel bedeutet + + +@example + +(* 5 8) ==> 40 + +@end example + + +dass der Ausdruck @t{(* 5 8)} zum Objekt @t{40} ausgewertet wird. Oder +genauer gesagt: Der Ausdruck, der sich aus der Zeichenfolge „@t{(* 5 +8)}`` ergibt, wird, in der Anfangsumgebung, ausgewertet zu einem Objekt, +das durch die Zeichenfolge „@t{40}`` extern dargestellt werden kann. +Siehe den Abschnitt @ref{Externe Darstellung} für eine Diskussion der +externen Darstellungen eines Objekts. + +@node Namenskonventionen, , Auswertungsbeispiele, Notation und Terminologie +@subsection Namenskonventionen + + +Nach Konvention enden die Namen von Prozeduren, die immer einen +booleschen Wert zurückgeben, gewöhnlich auf „@code{?}``. Solche +Prozeduren werden Prädikate genannt. +@vindex @w{?} + +Nach Konvention enden die Namen von Prozeduren, die Werte in bereits +zugeteilte Speicherstellen einspeichern (siehe den Abschnitt +@pxref{Speichermodell}), gewöhnlich auf „@code{!}``. +@vindex @w{!} +Solche Prozeduren werden Veränderungsprozeduren genannt. Nach +Konvention ist der von einer Veränderungsprozedur zurückgegebene Wert +unbestimmt. + +Nach Konvention erscheint „@code{->}`` im Namen von Prozeduren, die +@vindex @w{->} +ein Objekt einen Typs nehmen und ein entsprechendes Objekt eines anderen +Typs zurückgeben. Zum Beispiel nimmt @samp{List->vector} eine Liste und +gibt einen Vektor zurück, dessen Elemente dieselben sind wie die der +Liste. + + + +@ignore todo +Terms that need defining: thunk, command (what else?). +@end ignore + + +@c @include{lex} + +@c Lexical structure + +@c %\vfill\eject +@node Schreibkonventionen, Grundkonzepte, Übersicht von Scheme, top +@chapter Schreibkonventionen + +@menu +* Bezeichner:: +* Leerraum und Kommentare:: +* Andere Notationen:: +@end menu + + +Dieser Abschnitt berichtet informell über einige der beim Schreiben von +Scheme-Programmen benutzten Schreibkonventionen. Eine formale Syntax +von Scheme finden Sie im Abschnitt @ref{Formale Syntax}. + +Groß- und kleingeschriebene Formen eines Buchstabens werden nie +unterschieden außer innerhalb von Zeichen- und Zeichenketten-Konstanten. +Zum Beispiel ist @samp{Foo} derselbe Bezeichner wie @samp{FOO} und +@t{#x1AB} ist dieselbe Zahl wie @t{#X1ab}. + +@node Bezeichner, Leerraum und Kommentare, Schreibkonventionen, Schreibkonventionen +@section Bezeichner + + + +Die meisten Bezeichner, die in anderen Programmiersprachen zugelassen +sind, +@cindex @w{Bezeichner} +sind auch in Scheme zulässig. Die genauen Regeln für das Bilden von +Bezeichnern unterscheiden sich je nach Scheme-Implementierung, aber in +allen Implementierungen ist eine Folge von Zeichen, Ziffern und +„erweiterten Buchstabenzeichen``, die mit einem Zeichen beginnt, das +keine Zahl beginnen kann, ein Bezeichner. Außerdem sind @code{+}, +@code{-} und @code{...} auch Bezeichner. +@vindex @w{...} +@vindex @w{-} +@vindex @w{+} +Hier sind einige Beispiele von Bezeichnern: + + +@example + +lambda q +list->vector soup ++ V17a +<=? a34kTMNs +Das-Wort-Rekursion-hat-viele-Bedeutungen + +@end example + + +Erweiterte Buchstabenzeichen dürfen innerhalb von Bezeichnern benutzt +werden, als wären sie Buchstaben. Die folgenden Zeichen sind erweiterte +Buchstabenzeichen: + + +@example + +! $ % & * + - . / : < = > ? @@ ^ _ ~ +@end example + + +Siehe den Abschnitt @ref{Lexikalische Struktur} für eine formale Syntax +von Bezeichnern. + +Bezeichner haben in Scheme-Programmen zwei Zwecke: + + +@itemize @bullet + +@item +Jeder Bezeichner darf als Variable oder als syntaktisches Schlüsselwort +benutzt werden +(siehe die Abschnitte @pxref{Variable; syntaktische Schlüsselwörter; und +Regionen} und @pxref{Makros}). + +@item +Wenn ein Bezeichner als Literal oder innerhalb eines Literals auftaucht +(siehe den Abschnitt @pxref{Literale Ausdrücke}), wird er benutzt, um +ein @emph{Symbol} zu bezeichnen (siehe den Abschnitt @pxref{Symbole}). + + +@end itemize + +@cindex @w{syntaktisches Schlüsselwort} +@cindex @w{Variable} + +@c \label{keywordsection} +@c The following identifiers are syntactic keywords, and should not be used +@c as variables: + +@c \begin{scheme} +@c => do or +@c and else quasiquote +@c begin if quote +@c case lambda set! +@c cond let unquote +@c define let* unquote-splicing +@c delay letrec% +@c \end{scheme} + +@c Some implementations allow all identifiers, including syntactic +@c keywords, to be used as variables. This is a compatible extension to +@c the language, but ambiguities in the language result when the +@c restriction is relaxed, and the ways in which these ambiguities are +@c resolved vary between implementations. + + +@node Leerraum und Kommentare, Andere Notationen, Bezeichner, Schreibkonventionen +@section Leerraum und Kommentare + + +@dfn{Leerraum}-Zeichen sind Leerzeichen und Zeilenvorschübe. +@cindex @w{Leerraum} +(Implementierungen bieten typischerweise zusätzliche Leerraum-Zeichen +wie Tabulatorzeichen oder Seitenvorschübe.) Leerraum wird zur besseren +Lesbarkeit benutzt und um Tokens voneinander zu trennen, wobei ein Token +eine unteilbare lexikalische Einheit wie zum Beispiel ein Bezeichner +oder eine Zahl ist; dort hat der Leerraum sonst keine Auswirkung. +Leerraum darf zwischen jeglichen zwei Tokens auftreten, aber nicht +innerhalb eines Tokens. Leerraum darf auch innerhalb einer Zeichenkette +auftreten, wo er aber Auswirkungen hat. + +Ein Semikolon (@t{;}) zeigt den Anfang eines Kommentars an. Der +Kommentar geht weiter bis zum +@cindex @w{;} +@cindex @w{Kommentar} +Ende der Zeile, auf der das Semikolon steht. Kommentare sind gegenüber +Scheme unsichtbar, aber das Ende der Zeile ist als Leerraum sichtbar. +Dies verhindert, dass ein Kommentar in der Mitte eines Bezeichners oder +einer Zahl steht. + + +@example + +;;; Die FACT-Prozedur berechnet die Fakultät +;;; einer nicht negativen ganzen Zahl. +(define fact + (lambda (n) + (if (= n 0) + 1 ;Rekursionsanfang: Rückgabe 1 + (* n (fact (- n 1)))))) + +@end example + + + +@node Andere Notationen, , Leerraum und Kommentare, Schreibkonventionen +@section Andere Notationen + + +@ignore todo +Rewrite? +@end ignore + + +Für eine Beschreibung der Notationen, die für Zahlen benutzt werden, +siehe den Abschnitt @ref{Zahlen}. + + +@table @t + + +@item @t{.@: + -} +Diese werden in Zahlen benutzt und können auch sonst irgendwo in einem +Bezeichner auftauchen, außer als deren erstes Zeichen. Ein abgegrenztes +Plus- oder Minuszeichen für sich alleine ist auch ein Bezeichner. Ein +abgegrenzter Punkt (der nicht innerhalb einer Zahl oder eines +Bezeichners auftritt) wird in der Notation für Paare benutzt (Abschnitt +@pxref{Paare und Listen}) und um den Rest-Parameter in einer formalen +Parameterliste anzuzeigen (Abschnitt @pxref{Prozeduren}). Eine +abgegrenzte Folge von drei Punkten nacheinander ist auch ein Bezeichner. + +@item @t{( )} +Runde Klammern werden zur Gruppierung und zum Kennzeichnen von Listen +(section @pxref{Paare und Listen}). + +@item @t{'} +Ein halbes Anführungszeichen wird benutzt, um literale Daten anzuzeigen +(Abschnitt @pxref{Literale Ausdrücke}). + +@item @t{`} +Das Backquote-Zeichen wird benutzt, um fast-konstante Daten anzuzeigen +(Abschnitt @pxref{Quasimaskierung}). + +@item @t{, ,@@} +Das Kommazeichen und die Folge aus Komma und At-Zeichen werden zusammen +mit dem Backquote benutzt (Abschnitt @pxref{Quasimaskierung}). + +@item @t{"} +Das doppelte Anführungszeichen wird zum Abgrenzen von Zeichenketten +benutzt (Abschnitt @pxref{Zeichenketten}). + +@item \ +Der Backslash wird in der Syntax für Zeichen-Konstante benutzt +(Abschnitt @pxref{Zeichen}) und als ein Maskierungszeichen innerhalb von +Zeichenketten-Konstanten (Abschnitt @pxref{Zeichenketten}). + +@c A box used because \verb is not allowed in command arguments. + +@item @w{@t{[ ] @{ @} |}} +Linke und rechte eckige und geschweifte Klammern sowie der vertikale +Strich sind reserviert für mögliche spätere Erweiterungen der Sprache. + +@item # +Das Rautezeichen wird für eine Vielfalt von Zwecken benutzt, je nachdem, +welches Zeichen direkt darauf folgt: + +@item @t{#t} @t{#f} +Dies sind die booleschen Konstanten (Abschnitt @pxref{Boolesche Werte}). + +@item #\ +Dies leitet eine Zeichen-Konstante ein (Abschnitt @pxref{Zeichen}). + +@item #@t{(} +Dies leitet eine Vektor-Konstante ein (Abschnitt @pxref{Vektoren}). +Vektor-Konstante werden beendet mir @t{)} . + +@item @t{#e #i #b #o #d #x} +Diese werden zur Notation von Zahlen benutzt (Abschnitt @pxref{Syntax +numerischer Konstanter}). + +@end table + + +@c @include{basic} + +@c \vfill\eject +@node Grundkonzepte, Ausdrücke, Schreibkonventionen, top +@chapter Grundkonzepte + +@menu +* Variable; syntaktische Schlüsselwörter; und Regionen:: +* Typfremdheit:: +* Externe Darstellungen:: +* Speichermodell:: +* Echte Endrekursion:: +@end menu + + + +@node Variable; syntaktische Schlüsselwörter; und Regionen, Typfremdheit, Grundkonzepte, Grundkonzepte +@section Variable; syntaktische Schlüsselwörter; und Regionen + + + + +Ein Bezeichner darf einen Syntaxtyp benennen oder er darf +@cindex @w{Bezeichner} +eine Stelle benennen, an der ein Wert gespeichert werden kann. Ein +Bezeichner, der einen Syntaxtyp benennt, heißt ein @emph{syntaktisches +Schlüsselwort} +@cindex @w{syntaktisches Schlüsselwort} +und wird als an diese Syntax @emph{gebunden} bezeichnet. Ein +Bezeichner, der eine Stelle benennt, heißt eine @emph{Variable} und wird +als an diese Stelle +@cindex @w{Variable} +@emph{gebunden} bezeichnet. Die Menge aller sichtbaren Bindungen, die +an einem Punkt eines Programms gelten, sind +@cindex @w{Bindung} +bekannt als die an diesem Punkt geltende @emph{Umgebung}. Der Wert, der +an der Stelle, an die die Variable gebunden ist, gespeichert ist, heißt +der Wert der Variablen. Manchmal wird, die Terminologie missbrauchend, +gesagt, die Variable benenne den Wert oder sei an den Wert gebunden. +Das ist nicht ganz zutreffend, aber diese Praxis führt selten zu +Verwirrung. + +@ignore todo +Define ``assigned'' and ``unassigned'' perhaps? +@end ignore + + +@ignore todo +In programs without side effects, one can safely pretend that the +variables are bound directly to the arguments. Or: +In programs without @code{set!}, one can safely pretend that the +@vindex @w{set!} +variable is bound directly to the value. +@end ignore + + +Bestimmte Ausdruckstypen werden benutzt, um neue Arten von Syntax zu +erzeugen und um syntaktische Schlüsselwörter an diese neuen Syntaxen zu +binden, während andere Ausdruckstypen neue Stellen erzeugen und Variable +an diese Stellen binden. Diese Ausdruckstypen werden +@emph{Bindungskonstrukte} genannt. + +@cindex @w{Bindungskonstrukt} +Jene, die syntaktische Schlüsselwörter binden, werden im Abschnitt +@ref{Makros} aufgeführt. Das grundlegendste Variablenbindungskonstrukt +ist der @samp{Lambda}-Ausdruck, weil alle anderen +Variablenbindungskonstrukte als @samp{Lambda}-Ausdrücke beschrieben +werden können. Die anderen Variablenbindungskonstrukte sind die +Ausdrücke @samp{Let}, @samp{Let*}, @samp{Letrec} und @samp{Do} (siehe +die Abschnitte @pxref{Prozeduren}, @pxref{Bindungskonstrukte} und +@pxref{Iteration}). + +@c Note: internal definitions not mentioned here. + +Wie Algol und Pascal und anders als die meisten anderen Dialekte von +Lisp außer Common Lisp ist Scheme eine Sprache mit statischen +Sichtbarkeitsbereichen und einer Block-Struktur. Für jeden Ort, wo ein +Bezeichner in einem Programm gebunden wird, gibt es eine zugehörige +@dfn{Region} des Programmtexts, in der +@cindex @w{Region} +die Bindung sichtbar ist. Die Region wird durch die jeweiligen +Bindungskonstrukte bestimmt, die die Bindung herstellen; wenn die +Bindung zum Beispiel durch einen @samp{Lambda}-Ausdruck hergestellt +wird, ist ihre Region der gesamte @samp{Lambda}-Ausdruck. Jede +Erwähnung eines Bezeichners bezieht sich auf diejenige Bindung dieses +Bezeichners, die die am weitesten innen liegende diese Erwähnung +enthaltende Region hergestellt hat. Wenn keine der Regionen, in denen +diese Benutzung des Bezeichners vorkommt, eine Bindung für diesen +Bezeichner enthält, dann bezieht sich diese Benutzung auf die Bindung +der Variablen in der Umgebung auf oberster Ebene, falls vorhanden +(Kapitel @pxref{Ausdrücke} und @pxref{Standardprozeduren}); ist keine +solche Bindung des Bezeichners vorhanden, nennt man ihn +@dfn{ungebunden}. +@cindex @w{oberste Ebene} +@cindex @w{gebunden} +@cindex @w{ungebunden} + +@ignore todo +Mention that some implementations have multiple top level environments? +@end ignore + + +@ignore todo +Pitman sez: needs elaboration in case of @t{(let ...)} +@end ignore + + +@ignore todo +Pitman asks: say something about vars created after scheme starts? +@t{(define x 3) (define (f) x) (define (g) y) (define y 4)} +Clinger replies: The language was explicitly +designed to permit a view in which no variables are created after +Scheme starts. In files, you can scan out the definitions beforehand. +I think we're agreed on the principle that interactive use should +approximate that behavior as closely as possible, though we don't yet +agree on which programming environment provides the best approximation. +@end ignore + + +@node Typfremdheit, Externe Darstellung, Variable; syntaktische Schlüsselwörter; und Regionen, Grundkonzepte +@section Typfremdheit + + + +Kein Objekt erfüllt mehr als eines der folgenden Prädikate: + + +@example + +boolean? pair? +symbol? number? +char? string? +vector? port? +procedure? + +@end example + + +Diese Prädikaten definieren die Typen @emph{Boolean} (boolescher Typ), +@emph{Pair} (Paar), @emph{Symbol} (Symbol), @emph{Number} (Zahl), +@emph{Char} (oder @emph{Character}, deutsch Zeichen), @emph{String} +(Zeichenkette), @emph{Vector} (Vektor), @emph{Port} (Port) und +@emph{Procedure} (Prozedur). Die leere Liste ist ein besonderes Objekt +und hat ihren eigenen Typ; sie erfüllt keines der obigen Prädikate. + +@vindex symbol? +@vindex pair? +@vindex boolean? +@cindex @w{Typ} + +@vindex vector? +@vindex string? +@vindex char? +@vindex number? + +@cindex @w{leere Liste} +@vindex procedure? +@vindex port? + +Obwohl es einen gesonderten booleschen Typ gibt, kann jeder Scheme-Wert +als ein boolescher Wert zum Prüfen einer Bedingung benutzt werden. Wie +im Abschnitt @ref{Boolesche Werte} erklärt wird, gelten alle Werte beim +Prüfen als wahr außer @t{#f}. +@c and possibly the empty list. +@c The only value that is guaranteed to count as +@c false is \schfalse{}. It is explicitly unspecified whether the empty list +@c counts as true or as false. +Dieser Bericht benutzt das Wort „wahr`` für einen beliebigen +Scheme-Wert außer @t{#f} und der Bericht benutzt das Wort „falsch`` für +@t{#f}. +@cindex @w{falsch} +@cindex @w{wahr} + +@node Externe Darstellungen, Speichermodell, Typfremdheit, Grundkonzepte +@section Externe Darstellungen + + + +Ein wichtiges Konzept in Scheme (und Lisp) ist das der @emph{externen +Darstellung} eines Objekts als eine Folge von Zeichen. Zum Beispiel ist +eine externe Darstellung der ganzen Zahl 28 die Zeichenfolge „@t{28}`` +und eine externe Darstellung einer Liste bestehend aus den ganzen Zahlen +8 und 13 ist die Zeichenfolge „@t{(8 13)}``. + +Die externe Darstellung eines Objekts muss nicht eindeutig sein. Die +ganze Zahl 28 hat auch die Darstellungen „@t{#e28.000}`` und +„@t{#x1c}``, die Liste im vorherigen Absatz hat auch die Darstellungen +„@t{( 08 13 )}`` und „@t{(8 .@: (13 .@: ()))}`` (siehe den Abschnitt +@pxref{Paare und Listen}). + +Viele Objekte haben Standarddarstellungen als externe Darstellung, aber +manche, wie Prozeduren, haben keine Standarddarstellungen (auch wenn +bestimmte Implementierungen für sie Darstellungen festlegen dürfen). + +Eine externe Darstellung darf in ein Programm geschrieben werden, um das +zugehörige Objekt zu erhalten (siehe @samp{Quote}, Abschnitt +@pxref{Literale Ausdrücke}). + +Externe Darstellungen können auch zur Eingabe und Ausgabe benutzt +werden. Die Prozedur @samp{Read} (Abschnitt @pxref{Eingabe}) wandelt +externe Darstellungen um und die Prozedur @samp{Write} (Abschnitt +@pxref{Ausgabe}) erzeugt solche. Zusammen bieten sie ein elegantes und +mächtiges Mittel zur Ein- und Ausgabe. + +Beachten Sie, dass die Zeichenfolge „@t{(+ 2 6)}`` @emph{keine} externe +Darstellung für die ganze Zahl 8 ist, wenn sie auch ein Ausdruck +@emph{ist}, der zu der ganzen Zahl 8 ausgewertet wird; stattdessen ist +sie eine externe Darstellung einer dreielementigen Liste, deren Elemente +das Symbol @t{+} und die ganzen Zahlen 2 und 6 sind. Die Syntax von +Scheme hat die Eigenschaft, dass eine beliebige Zeichenfolge, die ein +Ausdruck ist, auch die externe Darstellung irgendeines Objekts ist. +Dies kann zu Verwirrung führen, da es ohne Kontext nicht offensichtlich +sein kann, ob eine bestimmte Zeichenfolge Daten oder Programm bezeichnen +soll, es ist aber auch eine Quelle der Macht, da so das Schreiben von +Programmen wie Interpretern und Übersetzern erleichtert wird, die +Programme als Daten behandeln (oder umgekehrt). + +Die Syntax externer Darstellungen verschiedener Arten von Objekten +begleitet die Beschreibungen der Grundoperationen, um die Objekte zu +manipulieren, welche in den jeweiligen Abschnitten des Kapitels +@ref{Standardprozeduren} zu finden sind. + +@node Speichermodell, Echte Endrekursion, Externe Darstellungen, Grundkonzepte +@section Speichermodell + + + +Variable und Objekte wie Paare, Vektoren und Zeichenketten bezeichnen +implizit Speicherstellen oder Folgen von Speicherstellen. Zum Beispiel +bezeichnet eine Zeichenkette +@cindex @w{Stelle} +so viele Stellen, wie es Zeichen in der Zeichenkette gibt. (Diese +Stellen müssen keinem ganzen Maschinenwort entsprechen.) Ein neuer Wert +darf mit der Prozedur @t{String-set!} in einer dieser Stellen +gespeichert werden, aber die Zeichenkette bezeichnet dann noch immer +dieselben Stellen wie vorher. + +Ein von einer Stelle geholtes Objekt, durch Variablenreferenz oder durch +eine Prozedur wie @samp{Car}, @samp{Vector-ref} oder @samp{String-ref} +ist im Sinne von @code{Eqv?} gleichwertig +@c and \ide{eq?} ?? +(Abschnitt @pxref{Äquivalenzprädikate}) +@vindex @w{eqv?} +zum Objekt, was vor dem Holen zuletzt an der Stelle gespeichert war. + +Jede Stelle wird markiert, um anzuzeigen, ob sie in Benutzung ist. +Keine Variable und kein Objekt bezieht sich je auf eine Stelle, die +nicht in Benutzung ist. Wann immer dieser Bericht davon spricht, dass +Speicher für eine Variable oder ein Objekt zugeteilt wird, ist damit +gemeint, dass eine entsprechende Anzahl von Stellen aus der Menge +unbenutzer Stellen gewählt wird und die ausgewählten Stellen markiert +werden, um anzuzeigen, dass sie nun benutzt sind, bevor die Variable +oder das Objekt dazu gebracht wird, diese Stellen zu bezeichnen. + +In vielen Systemen ist es wünschenswert, dass sich Konstante (@abbr{d.h.} die +Werte von +@cindex @w{Konstante} +literalen Ausdrücken) in Nur-Lese-Speicher befinden. Um dies +auszudrücken, ist es gelegen sich vorzustellen, dass jedes Objekt, +welches Stellen bezeichnet, mit einer Markierung assoziiert ist, die +angibt, ob das Objekt veränderlich +@cindex @w{veränderlich} +oder unveränderlich ist. In solchen Systemen sind literale Konstante +und die Zeichenketten, +@cindex @w{unveränderlich} +die @code{symbol->string} zurückgibt, unveränderliche Objekte, während +alle Objekte, +@vindex @w{Symbol->string} +die durch andere in diesem Bericht angegebene Prozeduren erzeugt wurden, +veränderlich sind. Es ist ein Fehler zu versuchen, einen neuen Wert an +eine Stelle zu speichern, die von einem unveränderlichen Objekt +bezeichnet wird. + +@node Echte Endrekursion, , Speichermodell, Grundkonzepte +@section Echte Endrekursion + + + +Implementierungen von Scheme müssen +@emph{echt endrekursiv}. +@cindex @w{echte Endrekursion} +sein. Prozeduraufrufe, die in den unten beschriebenen bestimmten +syntaktischen Kontexten vorkommen, sind ,endständige Aufrufe`. Eine +Scheme-Implementierung ist echt endrekursiv, wenn sie eine unbeschränkte +Anzahl von aktiven endständigen Aufrufen unterstützt. Ein Aufruf ist +@emph{aktiv}, wenn die aufgerufene Prozedur noch immer einen Rücksprung +durchführen, @abbr{d.h.} einen Wert zurückgeben, kann. Beachten Sie, +dass dies alle Aufrufe einschließt, die entweder von der aktuellen +Fortsetzung oder von zuvor mit @samp{Call-with-current-continuation} +gefangenen Fortsetzungen, die später aufgerufen werden, einschließt. +Ohne gefangene Fortsetzungen könnten Aufrufe höchstens einen Rücksprung +durchführen und aktive Aufrufe wären diejenigen, die noch keinen +Rücksprung durchgeführt haben. Eine formale Definition von echter +Endrekursion ist in [propertailrecursion] zu finden. + + +@quotation +@emph{Begründung:} + +Intuitiv wird kein Speicher für einen aktiven endständigen Aufruf +benötigt, weil die Fortsetzung, die im endständigen Aufruf benutzt wird, +dieselbe Semantik hat wie die Fortsetzung, die der den Aufruf +enthaltenden Prozedur übergeben wurde. Obwohl eine nicht richtige +Implementierung in diesem Aufruf eine neue Fortsetzung benutzen könnte, +würde ein Rücksprung zu dieser neuen Fortsetzung einen sofortigen +Rücksprung zu der der Prozedur übergebenen Fortsetzung nach sich ziehen. +Eine echt endrekursive Implementierung springt direkt zu dieser +übergebenen Fortsetzung zurück. + +Echte Endrekursion war eine der zentralen Ideen in Steeles und Sussmans +ursprünglicher Fassung von Scheme. Ihr erster Scheme-Interpreter +implementierte sowohl Funktionen als auch Akteure. Programmfluss wurde +über Akteure ausgedrückt, welche sich darin von Funktionen +unterschieden, dass sie ihre Ergebnisse einem anderen Akteur übergaben +statt an den Aufrufer. In der Terminologie dieses Abschnitts endete +jeder Akteur mit einem endständigen Aufruf an einen anderen Akteur. + +Steele und Sussman beobachteten später, dass der Code in ihrem +Interpreter, der mit Akteuren umging, identisch war mit dem für +Funktionen und es daher keinen Grund dafür gab, beide in die Sprache +aufzunehmen. + +@end quotation + + +Ein @emph{endständiger Aufruf} ist ein Prozeduraufruf, der +@cindex @w{endständiger Aufruf} +@emph{endständig} auftritt. Endständigkeit ist induktiv definiert. +Beachten Sie, dass Endständigkeit immer in Bezug auf einen bestimmten +Lambda-Ausdruck bestimmt wird. + + + +@itemize @bullet + +@item +Der letzte Ausdruck im Rumpf eines Lambda-Ausdrucks, unten dargestellt +als @r{<endständiger Ausdruck>} tritt endständig auf. + +@format +@t{(lambda <Formale> + <Definition>* <Ausdruck>* <endständiger Ausdruck>) +} + +@end format + + + +@item +Wenn einer der folgenden Ausdrücke endständig ist, sind die als +<endständiger Ausdruck> dargestellten Unterausdrücke endständig. Diese +wurden über die Regeln der im Kapitel @ref{Formale Syntax und Semantik} +angegebenen Grammatik abgeleitet, durch Ersetzung der Vorkommen von +<Ausdruck> durch <endständiger Ausdruck>. Hier sind nur die Regeln +dargestellt, die Endständigkeit enthalten. + + +@format +@t{(if <Ausdruck> <endständiger Ausdruck> <endständiger Ausdruck>) +(if <Ausdruck> <endständiger Ausdruck>) + +(cond <cond-Klausel>+) +(cond <cond-Klausel>* (else <endständige Folge>)) + +(case <Ausdruck> + <case-Klausel>+) +(case <Ausdruck> + <case-Klausel>* + (else <endständige Folge>)) + +(and <Ausdruck>* <endständiger Ausdruck>) +(or <Ausdruck>* <endständiger Ausdruck>) + +(let (<Bindungsspezifikation>*) <endständiger Rumpf>) +(let <Variable> (<Bindungsspezifikation>*) <endständiger Rumpf>) +(let* (<Bindungsspezifikation>*) <endständiger Rumpf>) +(letrec (<Bindungsspezifikation>*) <endständiger Rumpf>) + +(let-syntax (<Syntaxspezifikation>*) <endständiger Rumpf>) +(letrec-syntax (<Syntaxspezifikation>*) <endständiger Rumpf>) + +(begin <endständige Folge>) + +(do (<Iterationsspezifikation>*) + (<Test> <endständige Folge>) + <Ausdruck>*) + +@r{where} + +<cond-Klausel> --> (<Test> <endständige Folge>) +<case-Klausel> --> ((<Datenelement>*) <endständige Folge>) + +<endständiger Rumpf> --> <Definition>* <endständige Folge> +<endständige Folge> --> <Ausdruck>* <endständiger Ausdruck> +} + +@end format + + + +@item +Wenn ein @samp{Cond}-Ausdruck entständig auftritt und eine Klausel der +Form @samp{(@r{<Ausdruck1>} => @r{<Ausdruck2>})} enthält, dann ist der +(implizite) Aufruf der Prozedur, die sich aus der Auswertung von +@r{<Ausdruck2>} ergibt, endständig. @r{<Ausdruck2>} selbst ist nicht +endständig. + + +@end itemize + + +Bestimmte eingebaute Prozeduren müssen auch endrekursive Aufrufe +durchführen. Das erste an @code{apply} und an +@vindex @w{apply} +@code{call-with-current-continuation} übergebene Argument sowie das +zweite an +@vindex @w{call-with-current-continuation} +@code{call-with-values} übergebene Argument muss endrekursiv aufgerufen +werden. +@vindex @w{call-with-values} +Ebenso muss @code{eval} sein Argument so auswerten, als wäre es +@vindex @w{eval} +innerhalb der @code{eval}-Prozedur endständig. +@vindex @w{eval} + +Im folgenden Beispiel ist der einzige endrekursive Aufruf der Aufruf von +@samp{f}. Keiner der Aufrufe von @samp{g} oder @samp{h} sind +endrekursive Aufrufe. Die Referenz auf @samp{x} ist endständig, aber +sie ist kein Aufruf und daher nicht endrekursiv. + +@example + +(lambda () + (if (g) + (let ((x (h))) + x) + (and (g) (f)))) + +@end example + + + +@quotation +@emph{Anmerkung:} +Implementierungen dürfen, sie müssen aber nicht, erkennen, dass einige +der nicht endrekursiven Aufrufe, wie oben der Aufruf von @samp{h}, +ausgewertet werden können, als wären sie endrekursiv. Im obigen +Beispiel könnte der @samp{Let}-Ausdruck zu einem endrekursiven Aufruf +von @samp{h} übersetzt werden. (Die Möglichkeit, dass @samp{h} eine +unerwartete Anzahl von Werten zurückgibt, kann ignoriert werden, weil +dann die Wirkung des @samp{Let} ausdrücklich unbestimmt und +implementierungsabhängig ist.) +@end quotation + + + +@c @include{expr} + +@c \vfill\eject +@node Ausdrücke, Programmstruktur, Grundkonzepte, top +@chapter Ausdrücke + +@menu +* Grundlegende Ausdruckstypen:: +* Abgeleitete Ausdruckstypen:: +* Makros:: +@end menu + + + +@c \newcommand{\syntax}{{\em Syntax: }} +@c \newcommand{\semantics}{{\em Semantics: }} + +@c [Deleted for R5RS because of multiple-value returns. -RK] +@c A Scheme expression is a construct that returns a value, such as a +@c variable reference, literal, procedure call, or conditional. + +Ausdruckstypen werden eingeteilt in @emph{grundlegende} oder in +@emph{abgeleitete} Ausdruckstypen. Grundlegende Ausdruckstypen +schließen Variable und Prozeduraufrufe ein. Abgeleitete Ausdrückstypen +sind nicht semantisch grundlegend, sondern können stattdessen als Makros +definiert werden. Mit Ausnahme von @samp{Quasiquote} zur +Quasimaskierung, dessen Makrodefinition komplex ist, werden die +abgeleiteten Ausdrücke zu den Bibliotheksfunktionalitäten gezählt. +Angemessene Definitionen werden im Abschnitt @ref{Abgeleitete +Ausdruckstypen} vorgestellt. + +@node Grundlegende Ausdruckstypen, Abgeleitete Ausdruckstypen, Ausdrücke, Ausdrücke +@section Grundlegende Ausdruckstypen + +@menu +* Variablenreferenzen:: +* Literale Ausdrücke:: +* Prozeduraufrufe:: +* Prozeduren:: +* Bedingungen:: +* Zuweisungen:: +@end menu + + + +@node Variablenreferenzen, Literale Ausdrücke, Grundlegende Ausdruckstypen, Grundlegende Ausdruckstypen +@subsection Variablenreferenzen + + + +@deffn {Syntax} @r{<Variable>} + + +Ein Ausdruck, der aus einer Variablen +@cindex @w{Variable} +(Abschnitt @pxref{Variable; syntaktische Schlüsselwörter; und Regionen}) +besteht, ist eine Variablenreferenz. Der Wert der Variablenreferenz ist +der an der Stelle, an die die Variable gebunden ist, gespeicherte Wert. +Es ist ein Fehler, eine ungebundene Variable zu referenzieren. +@cindex @w{ungebunden} + + +@format +@t{(define x 28) +x ==> 28 +} +@end format + +@end deffn + +@node Literale Ausdrücke, Prozeduraufrufe, Variablenreferenzen, Grundlegende Ausdruckstypen +@subsection Literale Ausdrücke + + + + +@deffn {Syntax} quote @r{<Datenelement>} + +@deffnx {Syntax} @t{'}@r{<Datenelement>} + + +@deffnx {Syntax} @r{<Konstante>} + + +@samp{(quote @r{<Datenelement>})} wird ausgewertet zu @r{<Datenelement>}. +Durch @samp{Quote} wird das @r{<Datenelement>} @emph{maskiert}. +@cindex @w{'} +@r{<Datenelement>} darf eine beliebige externe Darstellung eines +Scheme-Objekts sein (siehe den Abschnitt @pxref{Externe Darstellungen}). +Diese Notation wird zum Einfügen literaler Konstanter in Scheme-Code +benutzt. + + +@format +@t{ +(quote a) ==> a +(quote #(a b c)) ==> #(a b c) +(quote (+ 1 2)) ==> (+ 1 2) +} +@end format + + +@samp{(quote @r{<Datenelement>})} darf abgekürzt werden als +@t{'}@r{<Datenelement>}. Die beiden Notationen sind in allen Bezügen +äquivalent. + + +@format +@t{'a ==> a +'#(a b c) ==> #(a b c) +'() ==> () +'(+ 1 2) ==> (+ 1 2) +'(quote a) ==> (quote a) +''a ==> (quote a) +} +@end format + + +Numerische Konstante, Zeichenkettenkonstante, Zeichenkonstante und +boolesche Konstante werden „zu sich selbst`` ausgewertet; sie müssen +nicht mit @samp{Quote} maskiert werden. + + +@format +@t{'"abc" ==> "abc" +"abc" ==> "abc" +'145932 ==> 145932 +145932 ==> 145932 +'#t ==> #t +#t ==> #t +} +@end format + + +Wie im Abschnitt @ref{Speichermodell} angemerkt ist es ein Fehler, eine +Konstante (@abbr{d.h.} den Wert eines literalen Ausdrucks) mit einer +Veränderungsprozedur wie @samp{Set-car!} oder @samp{String-set!} +abzuändern. + +@end deffn + + +@node Prozeduraufrufe, Prozeduren, Literale Ausdrücke, Grundlegende Ausdruckstypen +@subsection Prozeduraufrufe + + + +@deffn {Syntax} @r{<Operator>} @r{<Operand1>} @dots{}, + + +Ein Prozeduraufruf wird geschrieben, indem man einfach die Ausdrücke für +die aufzurufende Prozedur und die ihr zu übergebenden Argumente mit +runden Klammern umschließt. Die Operator- und Operand-Ausdrücke werden +(in unbestimmter Reihenfolge) ausgewertet und der daraus hervorgehenden +Prozedur werden die sich ergebenden Argumente übergeben. +@cindex @w{Prozeduraufruf} +@cindex @w{Aufruf} + +@format +@t{ +(+ 3 4) ==> 7 +((if #f + *) 3 4) ==> 12 +} +@end format + + +Eine Menge von Prozeduren sind schon als die Werte von Variablen in der +Anfangsumgebung verfügbar; zum Beispiel sind die Prozeduren für die +Addition und Multiplikation in obigen Beispielen die Werte der Variablen +@samp{+} und @samp{*}. Neue Prozeduren entstehen durch das Auswerten +von Lambda-Ausdrücken (siehe den Abschnitt @pxref{Prozeduren}). +@ignore todo +At Friedman's request, flushed mention of other ways. +@end ignore + +@c or definitions (see section~\ref{define}). + +Prozeduraufrufe dürfen eine beliebige Anzahl von Werten zurückgeben +(siehe @code{values} im +@vindex @w{values} +Abschnitt @pxref{Programmflussfunktionalitäten}). Mit Ausnahme von +@samp{Values} geben die in der Anfangsumgebung verfügbaren Prozeduren +einen Wert oder, bei Prozeduren wie @samp{Apply}, genau die Werte, die +ein Aufruf eines ihrer Argumente zurückgibt, zurück. . + +Prozeduraufrufe werden auch @emph{Kombinationen} genannt. + +@cindex @w{Kombination} + + +@quotation +@emph{Anmerkung:} Anders als bei anderen Dialekten von Lisp ist die +Auswertungsreihenfolge unbestimmt und die Ausdrücke für den Operator und +die Operanden werden immer nach denselben Auswertungsregeln ausgewertet. +@end quotation + + + +@quotation +@emph{Anmerkung:} +Obwohl die Auswertungsreihenfolge ansonsten unbestimmt ist, ist die +Wirkung einer beliebigen nebenläufigen Auswertung von Operator- und +Operandausdrücken so weit eingeschränkt, dass sie mit der Wirkung bei +einer beliebigen sequentiellen Auswertungsreihenfolge übereinstimmen +muss. Die Auswertungsreihenfolge darf für jeden Prozeduraufruf +unterschiedlich gewählt werden. +@end quotation + + + +@quotation +@emph{Anmerkung:} +In vielen Dialekten von Lisp ist die leere Kombination @t{()} ein +zulässiger Ausdruck. In Scheme müssen Kombinationen mindestens einen +Unterausdruck haben, so dass @t{()} kein syntaktisch gültiger Ausdruck +ist. +@ignore todo +Dybvig: ``it should be obvious from the syntax.'' +@end ignore + +@end quotation + + +@ignore todo +Freeman: +I think an explanation as to why evaluation order is not specified +should be included. It should not include any reference to parallel +evaluation. Does any existing compiler generate better code because +the evaluation order is unspecified? Clinger: yes: T3, MacScheme v2, +probably MIT Scheme and Chez Scheme. But that's not the main reason +for leaving the order unspecified. +@end ignore + + +@end deffn + + +@node Prozeduren, Bedingungen, Prozeduraufrufe, Grundlegende Ausdruckstypen +@subsection Prozeduren + + + + +@deffn {Syntax} lambda @r{<Formale>} @r{<Rumpf>} + +@emph{Syntax:} +@r{<Formale>} sollte eine Liste formaler Argumente sein, wie sie unten +beschrieben ist, und @r{<Rumpf>} sollte eine Folge von einem oder mehr +Ausdrücken sein. + +@emph{Semantik:} +Ein Lambda-Ausdruck wird immer zu einer Prozedur ausgewertet. Die +Umgebung, die bestand, während der Lambda-Ausdruck ausgewertet wurde, +wird als Teil der Prozedur gespeichert. Wird die Prozedur später mit +tatsächlichen Argumenten aufgerufen, wird die Umgebung, in der der +Lambda-Ausdruck ausgewertet wurde, erweitert, indem die Variablen in der +Liste formaler Argumente an neue Stellen gebunden werden, dann werden +die entssprechenden tatsächlichen Argumentwerte an diese Stellen +gespeichert und die Ausdrücke im Rumpf des Lambda-Ausdrucks werden der +Reihe nach in der erweiterten Umgebung ausgewertet. Das oder die +Ergebnisse des letzten Ausdrucks im Rumpf wird @abbr{bzw.} werden als +das oder die Ergebnisse des Prozeduraufrufs zurückgegeben. + + +@format +@t{(lambda (x) (+ x x)) ==> @emph{}eine Prozedur +((lambda (x) (+ x x)) 4) ==> 8 + +(define reverse-subtract ; rückwärts subtrahieren + (lambda (x y) (- y x))) +(reverse-subtract 7 10) ==> 3 + +(define add4 + (let ((x 4)) + (lambda (y) (+ x y)))) +(add4 6) ==> 10 +} +@end format + + +@r{<Formale>} sollte eine der folgenden Formen haben: + + + +@itemize @bullet + +@item +@t{(@r{<Variable1>} @dots{},)}: +Die Prozedur nimmt eine feste Anzahl von Argumenten; wenn die Prozedur +aufgerufen wird, werden die Argumente in den Bindungen der +entsprechenden Variablen gespeichert. + +@item +@r{<Variable>}: +Die Prozedur nimmt eine beliebige Anzahl von Argumenten entgegen; wird +die Prozedur aufgerufen, wird die Folge aus den tatsächlichen Argumenten +in eine neu angeforderte Liste umgewandelt und diese Liste in der +Bindung von @r{<Variable>} gespeichert. + +@item +@t{(@r{<Variable1>} @dots{}, @r{<Variable_n>} @b{.} +@r{<Variable_n+1>})}: +Wenn ein durch ein Leerzeichen abgetrennter Punkt vor der letzten +Variablen steht, dann nimmt die Prozedur n oder mehr Argumente, wobei n +die Anzahl formaler Argumente vor dem Punkt ist (es muss mindestens +eines geben). Der Wert, der in der Bindung der letzten Variablen +gespeichert wird, wird der einer neu angeforderten Liste derjenigen +tatsächlichen Argumente sein, die nach Verteilung aller anderen +tatsächlichen Argumente auf die anderen formalen Argumenten übrig +bleiben. + +@end itemize + + +Es ist ein Fehler, wenn eine @r{<Variable>} mehr als einmal in +@r{<Formale>} vorkommt. + + +@format +@t{((lambda x x) 3 4 5 6) ==> (3 4 5 6) +((lambda (x y . z) z) + 3 4 5 6) ==> (5 6) +} +@end format + + +Jede Prozedur, die durch das Auswerten eines Lambda-Ausdrucks entsteht, +wird (konzeptionell) mit einer Speicherstelle beschriftet, damit +@code{eqv?} und +@vindex @w{eqv?} +@code{eq?} mit Prozeduren umgehen können (siehe den Abschnitt +@pxref{Äquivalenzprädikate}). +@vindex @w{eq?} + +@end deffn + + +@node Bedingungen, Zuweisungen, Prozeduren, Grundlegende Ausdruckstypen +@subsection Bedingungen + + + +@deffn {Syntax} if @r{<Test>} @r{<Folgerung>} @r{<Alternative>} +@deffnx {Syntax} if @r{<Test>} @r{<Folgerung>} +@c \/ if hyper = italic + +@emph{Syntax:} @r{<Test>}, @r{<Folgerung>} und @r{<Alternative>} dürfen +beliebige Ausdrücke sein. + +@emph{Semantik:} +Ein @samp{If}-Ausdruck wird wie folgt ausgewertet: Zuerst wird +@r{<Test>} ausgewertet. Wenn er einen wahren Wert liefert (siehe +@cindex @w{wahr} +den Abschnitt @pxref{Boolesche Werte}), dann wird @r{<Folgerung>} +ausgewertet und ihr(e) Wert(e) zurückgegeben. Ansonsten wird +@r{<Alternative>} ausgewertet und ihr(e) Wert(e) zurückgegeben. Wenn +@r{<Test>} einen falschen Wert liefert und keine @r{<Alternative>} +angegeben wurde, ist das Ergebnis des Ausdrucks unbestimmt. + + +@format +@t{(if (> 3 2) 'ja 'nein) ==> ja +(if (> 2 3) 'ja 'nein) ==> nein +(if (> 3 2) + (- 3 2) + (+ 3 2)) ==> 1 +} +@end format + + +@end deffn + + +@node Zuweisungen, , Bedingungen, Grundlegende Ausdruckstypen +@subsection Zuweisungen + + + + +@deffn {Syntax} set! @r{<Variable>} @r{<Ausdruck>} + +@r{<Ausdruck>} wird ausgewertet und der sich ergebende Wert an der +Stelle gespeichert, an die @r{<Variable>} gebunden ist. @r{<Variable>} +muss entweder in einer Region gebunden sein, die den +@samp{Set!}-Ausdruck einschließt, +@cindex @w{Region} +oder auf oberster Ebene gebunden sein. Das Ergebnis des +@samp{Set!}-Ausdrucks ist unbestimmt. + + +@format +@t{(define x 2) +(+ x 1) ==> 3 +(set! x 4) ==> @emph{unbestimmt} +(+ x 1) ==> 5 +} +@end format + + +@end deffn + + +@node Abgeleitete Ausdruckstypen, Makros, Grundlegende Ausdruckstypen, Ausdrücke +@section Abgeleitete Ausdruckstypen + +@menu +* Bedingung:: +* Bindungskonstrukte:: +* Sequenzierung:: +* Iteration:: +* Verzögerte Auswertung:: +* Quasimaskierung:: +@end menu + + + +Die Konstrukte in diesem Abschnitt sind hygienisch, wie im Abschnitt +@ref{Makros} diskuttiert. +Als Referenz sind im Abschnitt @ref{Abgeleitete Ausdruckstypen} +Makrodefinitionen zu finden, die die meisten hier beschriebenen +Konstrukte in grundlegende Konstrukte, die im vorherigen Abschnitt +beschrieben wurden, umwandeln. + +@ignore todo +Mention that no definition of backquote is provided? +@end ignore + + +@node Bedingung, Bindungskonstrukte, Abgeleitete Ausdruckstypen, Abgeleitete Ausdruckstypen +@subsection Bedingungen + + + +@deffn {Bibliothekssyntax} cond <Klausel1> <Klausel2> @dots{}, + +@emph{Syntax:} +Jede @r{<Klausel>} sollte entweder folgende Form haben: + +@format +@t{(@r{<Test>} @r{<Ausdruck1>} @dots{},) +} +@end format + +wobei @r{<Test>} ein beliebiger Ausdruck ist, oder die @r{<Klausel>} hat +alternativ diese Form: + +@format +@t{(@r{<Test>} => @r{<Ausdruck>}) +} +@end format + +Die letzte @r{<Klausel>} darf auch eine „else-Klausel`` sein, welche +die folgende Form hat: + +@format +@t{(else @r{<Ausdruck1>} @r{<Ausdruck2>} @dots{},)@r{.} +} +@end format + + +@cindex @w{Else} + +@cindex @w{=>} + +@emph{Semantik:} +Ein @samp{Cond}-Ausdruck wird ausgewertet, indem man der Reihe nach die +@r{<Test>}-Ausdrücke der aufeinanderfolgenden @r{<Klausel>}n auswertet, +bis eine von ihnen zu einem wahren Wert ausgewertet wird (siehe +@cindex @w{wahr} +den Abschnitt @pxref{Boolesche Werte}). Sobald ein @r{<Test>} zu einem +wahren Wert ausgewertet wird, werden die verbleibenden in seiner +@r{<Klausel>} stehenden Vorkommen eines @r{<Ausdruck>}s der Reihe nach +ausgewertet und das Ergebnis @abbr{bzw.} die Ergebnisse des letzten +@r{<Ausdruck>}s in der @r{<Klausel>} wird(werden) als Ergebnis(se) des +gesamten @samp{Cond}-Ausdrucks zurückgegeben. Wenn die gewählte +@r{<Klausel>} nur den @r{<Test>} und keine Vorkommen von @r{<Ausdruck>} +enthält, dann wird der Wert vom @r{<Test>} als Ergebnis zurückgegeben. +Wenn die gewählte @r{<Klausel>} die alternative Form mit @code{=>} +benutzt, dann wird der @r{<Ausdruck>} ausgewertet. +@vindex @w{=>} +Sein Wert muss eine Prozedur sein, die ein Argument annimmt; diese +Prozedur wird dann mit dem Wert vom @r{<Test>} aufgerufen und der von +dieser Prozedur zurückgegebene Wert @abbr{bzw.} die von ihr +zurückgegebenen Werte werden dann auch vom @samp{Cond}-Ausdruck +zurückgegeben. Wenn jeder @r{<Test>} zu falschen Werten ausgewertet +wird und es keine else-Klausel gibt, dann ist das Ergebnis des bedingten +Ausdrucks unbestimmt; gibt es eine else-Klausel, dann werden seine +@r{<Ausdruck>}-Vorkommen ausgewertet und der Wert @abbr{bzw.} die Werte +des letzten Ausdrucks zurückgegeben + + +Das folgende Beispiel nimmt an, dass die benutzte Scheme-Implementierung +die Umlaute und das scharfe S (ß) auch als Buchstabenzeichen ansieht, +als Erweiterung zur in diesem Bericht spezifizierten Syntax: + +@format +@t{(cond ((> 3 2) 'größer) + ((< 3 2) 'kleiner)) ==> größer + +(cond ((> 3 3) 'größer) + ((< 3 3) 'kleiner) + (else 'gleich)) ==> gleich + +(cond ((assv 'b '((a 1) (b 2))) => cadr) + (else #f)) ==> 2 +} +@end format + + + +@end deffn + + + +@deffn {Bibliothekssyntax} case @r{<Schlüssel>} <Klausel1> <Klausel2> @dots{}, + +@emph{Syntax:} +@r{<Schlüssel>} darf ein beliebiger Ausdruck sein. Jede @r{<Klausel>} +sollte die folgende Form haben: + +@format +@t{((@r{<Datenelement1>} @dots{},) @r{<Ausdruck1>} @r{<Ausdruck2>} @dots{},)@r{,} +} +@end format + +wobei jedes @r{<Datenelement>} eine externe Darstellung irgendeines +Objekts ist. Alle @r{<Datenelement>}e müssen verschieden sein. Die +letzte @r{<Klausel>} darf eine „else-Klausel`` sein, welche die folgende +Form hat: + +@format +@t{(else @r{<Ausdruck1>} @r{<Ausdruck2>} @dots{},)@r{.} +} +@end format + + +@vindex else + +@emph{Semantik:} +Ein @samp{Case}-Ausdruck wird wie folgt ausgewertet. @r{<Schlüssel>} +wird ausgewertet und sein Ergebnis mit jedem @r{<Datenelement>} +verglichen. Wenn das Ergebnis der Auswertung von @r{<Schlüssel>} +gleichwertig ist (im Sinne von @samp{Eqv?}; siehe den Abschnitt +@pxref{Äquivalenzprädikate}) mit einem @r{<Datenelement>}, dann werden +die Ausdrücke in der entsprechenden @r{<Klausel>} von links nach rechts +ausgewertet und das Ergebnis @abbr{bzw.} die Ergebnisse des letzten +Ausdrucks in der @r{<Klausel>} werden als Ergebnis(se) des +@samp{Case}-Ausdrucks zurückgegeben. Wenn die Auswertung von +@r{<Schlüssel>} zu einem anderen Ergebnis als jedes @r{<Datenelement>} +führt, dann werden, wenn es eine else-Klausel gibt, ihre Ausdrücke +ausgewertet und das Ergebnis @abbr{bzw.} die Ergebnisse des letzten +davon ist das Ergebnis @abbr{bzw.} sind die Ergebnisse des +@samp{Case}-Ausdrucks; andernfalls ist das Ergebnis des +@samp{Case}-Ausdrucks unbestimmt. + + +@format +@t{(case (* 2 3) + ((2 3 5 7) 'prim) + ((1 4 6 8 9) 'zusammengesetzt)) ==> zusammengesetzt +(case (car '(c d)) + ((a) 'a) + ((b) 'b)) ==> @emph{unbestimmt} +(case (car '(c d)) + ((a e i o u) 'Vokal) + ((j) 'Halbvokal) + (else 'Konsonant)) ==> Konsonant +} +@end format + + +@end deffn + + + +@deffn {Bibliothekssyntax} and <Test1> @dots{}, + +Die @r{<Test>}-Ausdrücke werden von links nach rechts ausgewertet und +der Wert des ersten Ausdrucks, der zu einem falschen Wert ausgewertet +wird (siehe den Abschnitt @pxref{Boolesche Werte}) wird zurückgegeben. +Jegliche verbleibenden Ausdrücke werden nicht ausgewertet. Wenn alle +Ausdrücke zu wahren Werten ausgewertet werden, wird der Wert des letzten +Ausdrucks zurückgegeben. Gibt es keine Ausdrücke, so wird @t{#t} +zurückgegeben. + + +@format +@t{(and (= 2 2) (> 2 1)) ==> #t +(and (= 2 2) (< 2 1)) ==> #f +(and 1 2 'c '(f g)) ==> (f g) +(and) ==> #t +} +@end format + + +@end deffn + + + +@deffn {Bibliothekssyntax} or <Test1> @dots{}, + +Die @r{<Test>}-Ausdrücke werden von links nach rechts ausgewertet und +der Wert des ersten Ausdrucks, der zu einem wahren Wert ausgewertet wird +(siehe den Abschnitt @pxref{Boolesche Werte}) wird zurückgegeben. +Jegliche verbleibenden Ausdrücke werden nicht ausgewertet. Wenn alle +Ausdrücke zu falschen Werten ausgewertet werden, wird der Wert des +letzten Ausdrucks zurückgegeben. Gibt es keine Ausdrücke, so wird +@t{#f} zurückgegeben. + + +@format +@t{(or (= 2 2) (> 2 1)) ==> #t +(or (= 2 2) (< 2 1)) ==> #t +(or #f #f #f) ==> #f +(or (memq 'b '(a b c)) + (/ 3 0)) ==> (b c) +} +@end format + + +@end deffn + + +@node Bindungskonstrukte, Sequenzierung, Bedingungen, Abgeleitete Ausdruckstypen +@subsection Bindungskonstrukte + + +Die drei Bindungskonstrukte @samp{Let}, @samp{Let*} und @samp{Letrec} +verleihen Scheme eine Block-Struktur wie bei Algol 60. [Auf Deutsch +heißt „Let ...`` soviel wie „Sei ...``.] Die Syntax der drei Konstrukte +ist identisch, aber sie unterscheiden sich in den Regionen, die sie für +ihre Variablenbindungen herstellen +@cindex @w{Region} +In einem @samp{Let}-Ausdruck werden die Anfangswerte berechnet, bevor +ihre Variablen gebunden werden; in einem @samp{Let*}-Ausdruck werden die +Bindungen und Auswertungen eine nach der anderen der Reihe nach +durchgeführt, während in einem @samp{Letrec}-Ausdruck alle Bindungen +bereits gelten, während ihre Anfangswerte berechnet werden, wodurch +wechselseitig rekursive Definitionen ermöglicht werden. + + +@deffn {Bibliothekssyntax} let @r{<Bindungen>} @r{<Rumpf>} + +@emph{Syntax:} +@r{<Bindungen>} sollte die folgende Form haben: + +@format +@t{((@r{<Variable1>} @r{<Anfang1>}) @dots{},)@r{,} +} +@end format + +wobei jeder @r{<Anfang>} ein Ausdruck ist und der @r{<Rumpf>} eine Folge +von einem oder mehr Ausdrücken sein sollte. Es ist ein Fehler, wenn +eine @r{<Variable>} mehr als einmal in der Liste der zu bindenden +Variablen vorkommt. + +@emph{Semantik:} +Jeder @r{<Anfang>} wird in der aktuellen Umgebung ausgewertet (in +unbestimmter Reihenfolge), dann werden die @r{<Variable>}n an neue +Stellen gebunden, die die Ergebnisse enthalten, woraufhin der +@r{<Rumpf>} in der so erweiterten Umgebung ausgewertet wird und der Wert +@abbr{bzw.} die Werte des letzten Ausdrucks im @r{<Rumpf>} zurückgegeben +wird(werden). Jede Bindung einer @r{<Variable>}n hat den @r{<Rumpf>} +als ihre Region. +@cindex @w{Region} + + +@format +@t{(let ((x 2) (y 3)) + (* x y)) ==> 6 + +(let ((x 2) (y 3)) + (let ((x 7) + (z (+ x y))) + (* z x))) ==> 35 +} +@end format + + +Siehe auch das benannte @samp{Let}, Abschnitt @ref{Iteration}. + +@end deffn + + + +@deffn {Bibliothekssyntax} let* @r{<Bindungen>} @r{<Rumpf>} + + +@emph{Syntax:} +@r{<Bindungen>} sollte die folgende Form haben: + +@format +@t{((@r{<Variable1>} @r{<Anfang1>}) @dots{},)@r{,} +} +@end format + +und der @r{<Rumpf>} sollte eine Folge von einem oder mehr Ausdrücken +sein. + +@emph{Semantik:} +@samp{Let*} ist ähnlich wie @samp{Let}, aber die Bindungen werden der +Reihe nach von links nach rechts durchgeführt und die Region einer +Bindung, die +@cindex @w{Region} +durch @samp{(@r{<Variable>} @r{<Anfang>})} angezeigt wird, ist der Teil +des @samp{Let*}-Ausdrucks rechts von der Bindung. Dadurch wird die +zweite Bindung in einer Umgebung ausgeführt, in der die erste Bindung +bereits sichtbar ist, und so weiter. + + +@format +@t{(let ((x 2) (y 3)) + (let* ((x 7) + (z (+ x y))) + (* z x))) ==> 70 +} +@end format + + +@end deffn + + + +@deffn {Bibliothekssyntax} letrec @r{<Bindungen>} @r{<Rumpf>} + +@emph{Syntax:} +@r{<Bindungen>} folgende Form haben sollte: + +@format +@t{((@r{<Variable1>} @r{<Anfang1>}) @dots{},)@r{,} +} +@end format + +und @r{<Rumpf>} eine Folge von einem oder mehreren Ausdrücken sein +sollte. Es ist ein Fehler, wenn eine @r{<Variable>} mehr als einmal in +der Liste der zu bindenden Variablen vorkommt. + +@emph{Semantik:} +Die @r{<Variable>}n werden an neue Stellen gebunden, die noch unfertige +Werte enthalten, jeder @r{<Anfang>} wird (in unbestimmter Reihenfolge) +ausgewertet, jeder Variablen das Ergebnis des zugehörigen @r{<Anfang>}s +zugewiesen und der @r{<Rumpf>} in der daraus hervorgehenden Umgebung +ausgewertet und der Wert @abbr{bzw.} die Werte des letzten Ausdrucks im +@r{<Rumpf>} zurückgegeben. Jede Bindung einer @r{<Variable>}n hat den +gesamten @samp{Letrec}-Ausdruck als ihre Reguibm was es ermöglicht, +@cindex @w{Region} +wechselseitig rekursive Prozeduren zu definieren. + + +@format +@t{(letrec ((even? ; gerade? + (lambda (n) + (if (zero? n) + #t + (odd? (- n 1))))) + (odd? ; ungerade? + (lambda (n) + (if (zero? n) + #f + (even? (- n 1)))))) + (even? 88)) + ==> #t +} +@end format + + +Eine Einschränkung von @samp{Letrec} ist sehr wichtig: es muss möglich +sein, jeden @r{<Anfang>} auszuwerten, ohne dass ein Wert irgendeiner +@r{<Variable>}n zugewiesen oder referenziert wird. Wird diese +Einschränkung verletzt, ist es ein Fehler. Die Einschränkung ist +notwendig, weil Scheme Argumente als Wertparameter und nicht als +Namensparameter übergibt. In den üblichsten Nutzungen von @samp{Letrec} +ist jeder @r{<Anfang>} ein Lambda-Ausdruck und die Einschränkung gilt +automatisch. + +@c \todo{use or uses? --- Jinx.} + +@end deffn + + +@node Sequenzierung, Iteration, Bindungskonstrukte, Abgeleitete Ausdruckstypen +@subsection Sequenzierung + + + +@deffn {Bibliothekssyntax} begin <Ausdruck1> <Ausdruck2> @dots{}, + +Jeder @r{<Ausdruck>} wird der Reihe nach von links nach rechts +ausgewertet und der Wert @abbr{bzw.} die Werte des letzten +@r{<Ausdruck>}s zurückgegeben. Dieser Ausdruckstyp wird für +Wirkungen wie Ein- und Ausgabe benutzt. + + +@format +@t{(define x 0) + +(begin (set! x 5) + (+ x 1)) ==> 6 + +(begin (display "4 plus 1 ist gleich ") + (display (+ 4 1))) ==> @emph{unbestimmt} + @emph{und gibt aus} 4 plus 1 ist gleich 5 +} +@end format + + +@end deffn + + +@node Iteration, Verzögerte Auswertung, Sequenzierung, Abgeleitete Ausdruckstypen +@subsection Iteration + +@c \unsection + + +@noindent + +@deffn {Bibliothekssyntax} do ((@r{<Variable1>} @r{<Anfang1>} @r{<Schritt1>}) @dots{}) (@r{<Test>} @r{<Ausdruck>} @dots{}) @r{<Befehl>} @dots{} +@cindex @w{Do} + +@samp{Do} (deutsch „tu``) ist ein Iterationskonstrukt. Es gibt eine +Menge von Variablen an, die zu binden sind, welchen Wert sie anfänglich +haben sollen und wie sie in jeder Iteration aktualisiert werden sollen. +Wird eine Terminierungsbedingung erfüllt, dann wird die Schleife nach +der Auswertung jedes @r{<Ausdruck>}s verlassen. + +@samp{Do}-Ausdrücke werden wie folgt ausgewertet: Die +@r{<Anfang>}sausdrücke werden ausgewertet (in einer unbestimmten +Reihenfolge), die @r{<Variable>}n werden an neue Stellen gebunden, die +Ergebnisse der @r{<Anfang>}sausdrücke in den Bindungen der +@r{<Variable>}n gespeichert und dann beginnt die Iterationsphase. + +Jede Iteration beginnt mit dem Auswerten vom @r{<Test>}; wenn das +Ergebnis falsch ist (siehe den Abschnitt @pxref{Boolesche Werte}), dann +werden der Reihe nach die Ausdrücke des @r{<Befehl>}s für ihre Wirkung +ausgewertet, die @r{<Schritt>}-Ausdrücke in einer unbestimmten +Reihenfolge ausgewertet, die @r{<Variable>}n an neue Stellen gebunden, +die Ergebnisse der @r{<Schritt>}e in den Bindungen der @r{<Variable>}n +gespeichert und die nächste Iteration fängt an. + +Wenn der @r{<Test>} zu einem wahren Wert ausgewertet wird, dann wird von +rechts nach links jeder @r{<Ausdruck>} ausgewertet und der Wert +@abbr{bzw.} die Werte des letzten @r{<Ausdruck>}s zurückgegeben. Gibt +es keinen @r{<Ausdruck>}, ist der Wert des @samp{Do}-Ausdrucks +unbestimmt. + +Die Region der Bindung einer @r{<Variable>}n +@cindex @w{Region} +besteht aus dem gesamten @samp{Do}-Ausdruck außer jedem @r{<Anfang>}. +Es ist ein Fehler, wenn eine @r{<Variable>} mehr als einmal in der Liste +der @samp{Do}-Variablen vorkommt. + +Ein @r{<Schritt>} darf weggelassen werden. In diesem Fall ist die +Wirkung dieselbe, wie wenn @samp{(@r{<Variable>} @r{<Anfang>} +@r{<Variable>})} statt @samp{(@r{<Variable>} @r{<Anfang>})} geschrieben +worden wäre. + + +@format +@t{(do ((vec (make-vector 5)) + (i 0 (+ i 1))) + ((= i 5) vec) + (vector-set! vec i i)) ==> #(0 1 2 3 4) + +(let ((x '(1 3 5 7 9))) + (do ((x x (cdr x)) + (Summe 0 (+ Summe (car x)))) + ((null? x) Summe))) ==> 25 +} +@end format + + +@c \end{entry} +@end deffn + + +@deffn {Bibliothekssyntax} let @r{<Variable>} @r{<Bindungen>} @r{<Rumpf>} + + +„Benanntes @samp{Let}`` ist eine Variante der Syntax von @code{Let}, die +@vindex @w{Let} +ein allgemeineres Schleifenkonstrukt als @samp{Do} bietet und auch zum +Ausdrücken von Rekursion benutzt werden kann. +Es hat dieselbe Syntax und Semantik wie das herkömmliche @samp{Let}, +außer dass @r{<Variable>} im @r{<Rumpf>} an eine Prozedur gebunden wird, +deren formale Argumente die gebundenen Variablen und deren Rumpf der +@r{<Rumpf>} ist. Daher kann durch einen Aufruf der durch die +@r{<Variable>} benannten Prozedur die Ausführung des @r{<Rumpf>}s +wiederholt werden. + +@c | <-- right margin + +@format +@t{(let loop ((Zahlen '(3 -2 1 6 -5)) + (nichtneg '()) + (neg '())) + (cond ((null? Zahlen) (list nichtneg neg)) + ((>= (car Zahlen) 0) + (loop (cdr Zahlen) + (cons (car Zahlen) nichtneg) + neg)) + ((< (car Zahlen) 0) + (loop (cdr Zahlen) + nichtneg + (cons (car Zahlen) neg))))) + ==> ((6 1 3) (-5 -2)) +} +@end format + + +@end deffn + + +@node Verzögerte Auswertung, Quasimaskierung, Iteration, Abgeleitete Ausdruckstypen +@subsection Verzögerte Auswertung + + + +@deffn {Bibliothekssyntax} delay @r{<Ausdruck>} + +@ignore todo +Fix. +@end ignore + + +Das @samp{Delay}-Konstrukt (deutsch „verzögern``) wird zusammen mit der +Prozedur @code{Force} (deutsch „erzwingen``) benutzt, um +@vindex @w{Force} +@dfn{verzögerte Auswertung} (Lazy evaluation) oder +@dfn{Bedarfsparameter} (Call by need) zu implementieren. +@cindex @w{Bedarfsparameter} +@cindex @w{Call by need} +@cindex @w{verzögerte Auswertung} +@cindex @w{Lazy evaluation} +@t{(delay @r{<Ausdruck>})} gibt ein Objekt zurück, was +@dfn{Versprechen} (Promise) genannt wird, welches zu einem zukünftigen +Zeitpunkt (durch +@cindex @w{Versprechen} +die @samp{Force}-Prozedur) +@ignore todo +Bartley's white lie; OK? +@end ignore + um die Auswertung des @r{<Ausdruck>}s gebeten werden kann und dann den +sich daraus ergebenden Wert liefert. Wenn der @r{<Ausdruck>} mehrere +Werte zurückgibt, ist die Wirkung davon unbestimmt. + +Siehe die Beschreibung von @samp{Force} (im Abschnitt +@pxref{Programmflussfunktionalitäten}) für eine vollständigere +Beschreibung von @samp{Delay}. + +@end deffn + + +@node Quasimaskierung, , Verzögerte Auswertung, Abgeleitete Ausdruckstypen +@subsection Quasimaskierung + + + + +@deffn {Syntax} quasiquote @r{<qq-Schablone>} + +@deffnx {Syntax} @t{`}@r{<qq-Schablone>} + + +„Backquote`` oder „Quasiquote``-Ausdrücke zur Quasimaskierung nützen +@cindex @w{Backquote} +beim Erstellen einer Liste oder Vektorstruktur, wenn die meisten aber +nicht alle Bestandteile der gewünschten Struktur im Voraus bekannt sind. +Wenn kein Komma innerhalb der @r{<qq-Schablone>} vorkommt, ist das +Ergebnis der +@cindex @w{Komma} +Auswertung von @t{`}@r{<qq-Schablone>} äquivalent zum Ergebnis der +Auswertung von @t{'}@r{<qq-Schablone>}. Kommt jedoch ein Komma +innerhalb der +@cindex @w{,} +@r{<qq-Schablone>} vor, so wird der auf das Komma folgende Ausdruck +ausgewertet („demaskiert``) und sein Ergebnis in die Struktur an Stelle +des Kommas und des Ausdrucks eingefügt. Kommt ein Komma direkt gefolgt +von einem At-Zeichen (@@) vor, muss der folgende +@cindex @w{,@@} +Ausdruck zu einer Liste ausgewertet werden; die öffnenden und +schließenden runden Klammern der Liste werden dann weggenommen und die +Elemente der Liste an Stelle der Komma-At-Zeichen-Ausdrucksfolge +eingefügt. Ein Komma-At-Zeichen sollte nur innerhalb einer Listen- oder +Vektor-@r{<qq-Schablone>} vorkommen. + +@c struck: "(in the sense of {\cf equal?})" after "equivalent" + + +@format +@t{`(list ,(+ 1 2) 4) ==> (list 3 4) +(let ((Name 'a)) `(list ,Name ',Name)) + ==> (list a (quote a)) +`(a ,(+ 1 2) ,@@(map abs '(4 -5 6)) b) + ==> (a 3 4 5 6 b) +`((@samp{foo} ,(- 10 3)) ,@@(cdr '(c)) . ,(car '(cons))) + ==> ((foo 7) . cons) +`#(10 5 ,(sqrt 4) ,@@(map sqrt '(16 9)) 8) + ==> #(10 5 2 4 3 8) +} +@end format + + +Quasimaskierungsformen dürfen verschachtelt werden. Ersetzungen werden +nur für demaskierte Bestandteile durchgeführt, die auf derselben +Verschachtelungsstufe wie das äußerste Backquote-Zeichen stehen. Die +Verschachtelungsstufe erhöht sich um eins für jede folgende +Quasimaskierung und sinkt ums eins in jeder Demaskierung. + + +@format +@t{`(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f) + ==> (a `(b ,(+ 1 2) ,(foo 4 d) e) f) +(let ((Name1 'x) + (Name2 'y)) + `(a `(b „Name1 ,',Name2 d) e)) + ==> (a `(b ,x ,'y d) e) +} +@end format + + +Die beiden Notationen + @t{`}@r{<qq-Schablone>} und @t{(quasiquote @r{<qq-Schablone>})} + sind in allen Bezügen identisch. + @samp{,@r{<Ausdruck>}} ist identisch mit @samp{(unquote @r{<Ausdruck>})}, + und + @samp{,@@@r{<Ausdruck>}} ist identisch mit + @samp{(unquote-splicing @r{<Ausdruck>})}. +Welche externe Syntax @code{Write} für zweielementige Listen, deren +@vindex @w{Write} +Car eines dieser Symbole ist, erzeugt, darf je nach Implementierung +abweichen. + +@cindex @w{`} + + +@format +@t{(quasiquote (list (unquote (+ 1 2)) 4)) + ==> (list 3 4) +'(quasiquote (list (unquote (+ 1 2)) 4)) + ==> `(list ,(+ 1 2) 4) + @emph{}d.h. (quasiquote (list (unquote (+ 1 2)) 4)) +} +@end format + + +Unvorhersehbares Verhalten darf auftreten, wenn eines der Symbole +@code{Quasiquote}, @code{Unquote} oder @code{Unquote-splicing} in einer +@vindex @w{Unquote-splicing} +@vindex @w{Unquote} +@vindex @w{Quasiquote} +Positions innerhalb einer @r{<qq-Schablone>} auf andere Weise als oben +beschrieben vorkommt. + +@end deffn + +@node Makros, , Abgeleitete Ausdruckstypen, Ausdrücke +@section Makros + +@menu +* Bindungskonstrukte für syntaktische Schlüsselwörter:: +* Mustersprache:: +@end menu + + + +Scheme-Programme können neue abgeleitete Ausdruckstypen definieren und +benutzen. Diese nennt man @emph{Makros}. +@cindex @w{Makro} +Vom Programm definierte Ausdruckstypen haben die Syntax + +@example + +(@r{<Schlüsselwort>} @r{<Datenelement>} ...) + +@end example + +wobei @r{<Schlüsselwort>} ein Bezeichner ist, der den Ausdruckstyp +eindeutig festlegt. Dieser Bezeichner wird das @emph{syntaktische +Schlüsselwort} oder einfach @emph{Schlüsselwort} des Makros genannt. +Die +@cindex @w{Makro-Schlüsselwort} +@cindex @w{Schlüsselwort} +@cindex @w{syntaktisches Schlüsselwort} +Anzahl der @r{<Datenelement>}e und ihre Syntax hängt vom Ausdruckstyp +ab. + +Jede Instanz eines Makros als eine @emph{Benutzung} +@cindex @w{Makro-Benutzung} +des Makros bezeichnet. Die Menge an Regeln, die festlegen, wie eine +Makro-Benutzung zu einem grundlegenderen Ausdruck umgeschrieben wird, +heißt der @emph{Umwandler} +@cindex @w{Makroumwandler} +des Makros. + +Die Mittel zur Makro-Definition setzen sich aus zwei Teilen zusammen: + + + +@itemize @bullet + +@item +Eine Menge von Ausdrücken, um bestimmte Bezeichner als Makroausdrücke zu +kennzeichnen, sie mit Makroumwandlern zu verknüpfen und den +Sichtbarkeitsbereich, in dem ein Makro definiert ist, zu steuern, sowie + +@item +eine Mustersprache zum Angeben von Makroumwandlern. + +@end itemize + + +Das syntaktische Schlüsselwort eines Makros darf Variablenbindungen +überdecken und lokale Variablenbindungen dürfen Schlüsselwortbindungen +überdecken. Alle Makros, +@cindex @w{Schlüsselwort} +die mit der Mustersprache definiert wurden, sind „hygienisch`` und +„referenziell transparent``, also bleibt Schemes lexikalische Bindung +intakt [Kohlbecker86], [ hygienic], [Bawden88], [macrosthatwork], +[syntacticabstraction]: + +@cindex @w{hygienisch} + +@cindex @w{referenziell transparent} + + + + +@itemize @bullet + + +@item +Wenn ein Makroumwandler eine Bindung für einen Bezeichner (Variable oder +Schlüsselwort) einfügt, verhält sich diese, als würde der Bezeichner in +seinem gesamten Sichtbarkeitsbereich umbenannt, um Konflikte mit anderen +gleichnamigen Bezeichnern zu vermeiden. Beachten Sie, dass ein +@code{define} auf oberster Ebene eine Bindung einführen darf oder nicht, +siehe den Abschnitt @ref{Definitionen}. + +@item +Wenn ein Makroumwandler eine freie Referenz auf einen Bezeichner +einfügt, bezieht sich die Referenz auf die Bindung, die sichtbar war, +als der Makroumwandler festgelegt wurde, ohne Berücksichtigung jeglicher +lokaler Bindungen, die die Makro-Benutzung umgeben könnten. + + +@end itemize + +@vindex @w{Define} + +@c The low-level facility permits non-hygienic macros to be written, +@c and may be used to implement the high-level pattern language. + +@c The fourth section describes some features that would make the +@c low-level macro facility easier to use directly. + +@node Bindungskonstrukte für syntaktische Schlüsselwörter, Mustersprache, Makros, Makros +@subsection Bindungskonstrukte für syntaktische Schlüsselwörter + + + +@samp{Let-syntax} und @samp{Letrec-syntax} sind analog zu @samp{Let} und +@samp{Letrec}, aber sie binden syntaktische Schlüsselwörter an +Makrosumwandler statt Variable an Stellen zu binden, die Werte +enthalten. Syntaktische Schlüsselwörter dürfen auch auf oberster Ebene +gebunden werden; siehe den Abschnitt @ref{Syntaxdefinitionen}. + + +@deffn {Syntax} let-syntax @r{<Bindingungen>} @r{<Rumpf>} + +@emph{Syntax:} +@r{<Bindungen>} sollte folgende Form haben: + +@format +@t{((@r{<Schlüsselwort>} @r{<Umwandlerspezifikation>}) @dots{},) +} +@end format + +Jedes @r{<Schlüsselwort>} ist ein Bezeichner, jede +@r{<Umwandlerspezifikation>} ist eine Instanz von @samp{Syntax-rules} +und @r{<Rumpf>} sollte eine Folge von einem oder mehreren Ausdrücken +sein. Es ist ein Fehler, wenn ein @r{<Schlüsselwort>} mehr als einmal +in der Liste der Schlüsselwörter auftaucht, die gebunden werden. + +@emph{Semantik:} +Der @r{<Rumpf>} wird in der syntaktischen Umgebung umgeschrieben, die +entsteht, wenn die syntaktische Umgebung des @samp{Let-syntax}-Ausdrucks +um Makros, deren Schlüsselwörter die aus den +@r{<Schlüsselwort>}-Vorkommen sind, gebunden an die angegebenen +Umwandler, erweitert wird. Jede Bindung eines @r{<Schlüsselwort>}s hat +den @r{<Rumpf>} als ihre Region. + + +Das folgende Beispiel nimmt an, dass die benutzte Scheme-Implementierung +das scharfe S (ß) auch als Buchstabenzeichen ansieht, als Erweiterung +zur in diesem Bericht spezifizierten Syntax: + +@format +@t{(let-syntax ((when (syntax-rules () + ((when Test Anweisung1 Anweisung2 ...) + (if Test + (begin Anweisung1 + Anweisung2 ...)))))) + (let ((if #t)) + (when if (set! if 'jetzt)) + if)) ==> jetzt + +(let ((x 'außen)) + (let-syntax ((m (syntax-rules () ((m) x)))) + (let ((x 'innen)) + (m)))) ==> außen +} +@end format + + +@end deffn + + +@deffn {Syntax} letrec-syntax @r{<Bindungen>} @r{<Rumpf>} + +@emph{Syntax:} +Dieselbe wie bei @samp{Let-syntax}. + +@emph{Semantik:} +Der @r{<Rumpf>} wird in der syntaktischen Umgebung umgeschrieben, die +entsteht, wenn die syntaktische Umgebung des +@samp{Letrec-syntax}-Ausdrucks um die Makros, deren Schlüsselwörter die +aus den @r{<Schlüsselwort>}-Vorkommen sind, gebunden an die angegebenen +Umwandler, erweitert wird. +Jede Bindung eines @r{<Schlüsselwort>}s hat die @r{<Bindungen>} sowie +den @r{<Rumpf>} in ihrer Region, so dass die Umwandler Ausdrücke zu +Benutzungen der Makros umschreiben können, die durch den +@samp{Letrec-syntax}-Ausdruck eingeführt wurden. + + +@format +@t{(letrec-syntax + ((mein-or (syntax-rules () + ((mein-or) #f) + ((mein-or e) e) + ((mein-or e1 e2 ...) + (let ((temp e1)) + (if temp + temp + (mein-or e2 ...))))))) + (let ((x #f) + (y 7) + (temp 8) + (let odd?) + (if even?)) + (mein-or x + (let temp) + (if y) + y))) ==> 7 +} +@end format + + +@end deffn + +@node Mustersprache, , Bindungskonstrukte für syntaktische Schlüsselwörter, Makros +@subsection Mustersprache + + + +Eine @r{<Umwandlerspezifikation>} hat folgende Form: + + +@deffn {} syntax-rules @r{<Literale>} @r{<Syntaxregel>} @dots{}, + +@emph{Syntax:} +@r{<Literale>} sind eine Liste von Bezeichnern, und jede +@r{<Syntaxregel>} sollten die folgende Form haben + +@format +@t{(@r{<Muster>} @r{<Schablone>}) +} +@end format + +Das @r{<Muster>} in einer @r{<Syntaxregel>} ist ein listenförmiges +@r{<Muster>}, dessen Listenform mit dem Schlüsselwort für das Makro +beginnt. + +Allgemein ist ein @r{<Muster>} entweder ein Bezeichner, eine Konstante +oder eines der Folgenden + +@format +@t{(@r{<Muster>} @dots{}) +(@r{<Muster>} @r{<Muster>} @dots{} . @r{<Muster>}) +(@r{<Muster>} @dots{} @r{<Muster>} @r{<Auslassungspunkte>}) +#(@r{<Muster>} @dots{}) +#(@r{<Muster>} @dots{} @r{<Muster>} @r{<Auslassungspunkte>}) +} +@end format + +und eine Schablone ist ein Bezeichner, eine Konstante oder eines der +Folgenden + +@format +@t{(@r{<Element>} @dots{}) +(@r{<Element>} @r{<Element>} @dots{} . @r{<Schablone>}) +#(@r{<Element>} @dots{}) +} +@end format + +wobei ein @r{<Element>} eine @r{<Schablone>} ist, auf die optional +@r{<Auslassungspunkte>} folgen, wobei @r{<Auslassungspunkte>} der +Bezeichner „@samp{...}`` ist (welcher nicht als Bezeichner in einer +Schablone oder einem Muster benutzt werden darf). +@vindex ... + +@emph{Semantik:} Eine Instanz von @samp{Syntax-rules} erstellt einen +neuen Makroumwandler, indem eine Folge hygienischer Umschreiberegeln +angegeben wird. Eine Benutzung eines Makros, deren Schlüsselwort mit +einem über @samp{Syntax-rules} festgelegten Umwandler verknüpft ist, +wird mit den Mustern abgeglichen, die in @r{<Syntaxregel>} vorkommen, +angefangen mit der am weisten links stehenden @r{<Syntaxregel>}. Wenn +ein passendes Muster gefunden wurde, wird die Makrobenutzung hygienisch +entsprechend der Schablone umgeschrieben. + +Ein Bezeichner, der im Muster einer @r{<Syntaxregel>} steht, ist eine +@emph{Mustervariable}, außer wenn sie das Schlüsselwort ist, das das +Muster beginnt, unter den @r{<Literale>}n vorkommt oder der Bezeichner +„@samp{...}`` ist. Mustervariable werden beliebigen Eingabeelementen +zugeordnet und benutzt, um Elemente der Eingabe in der Schablone zu +bezeichnen. Es ist ein Fehler, wenn dieselbe Mustervariable mehr als +einmal in einem @r{<Muster>} auftaucht. + +Das Schlüsselwort am Anfang des Musters in einer @r{<Syntaxregel>} ist +nicht an dem Abgleich beteiligt und wird nicht als eine Mustervariable +oder als Literalbezeichner angesehen. + + +@quotation +@emph{Begründung:} +Der Bereich, auf den sich das Schlüsselwort auswirkt, wird anhand des +Ausdrucks oder der Syntaxdefinition festgelegt, die das Schlüsselwort +an den verknüpften Makroumwandler bindet. Wenn das Schlüsselwort eine +Mustervariable oder ein Literalbezeichner wäre, dann wäre die auf das +Muster folgende Schablone selbst im Bereich, auf den sich das +Schlüsselwort auswirkt, unabhängig davon, ob das Schlüsselwort durch +@samp{Let-syntax} oder @samp{Letrec-syntax} gebunden wurde. +@end quotation + + +Bezeichner, die unter den @r{<Literale>}n vorkommen, werden als +Literalbezeichner ausgelegt, die mit den entsprechenden Unterformen +der Eingabe abgeglichen werden. +Eine Unterform in der Eingabe passt zu einem Literalbezeichner genau +dann, wenn sie ein Bezeichner ist und entweder sowohl ihr Vorkommen im +Makroausdruck als auch ihr Vorkommen in der Makrodefinition dieselbe +lexikalische Bindung haben oder die beiden Bezeichner gleich sind und +beide keine lexikalische Bindung haben. + +@c [Bill Rozas suggested the term "noise word" for these literal +@c identifiers, but in their most interesting uses, such as a setf +@c macro, they aren't noise words at all. -- Will] + +Ein Untermuster gefolgt von @samp{...} kann zu null oder mehr +Elementen der Eingabe passen. Es ist ein Fehler, wenn @samp{...} +unter den @r{<Literale>}n vorkommt. Innerhalb eines Musters muss der +Bezeichner @samp{...} auf das letzte Element einer nichtleeren Folge +von Untermustern folgen. + +Formaler ausgedrückt passt eine Eingabeform F zu einem Muster M genau +dann, wenn: + + + +@itemize @bullet + +@item +M ein nichtliteraler Bezeichner ist, oder + +@item +M ein literaler Bezeichner ist und F ein Bezeichner mit derselben +Bindung ist, oder + +@item +M eine Liste @samp{(M_1 @dots{} M_n)} und F eine +Liste aus n +Formen ist, welche jeweils zu M_1 bis M_n passen, oder + +@item +M eine unechte Liste +@samp{(M_1 M_2 @dots{} M_n . M_n+1)} ist +und F eine Liste oder +unechte Liste von n oder mehr Formen ist, die jeweils zu M_1 bis M_n, +passen und deren n-ter „Cdr`` zu M_n+1 passt, oder + +@item +M von der Form +@samp{(M_1 @dots{} M_n M_n+1 <Auslassungspunkte>)} ist, +wobei <Auslassungspunkte> der Bezeichner @samp{...} ist +und F eine +echte Liste aus mindestens n Formen ist, deren erste n Formen jeweils zu +M_1 bis M_n passen, und jedes verbleibende Element von F +zu M_n+1 passt, oder + +@item +M ein Vektor von der Form @samp{#(M_1 @dots{} M_n)} +und F ein Vektor aus +n Formen ist, die zu M_1 bis M_n passen, oder + +@item +M von der Form +@samp{#(M_1 @dots{} M_n M_n+1 <Auslassungspunkte>)} ist, +wobei <Auslassungspunkte> der Bezeichner @samp{...} +und F ein Vektor aus n +oder mehr Formen ist, deren erste n jeweils zu +M_1 bis M_n passen und wobei jedes verbleibende Element von F +zu M_n+1 passt, oder + +@item +M ein Datenelement und F gleich M ist, in dem Sinne der +@samp{Equal?}-Prozedur. + +@end itemize + + +Es ist ein Fehler, ein Makroschlüsselwort in dem Bereich, auf den es +sich auswirkt, in einem Ausdruck zu benutzen, der zu keinem seiner +Muster passt. + +Wenn eine Makro-Benutzung anhand der Schablone der passenden +@r{<Syntaxregel>} umgeschrieben wird, werden Mustervariable, die in der +Schablone vorkommen, durch die Subformen ersetzt, zu denen sie in der +Eingabe passen. Mustervariable, die in Untermustern gefolgt von einer +oder mehr Instanzen des Bezeichners @samp{...} vorkommen, dürfen nur in +Unterschablonen vorkommen, auf die ebenso viele Instanzen von @samp{...} +folgen. Sie werden in der Ausgabe durch all die Subformen ersetzt, die +zur Eingabe passen, so verteilt, wie sie vorkommen. Es ist ein Fehler, +wenn die Ausgabe nicht wie festgelegt aufgebaut werden kann. + +@c %% This description of output construction is very vague. It should +@c %% probably be formalized, but that is not easy... + +Bezeichner, die in der Schablone vorkommen, aber keine Mustervariablen +oder der Bezeichner @samp{...} sind, werden wörtlich als literale +Bezeichner eingefügt. Wenn ein literaler Bezeichner als freier +Bezeichner eingefügt wird, referenziert er diejenige Bindung dieses +Bezeichners, in dessen Bereich die Instanz von @samp{Syntax-rules} +vorkommt. Wenn ein literaler Bezeichner als gebundener Bezeichner +eingefügt wird, dann verhält er sich, als würde er umbenannt, so wird +unerwünschtes Fangen freier Bezeichner verhindert. + +Wenn zum Beispiel @code{Let} und @code{Cond} wie im Abschnitt +@vindex @w{Cond} +@vindex @w{Let} +@ref{Abgeleitete Ausdruckstypen} definiert sind, dann sind sie +hygienisch (wie vorgeschrieben) und das Folgende ist kein Fehler. + + +@format +@t{(let ((=> #f)) + (cond (#t => 'ok))) ==> ok +} +@end format + + +Der Makroumwandler für @samp{Cond} erkennt @samp{=>} als eine lokale +Variable und daher als Ausdruck und nicht als den Bezeichner auf +oberster Ebene @samp{=>}, den der Makroumwandler als ein syntaktisches +Schlüsselwort behandelt. Daher wird das Beispiel umgeschrieben zu + + +@format +@t{(let ((=> #f)) + (if #t (begin => 'ok))) +} +@end format + + +statt zu + + +@format +@t{(let ((=> #f)) + (let ((temp #t)) + (if temp ('ok temp)))) +} +@end format + + +was zu einem ungültigen Prozeduraufruf führen würde. + +@end deffn + + +@page + +@c @include{prog} +@node Programmstruktur, Standardprozeduren, Ausdrücke, top +@chapter Programmstruktur + +@menu +* Programme:: +* Definitionen:: +* Syntaxdefinitionen:: +@end menu + + + +@node Programme, Definitionen, Programmstruktur, Programmstruktur +@section Programme + + +Ein Scheme-Programm besteht aus einer Folge von Ausdrücken, Definitionen +und Syntaxdefinitionen. Ausdrücke werden im Kapitel @ref{Ausdrücke} +beschrieben, Definitionen und Syntaxdefinitionen sind Thema im Rest des +momentanen Kapitels. + +Programme werden typischerweise in Dateien gespeichert oder interaktiv +in ein laufenden Scheme-System eingegeben, wobei auch andere Paradigmen +möglich sind; Fragen der Benutzerschnittstelle gehören dabei nicht zum +in diesem Bericht behandelten Stoff. (Tatsächlich könnte Scheme auch +als eine Notation zum Ausdrücken von Berechnungsmethoden von Nutzen +sein, selbst ohne jegliche mechanische Implementierung.) + +Definitionen und Syntaxdefinitionen, die auf der obersten Ebene eines +Programms stehen, können deklarativ interpretiert werden. Sie führen +dazu, dass Bindungen in der Umgebung auf oberster Ebene erzeugt werden +oder sie ändern den Wert einer bestehenden Bindung auf oberster Ebene. +Ausdrücke, die auf der obersten Ebene eines Programms vorkommen, werden +imperativ interpretiert; sie werden der Reihe nach ausgeführt, wenn das +Programm aufgerufen oder geladen wird und führen typischerweise +irgendeine Art von Initialisierung des Programms durch. + +Auf der obersten Ebene eines Programms ist ein @t{(begin @r{<Form1>} +@dots{},)} äquivalent zur Folge von Ausdrücken, Definitionen und +Syntaxdefinitionen, die den Rumpf des @code{Begin} bilden. +@vindex @w{Begin} + +@ignore todo +Cromarty, etc.: disclaimer about top level? +@end ignore + + +@node Definitionen, Syntaxdefinitionen, Programme, Programmstruktur +@section Definitionen + +@menu +* Definitionen auf oberster Ebene:: +* Interne Definitionen:: +@end menu + + + +Definitionen sind in manchen, aber nicht in jedem Kontext gültig, in dem +Ausdrücke stehen dürfen. Sie sind nur auf der obersten Ebene eines +@r{<Programm>}s gültig und am Anfang eines @r{<Rumpf>}s. + +@cindex @w{Definition} + +Eine Definition sollte eine der folgenden Formen haben: +@cindex @w{Define} + + + +@itemize @bullet + + +@item @t{(define @r{<Variable>} @r{<Ausdruck>})} + +@item @t{(define (@r{<Variable>} @r{<Formale>}) @r{<Rumpf>})} + +@r{<Formale>} sollten entweder eine Folge von null oder mehr Variablen +sein oder eine Folge von einer oder mehr Variablen, gefolgt von einem +durch Leerzeichen begrenzten Punkt und einer weiteren Variablen (wie in +einem Lambda-Ausdruck). Diese Form ist äquivalent zu + +@example + +(define @r{<Variable>} + (lambda (@r{<Formale>}) @r{<Rumpf>}))@r{.} + +@end example + + +@item @t{(define (@r{<Variable>} .@: @r{<Formale>}) @r{<Rumpf>})} + +@r{<Formale>} sollte eine einzelne Variable sein. Diese Form ist +äquivalent zu + +@example + +(define @r{<Variable>} + (lambda @r{<Formale>} @r{<Rumpf>}))@r{.} + +@end example + + + +@end itemize + + +@node Definitionen auf oberster Ebene, Interne Definitionen, Definitionen, Definitionen +@subsection Definitionen auf oberster Ebene + + +Auf der obersten Ebene eines Programms hat eine Definition + +@example + +(define @r{<Variable>} @r{<Ausdruck>}) + +@end example + +grundlegend dieselbe Wirkung wie ein Zuweisungsausdruck + +@example + +(set! @r{<Variable>} @r{<Ausdruck>}) + +@end example + +wenn @r{<Variable>} gebunden ist. Wenn @r{<Variable>} jedoch nicht +gebunden ist, dann wird die Definition die @r{<Variable>} an eine neue +Stelle binden, bevor sie die Zuweisung durchführt, wohingegen es ein +Fehler wäre, @samp{Set!} auf einer ungebundenen Variablen durchzuführen. +@cindex @w{ungebunden} + + +@example + +(define add3 + (lambda (x) (+ x 3))) +(add3 3) ==> 6 +(define first car) +(first '(1 2)) ==> 1 + +@end example + + +Manche Implementierungen von Scheme benutzen eine Anfangsumgebung, in +der alle möglichen Variablen schon vorab an Stellen gebunden sind, von +denen die meisten undefinierte Werte enthalten. Definitionen auf +oberster Ebene sind in einer solchen Implementierung wirklich +gleichbedeutend mit Zuweisungen. + +@ignore todo +Rozas: equal time for opposition semantics? +@end ignore + + + +@node Interne Definitionen, , Definitionen auf oberster Ebene, Definitionen +@subsection Interne Definitionen + + + +Definitionen dürfen am Anfang eines @r{<Rumpf>}s vorkommen (das heißt, +vom Rumpf eines @code{Lambda}-, +@vindex @w{Lambda} +@code{Let}-, @code{Let*}-, @code{Letrec}-, @code{Let-syntax} oder @code{Letrec-syntax}- +@vindex @w{Letrec-syntax} +@vindex @w{Let-syntax} +@vindex @w{Letrec} +@vindex @w{Let*} +@vindex @w{Let} +oder dem einer Definition in angemessener Form). Solche +Definitionen sind bekannt als @emph{interne Definitionen} im Gegensatz +zur Umgebung auf oberster Ebene, was oben beschrieben ist. +@cindex @w{Interne Definitionen} +Die durch eine interne Definition definierte Variable gilt lokal für den +@r{<Rumpf>}. Das heißt, die @r{<Variable>} wird gebunden statt +zugewiesen und die Region der Bindung ist der gesamte @r{<Rumpf>}. Zum +Beispiel + + +@example + +(let ((x 5)) + (define foo (lambda (y) (bar x y))) + (define bar (lambda (a b) (+ (* a b) a))) + (foo (+ x 3))) ==> 45 + +@end example + + +Ein @r{<Rumpf>}, der interne Definitionen enthält, kann immer in einen +völlig gleichbedeutenden @samp{Letrec}-Ausdruck umgewandelt werden. Zum +Beispiel ist der @samp{Let}-Ausdruck im obigen Beispiel gleichbedeutend +mit + + +@example + +(let ((x 5)) + (letrec ((foo (lambda (y) (bar x y))) + (bar (lambda (a b) (+ (* a b) a)))) + (foo (+ x 3)))) + +@end example + + +Genau wie bei dem gleichbedeutenden @samp{Letrec}-Ausdruck muss es +möglich sein, jeden @r{<Ausdruck>} jeder internen Definition in einem +@r{<Rumpf>} auszuwerten, ohne den Wert irgendeiner der @r{<Variable>}n, +die definiert werden, zuzuweisen oder sich darauf zu beziehen. + +Wann immer eine interne Definition vorkommen darf, ist @t{(begin +@r{<Definition1>} @dots{},)} gleichbedeutend mit der Folge von +Definitionen, die den Rumpf des @code{Begin} bilden. +@vindex @w{Begin} + +@node Syntaxdefinitionen, , Definitionen, Programmstruktur +@section Syntaxdefinitionen + + +Syntaxdefinitionen sind nur auf der obersten Ebene eines @r{<Programm>}s +gültig. + +@cindex @w{Syntaxdefinition} +Sie haben die folgende Form: +@cindex @w{Define-syntax} + +@t{(define-syntax @r{<Schlüsselwort>} @r{<Umwandlerspezifikation>})} + +@r{<Schlüsselwort>} ist ein Bezeichner und +die @r{<Umwandlerspezifikation>} sollte eine Instanz von +@code{Syntax-rules} sein. +@vindex @w{Syntax-rules} +Die syntaktische Umgebung auf oberster Ebene wird erweitert durch +Bindung des @r{<Schlüsselwort>}s an den angegebenen Umwandler. + +Es gibt keine Entsprechung von @samp{Define-syntax} für interne +Definitionen. + +@c [Rationale flushed because it may or may not be true and isn't the +@c real rationale anyway. -RK] +@c \begin{rationale} +@c As discussed below, the syntax and scope rules for syntax definitions +@c can give rise to syntactic ambiguities when syntactic keywords are +@c shadowed. +@c Further ambiguities would arise if {\cf define-syntax} +@c were permitted at the beginning of a \meta{body}, with scope +@c rules analogous to those for internal definitions. +@c \end{rationale} + +@c It is an error for a program to contain more than one top-level +@c \meta{definition} or \meta{syntax definition} of any identifier. + +@c [I flushed this because it isn't an error for a program to +@c contain more than one top-level definition of an identifier, +@c and I didn't want to introduce any gratuitous incompatibilities +@c with the existing Scheme language. -- Will] + +Obwohl Makros in jedem Kontext, der sie zulässt, zu Definitionen und +Syntaxdefinitionen umgeschrieben werden können, ist es ein Fehler, wenn +eine Definition oder eine Syntaxdefinition ein syntaktisches +Schlüsselwort überschattet, dessen Bedeutung nötig ist, um zu bestimmen, +ob eine Form aus der Gruppe von Formen, die die überschattende +Definition enthält, tatsächlich eine Definition ist oder, für interne +Definitionen, nötig ist, um die Grenze zwischen der Gruppe und den auf +die Gruppe folgenden Ausdrücken zu bestimmen. Zum Beispiel sind die +folgenden Code-Stücke Fehler: + +@example + +(define define 3) + +(begin (define begin list)) + +(let-syntax + ((foo (syntax-rules () + ((foo (Proz Args ...) Rumpf ...) + (define Proz + (lambda (Args ...) + Rumpf ...)))))) + (let ((x 3)) + (foo (plus x y) (+ x y)) + (define foo x) + (plus foo x))) + +@end example + + + + +@c @include{procs} + +@c Initial environment + +@c \vfill\eject +@node Standardprozeduren, Formale Syntax und Semantik, Programmstruktur, top +@chapter Standardprozeduren + +@menu +* Äquivalenzprädikate:: +* Zahlen:: +* Andere Datentypen:: +* Programmflussfunktionalitäten:: +* Eval:: +* Ein- und Ausgabe:: +@end menu + + + + + +@cindex @w{Anfangsumgebung} + +@cindex @w{oberste Ebene} + +@cindex @w{Bibliotheksprozedur} + +Dieses Kapitel beschreibt die eingebauten Prozeduren von Scheme. Die +anfängliche Scheme-Umgebung (@abbr{bzw.} die Scheme-Umgebung auf +„oberster Ebene``) enthält von Anfang an eine Reihe von Variablen, +die an Stellen mit nützlichen Werten gebunden sind, von denen die +meisten grundlegende Prozeduren sind, die Daten manipulieren. Zum +Beispiel ist die Variable @samp{Abs} gebunden an eine (Stelle mit +einer) Prozedur mit einem einzelnen Argument, die den Absolutbetrag +einer Zahl berechnet, und die Variable @samp{+} ist an eine Prozedur +gebunden, die Summen berechnet. Eingebaute Prozeduren, die leicht +über andere eingebaute Prozeduren ausgedrückt werden könnten, werden +als „Bibliotheksprozeduren`` ausgewiesen. + +Ein Programm darf eine Definition auf oberster Ebene benutzen, um eine +beliebige Variable zu binden. Es darf daraufhin eine jede solche +Bindung durch eine Zuweisung (siehe @pxref{Zuweisungen}) wieder +ändern. Diese Operationen verändern das Verhalten der in Scheme +eingebauten Prozeduren nicht. Das Ändern einer beliebigen Bindung auf +oberster Ebene, die nicht durch eine Definition eingeführt wurde, hat +allerdings eine unbestimmte Wirkung auf das Verhalten der eingebauten +Prozeduren. + +@node Äquivalenzprädikate, Zahlen, Standardprozeduren, Standardprozeduren +@section Äquivalenzprädikate + + + +Ein @dfn{Prädikat} ist eine Prozedur, die immer einen booleschen +@cindex @w{Prädikat} +Wert (@t{#t} oder @t{#f}) zurückgibt. Ein @dfn{Äquivalenzprädikat} ist +@cindex @w{Äquivalenzprädikat} +die berechnende Entsprechung der mathematischen Äquivalenzrelation (es +ist symmetrisch, reflexiv und transitiv). Von den in diesem Abschnitt +beschriebenen Äquivalenzprädikaten ist @samp{Eq?} das feinste oder am +stärksten unterscheidende und @samp{Equal?} ist das gröbste. +@samp{Eqv?} unterscheidet etwas weniger als @samp{Eq?}. +@ignore todo +Pitman doesn't like +this paragraph. Lift the discussion from the Maclisp manual. Explain +why there's more than one predicate. +@end ignore + + + + +@deffn {Prozedur} eqv? obj1 obj2 + +Die Prozedur @samp{Eqv?} definiert eine nützliche Äquivalenzrelation auf +Objekten. Kurz gesagt gibt sie @t{#t} zurück, wenn @var{Obj1} und +@var{Obj2} unter normalen Umständen als dasselbe Objekt angesehen werden +sollte. Die Bedeutung der Relation lässt ein wenig +Interpretationsspielraum, aber die folgende teilweise Spezifikation von +@samp{Eqv?} gilt für alle Implementierungen von Scheme. + +Die @samp{eqv?}-Prozedur gibt @t{#t} zurück, wenn: + + + +@itemize @bullet + +@item +@var{Obj1} und @var{Obj2} beide @t{#t} oder beide @t{#f} sind. + +@item +@var{Obj1} und @var{Obj2} beide Symbole sind und + + +@format +@t{(string=? (symbol->string obj1) + (symbol->string obj2)) + ==> #t +} +@end format + + + +@quotation +@emph{Anmerkung:} +Die Annahme ist, dass weder @var{Obj1} noch @var{Obj2} ein „nicht +interniertes Symbol`` ist, wie im Abschnitt @ref{Symbole} angedeutet. +Dieser Bericht versucht nicht, das Verhalten von @samp{Eqv?} für +implementierungsabhängige Erweiterungen festzulegen. +@end quotation + + +@item +@var{Obj1} und @var{Obj2} beide Zahlen und numerisch gleich sind (siehe +@samp{=} im Abschnitt @pxref{Zahlen}) und außerdem entweder beide exakt +oder beide inexakt sind. + +@item +@var{Obj1} und @var{Obj2} beide Zeichen sind und laut der Prozedur +@samp{Char=?} dasselbe Zeichen sind (siehe den Abschnitt +@pxref{Zeichen}). + +@item +@var{Obj1} und @var{Obj2} beide die leere Liste sind. + +@item +@var{Obj1} und @var{Obj2} Paare, Vektoren oder Zeichenketten sind, die +dieselben Stellen im Speicher bezeichnen (siehe den Abschnitt +@pxref{Speichermodell}). + +@item +@var{Obj1} und @var{Obj2} Prozeduren sind, deren Stellenbeschriftungen +gleich sind (siehe den Abschnitt @pxref{Prozeduren}). + +@end itemize + +@cindex @w{inexakt} +@cindex @w{exakt} + +Die Prozedur @samp{Eqv?} gibt @t{#f} zurück, wenn: + + + +@itemize @bullet + +@item +@var{Obj1} und @var{Obj2} verschiedene Typen sind (Abschnitt +@pxref{Typfremdheit}). + +@item +eines der @var{Obj1} und @var{Obj2} ein @t{#t} ist, aber das andere ein +@t{#f} ist. + +@item +@var{Obj1} und @var{Obj2} Symbole sind, aber + + +@format +@t{(string=? (symbol->string @var{obj1}) + (symbol->string @var{obj2})) + ==> #f +} +@end format + + +@item +eines von @var{Obj1} und @var{Obj2} eine exakte Zahl ist, aber die +andere eine inexakte Zahl ist. + +@item +@var{Obj1} und @var{Obj2} Zahlen sind, für die die Prozedur @samp{=} den +Wert @t{#f} zurückgibt. + +@item +@var{Obj1} und @var{Obj2} Zeichen sind, für die die Prozedur +@samp{Char=?} den Wert @t{#f} zurückgibt. + +@item +eines von @var{Obj1} und @var{Obj2} die leere Liste ist, aber das andere +nicht. + +@item +@var{Obj1} und @var{Obj2} Paare, Vektoren und Zeichenketten sind, die +unterschiedliche Stellen bezeichnen. + +@item +@var{Obj1} und @var{Obj2} Prozeduren sind, die sich für manche Argumente +unterschiedlich verhalten würden (verschiedene Werte zurückgeben oder +verschiedene Wirkungen haben würden). + + +@end itemize + + + +@format +@t{(eqv? 'a 'a) ==> #t +(eqv? 'a 'b) ==> #f +(eqv? 2 2) ==> #t +(eqv? '() '()) ==> #t +(eqv? 100000000 100000000) ==> #t +(eqv? (cons 1 2) (cons 1 2)) ==> #f +(eqv? (lambda () 1) + (lambda () 2)) ==> #f +(eqv? #f 'nil) ==> #f +(let ((p (lambda (x) x))) + (eqv? p p)) ==> #t +} +@end format + + +Die folgenden Beispiele veranschaulichen Fälle, für die die obigen +Regeln das Verhalten von @samp{Eqv?} nicht vollständig angeben. Alles, +was sich über solche Fälle sagen lässt, ist, dass der von @samp{Eqv?} +zurückgegebene Wert ein boolescher Wert sein muss. + + +@format +@t{(eqv? "" "") ==> @emph{unbestimmt} +(eqv? '#() '#()) ==> @emph{unbestimmt} +(eqv? (lambda (x) x) + (lambda (x) x)) ==> @emph{unbestimmt} +(eqv? (lambda (x) x) + (lambda (y) y)) ==> @emph{unbestimmt} +} +@end format + + +Der nächste Satz von Beispielen zeigt die Nutzung von @samp{Eqv?} mit +Prozeduren, die lokalen Zustand haben. Die Beispiele nehmen an, dass +die benutzte Scheme-Implementierung die Umlaute auch als +Buchstabenzeichen ansieht, als Erweiterung zur in diesem Bericht +spezifizierten Syntax. @samp{Gen-Zähler} muss jedes Mal eine andere +Prozedur zurückgeben, denn jede Prozedur hat ihren eigenen internen +Zähler. @samp{Gen-Verlierer} gibt jedoch jedes Mal gleichwertige +Prozeduren zurück, denn der lokale Zustand beeinflusst die Werte oder +Wirkungen der Prozeduren nicht. + + +@format +@t{(define gen-Zähler + (lambda () + (let ((n 0)) + (lambda () (set! n (+ n 1)) n)))) +(let ((g (gen-Zähler))) + (eqv? g g)) ==> #t +(eqv? (gen-Zähler) (gen-Zähler)) + ==> #f +(define gen-Verlierer + (lambda () + (let ((n 0)) + (lambda () (set! n (+ n 1)) 27)))) +(let ((g (gen-Verlierer))) + (eqv? g g)) ==> #t +(eqv? (gen-Verlierer) (gen-Verlierer)) + ==> @emph{unbestimmt} + +(letrec ((f (lambda () (if (eqv? f g) 'beide 'f))) + (g (lambda () (if (eqv? f g) 'beide 'g)))) + (eqv? f g)) + ==> @emph{unbestimmt} + +(letrec ((f (lambda () (if (eqv? f g) 'f 'beide))) + (g (lambda () (if (eqv? f g) 'g 'beide)))) + (eqv? f g)) + ==> #f +} +@end format + + +@c Objects of distinct types must never be regarded as the same object, +@c except that \schfalse{} and the empty list\index{empty list} are permitted to +@c be identical. + +@c \begin{scheme} +@c (eqv? '() \schfalse) \ev \unspecified% +@c \end{scheme} + +Weil es ein Fehler ist, konstante Objekte zu verändern (die, die von +literalen Ausdrücken zurückgegeben werden), dürfen Implementierungen die +Struktur zwischen Konstanten teilen, müssen aber nicht. Daher ist der +Wert von @samp{Eqv?} für Konstante manchmal implementierungsabhängig. + + +@format +@t{(eqv? '(a) '(a)) ==> @emph{unbestimmt} +(eqv? "a" "a") ==> @emph{unbestimmt} +(eqv? '(b) (cdr '(a b))) ==> @emph{unbestimmt} +(let ((x '(a))) + (eqv? x x)) ==> #t +} +@end format + + + +@quotation +@emph{Begründung:} +Obige Definition von @samp{Eqv?} gestattet Implementierungen Freiraum +bei der Behandlung von Prozeduren und Literalen: Implementierungen steht +es frei, entweder die Gleichheit zweier Prozeduren oder zweier Literale +zu bestätigen oder nicht bestätigen zu können, ob sie gleich sind, so +dass sie selbst entscheiden können, ob Darstellungen äquivalenter +Objekte durch Nutzung desselben Zeigers oder Bit-Musters verschmolzen +werden sollen, um eine Darstellung für beide zu sein. +@end quotation + + +@end deffn + + + +@deffn {Prozedur} eq? obj1 obj2 + +@samp{Eq?} ist ähnlich wie @samp{Eqv?}, außer dass es in manchen Fällen +in der Lage ist, feinere Unterschiede zu erkennen als @samp{Eqv?}. + +Es wird garantiert, dass sich @samp{Eq?} und @samp{Eqv?} auf Symbolen, +booleschen Werten, der leeren Liste, Paaren, Prozeduren und nicht leeren +Zeichenketten und Vektoren gleich verhalten. Das Verhalten von +@samp{Eq?} für Zahlen und Zeichen ist implementierungsabhängig, aber es +wird immer entweder wahr oder falsch zurückgeben und wird nur dann wahr +zurückgeben, wenn @samp{Eqv?} auch wahr zurückgeben würde. @samp{Eq?} +darf sich für leere Vektoren und leere Zeichenketten auch anders als +@samp{Eqv?} verhalten. + + +@format +@t{(eq? 'a 'a) ==> #t +(eq? '(a) '(a)) ==> @emph{unbestimmt} +(eq? (list 'a) (list 'a)) ==> #f +(eq? "a" "a") ==> @emph{unbestimmt} +(eq? "" "") ==> @emph{unbestimmt} +(eq? '() '()) ==> #t +(eq? 2 2) ==> @emph{unbestimmt} +(eq? #\A #\A) ==> @emph{unbestimmt} +(eq? car car) ==> #t +(let ((n (+ 2 3))) + (eq? n n)) ==> @emph{unbestimmt} +(let ((x '(a))) + (eq? x x)) ==> #t +(let ((x '#())) + (eq? x x)) ==> #t +(let ((p (lambda (x) x))) + (eq? p p)) ==> #t +} +@end format + + +@ignore todo +Needs to be explained better above. How can this be made to be +not confusing? A table maybe? +@end ignore + + + +@quotation +@emph{Begründung:} Gewöhnlich wird man @samp{Eq?} deutlich effizienter +implementieren können als @samp{Eqv?}, zum Beispiel als einfacher +Vergleich von Zeigern statt einer komplizierteren Operation. Ein Grund +ist, dass es unmöglich sein kann, @samp{Eqv?} für zwei Zahlen in +konstanter Zeit zu berechnen, während @samp{Eq?}, als Zeigervergleich +implementiert, immer in konstanter Zeit abgeschlossen sein wird. +@samp{Eq?} darf wie @samp{Eqv?} benutzt werden, wenn in einer Anwendung +Prozeduren benutzt werden, um zustandsbehaftete Objekte zu +implementieren, da es denselben Einschränkungen wie @samp{Eqv?} genügt. +@end quotation + + +@end deffn + + + +@deffn {Bibliotheksprozedur} equal? obj1 obj2 + +@samp{Equal?} vergleicht den Inhalt von Paaren, Vektoren und +Zeichenketten rekursiv, indem es auf andere Objekte wie Zahlen und +Symbole @samp{Eqv?} anwendet. Eine Daumenregel ist, dass Objekte im +Allgemeinen @samp{Equal?} sind, wenn sie gleich ausgegeben werden. +@samp{Equal?} muss nicht terminieren, wenn seine Argumente zirkuläre +Datenstrukturen sind. + + +@format +@t{(equal? 'a 'a) ==> #t +(equal? '(a) '(a)) ==> #t +(equal? '(a (b) c) + '(a (b) c)) ==> #t +(equal? "abc" "abc") ==> #t +(equal? 2 2) ==> #t +(equal? (make-vector 5 'a) + (make-vector 5 'a)) ==> #t +(equal? (lambda (x) x) + (lambda (y) y)) ==> @emph{unbestimmt} +} +@end format + + +@end deffn + + +@node Zahlen, Andere Datentypen, Äquivalenzprädikate, Standardprozeduren +@section Zahlen + +@menu +* Numerische Typen:: +* Exaktheit:: +* Implementierungseinschränkungen:: +* Syntax numerischer Konstanter:: +* Numerische Operationen:: +* Numerische Ein- und Ausgabe:: +@end menu + + + +@cindex @w{Zahl} + +@c %R4%% The excessive use of the code font in this section was +@c confusing, somewhat obnoxious, and inconsistent with the rest +@c of the report and with parts of the section itself. I added +@c a \tupe no-op, and changed most old uses of \type to \tupe, +@c to make it easier to change the fonts back if people object +@c to the change. + +@c \newcommand{\type}[1]{{\it#1}} +@c \newcommand{\tupe}[1]{{#1}} + +Numerische Berechnung wurde traditionell von der Lisp-Gemeinschaft +vernachlässigt. Bis Common Lisp gab es keine vorsichtig durchdachte +Strategie zum Organisieren numerischer Berechnungen und abgesehen vom +MacLisp-System [Pitman83] wurden kaum Anstrengungen unternommen, +numerischen Code effizient auszuführen. Dieser Bericht erkennt die +exzellente Arbeit des Common-Lisp-Komitees an und akzeptiert viele ihrer +Empfehlungen. Auf manche Art vereinfacht und verallgemeinert dieser +Bericht deren Vorschläge auf eine Art, die mit den Zwecken von Scheme im +Einklang steht. + +Es ist wichtig, zwischen mathematischen Zahlen, den Scheme-Zahlen, +welche diese zu modellieren versuchen, und Notationen zum Aufschreiben +von Zahlen zu unterscheiden. Dieser Bericht benutzt die Typen Zahl +(@i{number}), komplexe Zahl (@i{complex}), reelle Zahl (@i{real}), +rationale Zahl (@i{rational}) und ganze Zahl (@i{integer}), um sowohl +die mathematischen Zahlen als auch die Scheme-Zahlen zu bezeichnen. +Maschinendarstellungen wie Festkomma (fixed point) und Gleitkomma +(floating point) werden [im englischsprachigen Scheme-Standard] durch +Namen wie @i{fixnum} und @i{flonum} bezeichnet. + +@c %R4%% I did some reorganizing here to move the discussion of mathematical +@c numbers before the discussion of the Scheme numbers, hoping that this +@c would help to motivate the discussion of representation independence. + +@node Numerische Typen, Exaktheit, Zahlen, Zahlen +@subsection Numerische Typen + + + +@cindex @w{numerische Typen} + +@c %R4%% A Scheme system provides data of type \type{number}, which is the most +@c general numerical type supported by that system. +@c \type{Number} is +@c likely to be a complicated union type implemented in terms of +@c \type{fixnum}s, \type{bignum}s, \type{flonum}s, and so forth, but this +@c should not be apparent to a naive user. What the user should see is +@c that the usual operations on numbers produce the mathematically +@c expected results, within the limits of the implementation. + +@c %R4%% I rewrote the following paragraph to make the various levels of +@c the tower into subsets of each other, instead of relating them by +@c injections. I think the injections tended to put people in the frame +@c of mind of thinking about coercions between non-overlapping numeric +@c types in mainstream programming languages. + +Mathematisch können Zahlen in einem Turm von Subtypen angeordnet werden, +@c %R4%% with injections relating adjacent levels of the tower: +in dem jede Stufe eine Teilmenge der darüberliegenden Stufe ist: + +@format + @r{number} (Zahl) + @r{complex} (komplexe Zahl) + @r{real} (reelle Zahl) + @r{rational} (rationale Zahl) + @r{integer} (ganze Zahl) +@end format + + +Zum Beispiel ist 3 eine ganze Zahl. Daher ist 3 auch eine rationale, +reelle und komplexe Zahl. Dasselbe gilt für die Scheme-Zahlen, die die +3 modellieren. Für Scheme-Zahlen sind diese Typen durch die Prädikate +@code{Number?}, @code{Complex?}, @code{Real?}, @code{Rational?}, +@vindex @w{Rational?} +@vindex @w{Real?} +@vindex @w{Complex?} +@vindex @w{Number?} +und @code{Integer?} definiert. +@vindex @w{Integer?} + +Es gibt keine einfache Beziehung zwischen dem Typ einer Zahl und ihrer +Darstellung in einem Rechner. Obwohl die meisten Implementierungen von +Scheme zumindest zwei verschiedene Darstellungen von 3 anbieten werden, +bezeichnen diese unterschiedlichen Darstellungen dieselbe ganze Zahl. + +@c %R4%% I moved "Implementations of Scheme are not required to implement +@c the whole tower..." to the subsection on implementation restrictions. + +Schemes numerische Operationen behandeln Zahlen als abstrakte Daten, die +so unabhängig wie möglich von ihrer Darstellung sind. Obwohl eine +Implementierung von Scheme Festkomma (fixnum), Gleitkomma (flonum) und +unter Umständen andere Repräsentationen benutzen darf, sollte dies +gegenüber dem Gelegenheitsprogrammierer, der einfache Programme +schreibt, unauffällig sein. + +Es ist allerdings notwendig, zwischen Zahlen zu unterscheiden, die exakt +dargestellt werden, und denen, deren Darstellung inexakt sein darf. Zum +Beispiel müssen Indizes auf Datenstrukturen exakt bekannt sein, genau +wie manche Polynomialkoeffizienten eines Systems für symbolische Algebra +exakt bekannt sein müssen. Andererseits sind Messergebnisse an sich +schon inexakt und irrationale Zahlen können durch rationale Zahlen und +somit inexakt angenähert werden. Damit abgefangen werden kann, wenn +inexakte Zahlen benutzt werden, wo exakte Zahlen benötigt werden, +unterscheidet Scheme ausdrücklich zwischen exakten und inexakten Zahlen. +Diese Unterscheidung ist unabhängig von der Größendimension des +Datentyps. + +@node Exaktheit, Implementierungseinschränkungen, Numerische Typen, Zahlen +@subsection Exaktheit + + +@c %R4%% I tried to direct the following paragraph away from philosophizing +@c about the exactness of mathematical numbers, and toward philosophizing +@c about the exactness of Scheme numbers. + + +@cindex @w{Exaktheit} +Scheme-Zahlen sind entweder @i{exakt} oder @i{inexakt}. Eine Zahl ist +@r{exakt}, wenn sie als exakte Konstante geschrieben wurde oder sich aus +@r{exakt}en Zahlen nur durch @r{exakte} Operationen ergeben hat. Eine +Zahl ist @r{inexakt}, wenn sie als inexakte Konstante geschrieben wurde, +@c %R4%% models a quantity (e.g., a measurement) known only approximately, +sich aus @r{inexakten} Zutaten ergeben hat oder sich unter Benutzung +@r{inexakter} Operationen ergeben hat. Daher ist @r{Inexakt}heit eine +ansteckende Eigenschaft einer Zahl. +@c %R4%% The rest of this paragraph (from R3RS) has been dropped. + +Wenn zwei Implementierungen @r{exakte} Ergebnisse für eine Berechnung +liefern, die keine @r{inexakten} Zwischenergebnisse verwendet hat, +werden die beiden Endergebnisse mathematisch äquivalent sein. Dies ist +im Allgemeinen unwahr für Berechnungen, die @r{inexakte} Zahlen +verwenden, denn dort dürfen Näherungsverfahren wie Gleitkommaarithmetik +verwendet werden, aber es ist die Pflicht der jeweiligen +Implementierung, die Ergebnisse so nah ans mathematische Ideal zu +bringen, wie es praktikabel ist. + +Rationale Operationen wie @samp{+} sollten immer @r{exakte} Ergebnisse +liefern, wenn ihnen @r{exakte} Argumente übergeben werden. +@c %R4%%If an implementation is +@c unable to represent an \tupe{exact} result (for example, if it does not +@c support infinite precision integers and rationals) +Wenn die Operation keine @r{exakten} Ergebnisse liefern kann, darf sie +entweder die Verletzung einer Implementierungseinschränkung melden, oder +dem Ergebnis stillschweigend einen @r{inexakten} Wert aufzwingen. +@c %R4%%Such a coercion may cause an error later. +Siehe den Abschnitt @ref{Implementierungseinschränkungen}. + +Mit Ausnahme von @code{inexact->exact} müssen die in diesem Abschnitt +beschriebenen Operationen +@vindex @w{inexact->exact} +im Allgemeinen inexakte Ergebnisse liefern, wenn ihnen auch beliebige +inexakte Argumente gegeben wurden. Eine Operation darf allerdings ein +@r{exaktes} Ergebnis liefern, wenn sie beweisen kann, dass der Wert des +Ergebnisses nicht von der Inexaktheit ihrer Argumente betroffen ist. +Zum Beispiel liefert die Multiplikation einer beliebigen Zahl mit einer +@r{exakten} Null eine @r{exakte} Null als Ergebnis, selbst wenn das +andere Argument @r{inexakt} ist. + +@node Implementierungseinschränkungen, Syntax numerischer Konstanter, Exaktheit, Zahlen +@subsection Implementierungseinschränkungen + + + +@cindex @w{Implementierungseinschränkung} + +Implementierungen von Scheme müssen nicht den gesamten Turm von +Untertypen, die im Abschnitt @ref{Numerische Typen} angegeben wurden, +implementieren, aber sie müssen eine widerspruchsfreie Teilmenge davon +implementieren, die sowohl mit den Zwecken der Implementierung als auch +dem Geist der Scheme-Sprache konsistent ist. Zum Beispiel kann selbst +eine Implementierung, in der alle Zahlen @r{real} (reell) sind, dennoch +ziemlich nützlich sein. + +Implementierungen dürfen auch bloß einen eingeschränkten Wertebereich +eines beliebigen Typs unterstützen, wenn er die Anforderungen dieses +Abschnitts erfüllt. Der unterstützte Bereich @r{exakter} Zahlen eines +beliebigen Typs darf sich von dem unterstützten Bereich @r{inexakter} +Zahlen dieses Typs unterscheiden. Zum Beispiel darf eine +Implementierung, die Gleitkommazahlen zur Darstellung all ihrer +@r{inexakten} @r{reellen} Zahlen verwendet, einen praktisch +unbeschränkten Wertebereich für @r{exakte} @r{ganze} und @r{rationale} +Zahlen unterstützen, während sie den Wertebereich für @r{inexakte} +@r{reelle} (und deswegen auch den Wertebereich für @r{inexakte} +@r{ganze} und @r{rationale} Zahlen) auf den dynamischen Wertebereich des +Gleitkommaformats einschränkt. Desweiteren sind die Lücken zwischen +darstellbaren @r{inexakten} @r{ganzen} und @r{rationalen} Zahlen in +einer solchen Implementierung wahrscheinlich sehr groß, wenn sich die +Zahlen den Grenzen des Wertebereichs annähern. + +Eine Implementierung von Scheme muss exakte ganze Zahlen in dem +Wertebereich unterstützen, der als Index für Listen, Vektoren und +Zeichenketten verwendet werden kann, oder der das Ergebnis der +Berechnung der Länge einer Liste, eines Vektors oder eine Zeichenkette +sein kann. Die Prozeduren @code{Length}, @code{Vector-length}, +@vindex @w{Vector-length} +@vindex @w{Length} +und @code{String-length} müssen eine exakte +@vindex @w{String-length} +ganze Zahl zurückgeben und es ist ein Fehler, etwas anderes als eine +exakte ganze Zahl als Index zu benutzen. Desweiteren wird jede +ganzzahlige Konstante, wenn sie durch eine exakte Syntax für ganze +Zahlen ausgedrückt wurde, tatsächlich auch als eine exakte ganze Zahl +eingelesen, ohne Rücksicht auf jegliche Implementierungseinschränkungen, +die außerhalb dieses Bereichs gelten. Zuletzt werden die unten +angeführten Prozeduren immer eine exakte ganze Zahl als Ergebnis +zurückgeben, sofern all ihre Argumente exakte ganze Zahlen sind und das +mathematisch erwartete Ergebnis als exakte ganze Zahl innerhalb der +Implementierung darstellbar ist: + + +@example + ++ - * +quotient remainder modulo +max min abs +numerator denominator gcd +lcm floor ceiling +truncate round rationalize +expt + +@end example + + +Implementierungen werden ermutigt, sind aber nicht verpflichtet, +@r{exakte} @r{ganze} und @r{exakte} @r{rationale} Zahlen praktisch +unbeschränkter Größe und Genauigkeit zu unterstützen, und die oben +genannten Prozeduren und die Prozedur @samp{/} auf eine Art zu +implementieren, so dass sie immer @r{exakte} Ergebnisse liefern, wenn +ihnen @r{exakte} Argumente gegeben werden. Wenn eine dieser Prozeduren +kein @r{exaktes} Ergebnis liefern kann, obwohl ihr @r{exakte} Argumente +übergeben wurden, dann darf sie entweder eine Verletzung einer +Implementierungseinschränkung melden oder sie darf stillschweigend dem +Ergebnis einen @r{inexakten} Wert aufzwingen. Ein solches Aufzwingen +darf später zu einem Fehler führen. + +@c %R4%% I moved this stuff here. +@c It seems to me that the only thing that this requires is that +@c implementations that support inexact numbers have to have both +@c exact and inexact representations for the integers 0 through 15. +@c If that's what it's saying, I'd rather say it that way. +@c On the other hand, letting the limit be as small as 15 sounds a +@c tad silly, though I think I understand how that number was arrived at. +@c (Or is 35 the number?) + +@c Implementations are encouraged, but not required, to support \tupe{inexact} +@c numbers. For any implementation that supports \tupe{inexact} numbers, +@c there is a subset of the integers for which there are both \tupe{exact} and +@c \tupe{inexact} representations. This subset must include all non-negative +@c integers up to some limit specified by the implementation. This limit +@c must be 16 or greater. The +@c \ide{exact\coerce{}inexact} and \ide{inexact\coerce{}exact} +@c procedures implement the natural one-to-one correspondence between +@c the \tupe{inexact} and \tupe{exact} integers within this range. + +Eine Implementierung darf Gleitkommazahlen und andere näherungsweise +Darstellungsstrategien für @r{inexakte} Zahlen benutzen. +@c %R4%% The following sentence seemed a bit condescending as well as +@c awkward. It didn't seem to be very enforceable, so I flushed it. + +@c This is not to +@c say that implementors need not use the best known algorithms for +@c \tupe{inexact} computations---only that approximate methods of high +@c quality are allowed. + +Dieser Bericht empfiehlt, setzt aber nicht voraus, dass +Implementierungen, die Gleitkommadarstellungen benutzen, den +IEEE-Standards für 32-Bit- und 64-Bit-Gleitkommazahlen folgen, und dass +Implementierungen, die andere Darstellungen benutzen, dieselbe oder eine +höhere Genauigkeit bieten, wie sie unter Benutzung dieser +Gleitkommastandards erreicht werden kann [IEEE]. + +Insbesondere müssen Implementierungen, die eine Gleitkommadarstellung +verwenden, diesen Regeln folgen: Ein Gleitkommaergebnis muss mit +mindestens soviel Genauigkeit dargestellt werden, wie Genauigkeit +benutzt wurde, um ein beliebiges Argument der Operation auszudrücken. +Es ist wünschenswert (aber nicht notwendig), dass womöglich inexakte +Operationen wie @samp{Sqrt}, wenn sie auf @r{exakte} Argumente angewandt +werden, @r{exakte} Antworten liefern, wann immer das möglich ist (zum +Beispiel sollte die Quadratwurzel einer @r{exakten} 4 eine @r{exakte} 2 +sein). Wenn eine Operation jedoch anhand einer @r{exakten} Zahl ein +@r{inexaktes} Ergebnis liefert (wie durch @samp{Sqrt}), und wenn das +Ergebnis als eine Gleitkommazahl dargestellt wird, dann muss dafür das +verfügbare Gleitkommaformat mit der höchsten Genauigkeit benutzt werden, +aber wenn das Ergebnis auf andere Art dargestellt wird, muss die +Darstellung mindestens soviel Genauigkeit wie das genaueste verfügbare +Gleitkommaformat haben. + +Obwohl Scheme eine Vielfalt geschriebener +@c %R4%% representations of +Notationen für Zahlen unterstützt, darf eine Implementierung auch nur +manche davon unterstützen. +@c %R4%% +Zum Beispiel muss eine Implementierung nicht die kartesische und polare +Notation für komplexe Zahlen unterstützen. Wenn eine Implementierung +eine @r{exakte} numerische Konstante vorfindet, die sie nicht als eine +@r{exakte} Zahl darstellen kann, darf sie entweder eine Verletzung einer +Implementierungseinschränkung melden oder stillschweigend die Konstante +durch eine @r{inexakte} Zahl darstellen. + + +@node Syntax numerischer Konstanter, Numerische Operationen, Implementierungseinschränkungen, Zahlen +@subsection Syntax numerischer Konstanter + + + +@c @@@@LOSE@@@@ + +@c %R4%% I removed the following paragraph in an attempt to tighten up +@c this subsection. Except for its first sentence, which I moved to +@c the subsection on implementation restrictions, I think its content +@c is implied by the rest of the section. + +@c Although Scheme allows a variety of written representations of numbers, +@c any particular implementation may support only some of them. +@c These syntaxes are intended to be purely notational; any kind of number +@c may be written in any form that the user deems convenient. Of course, +@c writing 1/7 as a limited-precision decimal fraction will not express the +@c number exactly, but this approximate form of expression may be just what +@c the user wants to see. + +Die Syntax der geschriebenen Darstellungen für Zahlen wird formal im +Abschnitt @ref{Lexikalische Struktur} beschrieben. Beachten Sie, dass +Groß- und Kleinschreibung für numerische Konstante nicht unterschieden +wird. + +@c %R4%% See section~\ref{numberformats} for many examples. + +Eine Zahl darf binär, oktal, dezimal oder hexadezimal durch Nutzung +eines Radix-Präfixes geschrieben werden. Die Radix-Präfixe sind +@samp{#b} (binär), @samp{#o} (oktal), @samp{#d} (dezimal) und @samp{#x} +(hexadezimal). Ohne +@vindex #x +@vindex #d +@vindex #o +@vindex #b +ein Radix-Präfix wird eine Zahl als dezimal angenommen. + +Eine +@c %R4%% +@c simple +numerische Konstante darf durch ein Präfix als entweder @r{exakt} oder +@r{inexakt} festgelegt werden. Die Präfixe sind @samp{#e} +@vindex #e +für @r{exakt} und @samp{#i} für @r{inexakt}. Ein Exaktheitspräfix +@vindex #i +darf vor oder nach einem beliebigen benutzten Radix-Präfix stehen. Wenn +die geschriebene Darstellung einer Zahl kein Exaktheitspräfix hat, kann +die Konstante entweder @r{inexakt} oder @r{exakt} sein. Sie ist +@r{inexakt}, wenn sie einen Punkt als Dezimaltrennzeichen, einen +Exponenten oder ein „#``-Zeichen anstelle einer Ziffer, andernfalls ist +sie @r{exakt}. +@c %R4%% With our new syntax, the following sentence is redundant: + +@c The written representation of a +@c compound number, such as a ratio or a complex, is exact if and only if +@c all of its constituents are exact. + +In Systemen mit @r{inexakten} Zahlen verschiedener Genauigkeiten kann es +nützlich sein, die Genauigkeit einer Konstanten anzugeben. Zu diesem +Zweck dürfen numerische Konstante mit einer Exponentenmarkierung +geschrieben werden, die die gewünschte Genauigkeit der @r{inexakten} +Darstellung anzeigt. Die Buchstaben @samp{s}, @samp{f}, @samp{d} und +@samp{l} legen jeweils die Nutzung von kleiner („@var{short}``), +einfacher („@var{single}``), doppelter („@var{double}``) und großer +(„@var{long}``) Genauigkeit fest. (Wenn weniger als vier interne +@c %R4%%\tupe{flonum} +@r{inexakte} Darstellungen existieren, werden die vier spezifizierten +Größen auf die verfügbaren abgebildet. Zum Beispiel darf eine +Implementierung mit zwei internen Darstellungen „short`` und „single`` +zusammenlegen und „long`` und „double`` zusammenlegen.) Zusätzlich +steht die Exponentenmarkierung @samp{e} für die standardmäßige +Genauigkeit der Implementierung. Die standardmäßige Genauigkeit ist +mindestens so genau wie @var{double}, aber Implementierungen dürfen es +der Nutzerin erlauben, den Standard festzusetzen. + + +@example + +3.14159265358979F0 + @r{Runden auf single ---} 3.141593 +0.6L0 + @r{Erweitern auf long ---} .600000000000000 + +@end example + + + +@node Numerische Operationen, Numerische Ein- und Ausgabe, Syntax numerischer Konstanter, Zahlen +@subsection Numerische Operationen + + +Der Leser sei verwiesen auf den Abschnitt @ref{Eintragsformat} für eine +Zusammenfassung der Namenskonventionen, mit denen Einschränkungen der +Argumenttypen numerischer Routinen angegeben werden. +@c %R4%% The following sentence has already been said twice, and the +@c term "exactness-preserving" is no longer defined by the Report. + +@c Remember that +@c an exactness-preserving operation may coerce its result to inexact if the +@c implementation is unable to represent it exactly. +Die in diesem Abschnitt benutzten Beispiele gehen davon aus, dass jede +mit @r{exakter} Notation angegebene numerische Konstante tatsächlich als +eine @r{exakte} Zahl dargestellt wird. Manche Beispiele gehen auch +davon aus, dass bestimmte numerische Konstante, die mit @r{inexakter} +Notation geschrieben wurden, ohne Verlust von Genauigkeit dargestellt +werden können; die @r{inexakten} Konstanten wurden so gewählt, dass dies +in Implementierungen, die Gleitkommazahlen benutzen, um inexakte Zahlen +darzustellen, wahrscheinlich der Fall ist. + +@ignore todo +Scheme provides the usual set of operations for manipulating +numbers, etc. +@end ignore + + + +@deffn {Prozedur} number? obj +@deffnx {Prozedur} complex? obj +@deffnx {Prozedur} real? obj +@deffnx {Prozedur} rational? obj +@deffnx {Prozedur} integer? obj + +Diese numerischen Typprädikate können auf jede Art von Argument +angewandt werden, auch auf Nichtzahlen. Sie geben @t{#t} zurück, wenn +das Objekt den genannten Typ hat, und sonst geben sie @t{#f} zurück. +Im Allgemeinen ist, wenn ein Typprädikat für eine Zahl wahr ist, auch +jedes höhere Typprädikat für diese Zahl wahr. Umgekehrt sind, wenn ein +Typprädikat für eine Zahl falsch ist, alle niedrigeren Typprädikate für +diese Zahl auch falsch. +@c %R4%% The new section on implementation restrictions subsumes: +@c Not every system +@c supports all of these types; for example, it is entirely possible to have a +@c Scheme system that has only \tupe{integer}s. Nonetheless every implementation +@c of Scheme must have all of these predicates. + +Wenn @var{z} eine inexakte komplexe Zahl ist, dann ist @samp{(real? +@var{z})} genau dann wahr, wenn @samp{(zero? (imag-part @var{z}))} wahr +ist. Wenn @var{x} eine inexakte reelle Zahl ist, dann ist +@samp{(integer? @var{x})} genau dann wahr, wenn @samp{(= @var{x} (round +@var{x}))}. + + +@format +@t{(complex? 3+4i) ==> #t +(complex? 3) ==> #t +(real? 3) ==> #t +(real? -2.5+0.0i) ==> #t +(real? #e1e10) ==> #t +(rational? 6/10) ==> #t +(rational? 6/3) ==> #t +(integer? 3+0i) ==> #t +(integer? 3.0) ==> #t +(integer? 8/4) ==> #t +} +@end format + + + +@quotation +@emph{Anmerkung:} +Das Verhalten dieser Typprädikate ist auf @r{inexakten} Zahlen +unverlässlich, denn jede Ungenauigkeit kann das Ergebnis beeinflussen. +@end quotation + + + +@quotation +@emph{Anmerkung:} +In vielen Implementierung wird die Prozedur @code{Rational?} dieselbe +sein wie +@vindex @w{Rational?} +@code{Real?} und die Prozedur @code{Complex?} wird dieselbe sein wie +@vindex @w{Complex?} +@vindex @w{Real?} +@code{Number?}, aber ungewöhnliche Implementierungen könnten nur in der +Lage sein, +@vindex @w{Number?} +manche irrationale Zahlen exakt darzustellen, oder das Zahlensystem +erweitern, so dass es auch eine Art nicht komplexer Zahlen unterstützt. +@end quotation + + +@end deffn + + +@deffn {Prozedur} exact? @var{z} +@deffnx {Prozedur} inexact? @var{z} + +Diese numerischen Prädikate bieten Exaktheitheitsprüfungen einer Größe +an. Für jede beliebige Scheme-Zahl ist genau eines dieser Prädikate +wahr. + +@end deffn + + + +@deffn {Prozedur} = z1 z2 z3 @dots{}, +@deffnx {Prozedur} < x1 x2 x3 @dots{}, +@deffnx {Prozedur} > x1 x2 x3 @dots{}, +@deffnx {Prozedur} <= x1 x2 x3 @dots{}, +@deffnx {Prozedur} >= x1 x2 x3 @dots{}, + +@c - Some implementations allow these procedures to take many arguments, to +@c - facilitate range checks. +Diese Prozeduren geben @t{#t} zurück, wenn ihre Argumente (jeweils) +gleich, monoton steigend, monoton fallend, monoton nicht fallend oder +monoton nicht steigend sind. + +Diese Prädikate müssen transitiv sein. + + +@quotation +@emph{Anmerkung:} +Die traditionelle Implementierung dieser Prädikate in Lisp-artigen +Sprachen ist nicht transitiv. +@end quotation + + + +@quotation +@emph{Anmerkung:} +Auch wenn es kein Fehler ist, @r{inexakte} Zahlen mit diesen Prädikaten +zu vergleichen, können die Ergebnisse unverlässlich sein, weil eine +kleine Ungenauigkeit das Ergebnis beeinflussen kann; dies gilt besonders +für @code{=} und @code{Zero?}. +@vindex @w{Zero?} +@vindex @w{=} +Fragen Sie im Zweifel einen Numeriker um Rat. +@end quotation + + +@end deffn + + +@deffn {Bibliotheksprozedur} zero? @var{z} +@deffnx {Bibliotheksprozedur} positive? @var{x} +@deffnx {Bibliotheksprozedur} negative? @var{x} +@deffnx {Bibliotheksprozedur} odd? @var{n} +@deffnx {Bibliotheksprozedur} even? @var{n} + +Diese numerischen Prädikate prüfen, ob eine bestimmte Eigenschaft für +eine Zahl gilt, und geben @t{#t} oder @t{#f} zurück. Siehe obige +Anmerkung. + +@end deffn + + +@deffn {Bibliotheksprozedur} max x1 x2 @dots{}, +@deffnx {Bibliotheksprozedur} min x1 x2 @dots{}, + +Diese Prozeduren geben das Maximum oder Minimum ihrer Argumente zurück. + + +@format +@t{(max 3 4) ==> 4 ; exakt +(max 3.9 4) ==> 4.0 ; inexakt +} +@end format + + + +@quotation +@emph{Anmerkung:} +Solange ein beliebiges Argument inexakt ist, wird auch das Ergebnis +inexakt sein (außer die Prozedur kann beweisen, dass die Ungenauigkeit +nicht groß genug ist, um das Ergebnis zu beeinflussen, was nur in +ungewöhnlichen Implementierungen möglich ist). Wenn @samp{Min} oder +@samp{Max} zum Vergleich von Zahlen unterschiedlicher Exaktheit benutzt +wird und der numerische Wert des Ergebnisses nicht als eine inexakte +Zahl dargestellt werden kann, ohne Genauigkeit zu verlieren, dann darf +die Prozedur eine Verletzung einer Implementierungseinschränkung melden. +@end quotation + + +@end deffn + + + +@deffn {Prozedur} + z1 @dots{}, +@deffnx {Prozedur} * z1 @dots{}, + +Diese Proceduren geben die Summe oder das Produkt ihrer Argumente +zurück. +@c - These procedures are exactness preserving. + + +@format +@t{(+ 3 4) ==> 7 +(+ 3) ==> 3 +(+) ==> 0 +(* 4) ==> 4 +(*) ==> 1 +} +@end format + + +@end deffn + + + +@deffn {Prozedur} - z1 z2 +@deffnx {Prozedur} - @var{z} +@deffnx {optionale Prozedur} - z1 z2 @dots{}, +@deffnx {Prozedur} / z1 z2 +@deffnx {Prozedur} / @var{z} +@deffnx {optionale Prozedur} / z1 z2 @dots{}, + +Für zwei oder mehr Argumente geben diese Prozeduren die Differenz oder +den Quotienten ihrer Argumente zurück, linksassoziativ. Mit einem +Argument geben sie jedoch das additiv oder multiplikativ Inverse ihres +Arguments zurück. +@c - These procedures are exactness preserving, except that division may +@c - coerce its result to inexact in implementations that do not support +@c - \tupe{ratnum}s. + + +@format +@t{(- 3 4) ==> -1 +(- 3 4 5) ==> -6 +(- 3) ==> -3 +(/ 3 4 5) ==> 3/20 +(/ 3) ==> 1/3 +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} abs x + +@samp{Abs} gibt den Absolutbetrag ihres Arguments zurück. +@c - {\cf Abs} is exactness preserving when its argument is real. + +@format +@t{(abs -7) ==> 7 +} +@end format + +@end deffn + + + +@deffn {Prozedur} quotient n1 n2 +@deffnx {Prozedur} remainder n1 n2 +@deffnx {Prozedur} modulo n1 n2 + +Diese Prozeduren implementieren zahlentheoretische (ganzzahlige) +Division. @var{n2} sollte nicht null sein. Alle drei Prozeduren geben +ganze Zahlen zurück. Wenn @var{n1}/@var{n2} eine ganze Zahl ist: + +@format +@t{ (quotient @var{n1} @var{n2}) ==> @var{n1}/@var{n2} + (remainder @var{n1} @var{n2}) ==> 0 + (modulo @var{n1} @var{n2}) ==> 0 +} +@end format + +Wenn @var{n1}/@var{n2} keine ganze Zahl ist: + +@format +@t{ (quotient @var{n1} @var{n2}) ==> @var{n_q} + (remainder @var{n1} @var{n2}) ==> @var{n_r} + (modulo @var{n1} @var{n2}) ==> @var{n_m} +} +@end format + +wobei @var{n_q} der Wert von @var{n1}/@var{n2} gegen null gerundet ist, +0 < |@var{n_r}| < |@var{n2}|, 0 < |@var{n_m}| < |@var{n2}|, @var{n_r} +und @var{n_m} sich von @var{n1} um ein Vielfaches von @var{n2} +unterscheidet, @var{n_r} dasselbe Vorzeichen wie @var{n1} hat und +@var{n_m} dasselbe Vorzeichen wie @var{n2} hat. + +Daraus können wir schließen, dass für ganze Zahlen @var{n1} und @var{n2} +mit @var{n2} ungleich 0 gilt, dass + +@format +@t{ (= @var{n1} (+ (* @var{n2} (quotient @var{n1} @var{n2})) + (remainder @var{n1} @var{n2}))) + ==> #t +} +@end format + +sofern alle in der Berechnung vorkommenden Zahlen exakt sind. + + +@format +@t{(modulo 13 4) ==> 1 +(remainder 13 4) ==> 1 + +(modulo -13 4) ==> 3 +(remainder -13 4) ==> -1 + +(modulo 13 -4) ==> -3 +(remainder 13 -4) ==> 1 + +(modulo -13 -4) ==> -1 +(remainder -13 -4) ==> -1 + +(remainder -13 -4.0) ==> -1.0 ; inexakt +} +@end format + +@end deffn + + +@deffn {Bibliotheksprozedur} gcd n1 @dots{}, +@deffnx {Bibliotheksprozedur} lcm n1 @dots{}, + +Diese Prozeduren geben den größten gemeinsamen Teilrt („greatest common +divisor``) oder das kleinste gemeinsame Vielfache („least common +multiple``) ihrer Argumente zurück. Das Ergebnis ist nie negativ. +@c - These procedures are exactness preserving. + +@c %R4%% I added the inexact example. + +@format +@t{(gcd 32 -36) ==> 4 +(gcd) ==> 0 +(lcm 32 -36) ==> 288 +(lcm 32.0 -36) ==> 288.0 ; inexakt +(lcm) ==> 1 +} +@end format + + +@end deffn + + + +@deffn {Prozedur} numerator @var{q} +@deffnx {Prozedur} denominator @var{q} + +Diese Prozeduren geben den Zähler („numerator``) oder den Nenner +(„denominator``) ihres Arguments zurück; das Ergebnis wird berechnet, +als wäre das Argument als unkürzbarer Bruch dargestellt. Der Nenner ist +immer positiv. Der Nenner von 0 ist auf 1 festgelegt. +@c - The remarks about denominators are new. +@c - Clearly, they are exactness-preserving procedures. + +@ignore todo +More description and examples needed. +@end ignore + + +@format +@t{(numerator (/ 6 4)) ==> 3 +(denominator (/ 6 4)) ==> 2 +(denominator + (exact->inexact (/ 6 4))) ==> 2.0 +} +@end format + + +@end deffn + + + +@deffn {Prozedur} floor x +@deffnx {Prozedur} ceiling x +@deffnx {Prozedur} truncate x +@deffnx {Prozedur} round x + + +Diese Prozeduren geben ganze Zahlen zurück. +@samp{Floor} („abrunden``) gibt die größte ganze Zahl zurück, die nicht +größer als @var{x} ist. +@samp{Ceiling} („aufrunden``) gibt die kleinste ganze Zahl zurück, die +nicht kleiner als @var{x} ist. +@samp{Truncate} („abschneiden``) gibt die am nächsten bei @var{x} +liegende ganze Zahl zurück, deren Absolutbetrag nicht größer als der +Absolutbetrag von @var{x} ist. @samp{Round} („runden``) gibt die am +nächsten bei @var{x} liegende ganze Zahl zurück; sie rundet auf die +nächste gerade ganze Zahl, wenn @var{x} genau in der Mitte zwischen zwei +ganzen Zahlen liegt. + + +@quotation +@emph{Begründung:} +@samp{Round} rundet auf gerade Zahlen, um mit dem standardmäßigen +Rundungsmodus, der vom IEEE-Gleitkommastandard festgelegt wurde, +übereinzustimmen. +@end quotation + + + +@quotation +@emph{Anmerkung:} +Wenn das Argument einer dieser Prozeduren inexakt ist, dann wird das +Ergebnis auch inexakt sein. Wird ein exakter Wert benötigt, sollte das +Ergebnis an die Prozedur @samp{Inexact->exact} weitergereicht werden. +@end quotation + + + +@format +@t{(floor -4.3) ==> -5.0 +(ceiling -4.3) ==> -4.0 +(truncate -4.3) ==> -4.0 +(round -4.3) ==> -4.0 + +(floor 3.5) ==> 3.0 +(ceiling 3.5) ==> 4.0 +(truncate 3.5) ==> 3.0 +(round 3.5) ==> 4.0 ; inexakt + +(round 7/2) ==> 4 ; exakt +(round 7) ==> 7 +} +@end format + + +@end deffn + + +@deffn {Bibliotheksprozedur} rationalize x y +@c - \proto{rationalize}{ x}{Prozedur} + + +@samp{Rationalize} gibt die @emph{einfachste} rationale Zahl zurück, die +sich von @var{x} nicht um mehr als @var{y} unterscheidet. Eine +rationale Zahl r_1 ist @emph{einfacher} als eine andere rationale Zahl +@cindex @w{einfachste rationale Zahl} +r_2, wenn r_1 = p_1/q_1 und r_2 = p_2/q_2 (unkürzbare Brüche) und +|p_1|<= |p_2| und |q_1| <= |q_2|. Somit ist 3/5 einfacher als 4/7. +Obwohl nicht alle rationalen Zahlen in dieser Ordnung vergleichbar sind +(betrachten Sie 2/7 und 3/5), enthält jedes beliebige Intervall eine +rationale Zahl, die einfacher ist als jede andere rationale Zahl in +diesem Intervall (die einfachere 2/5 liegt zwischen 2/7 und 3/5). +Beachten Sie, dass 0 = 0/1 die einfachste rationale Zahl von allen ist. + + +@format +@t{(rationalize + (inexact->exact .3) 1/10) ==> 1/3 ; exakt +(rationalize .3 1/10) ==> #i1/3 ; inexakt +} +@end format + + +@end deffn + + +@deffn {Prozedur} exp @var{z} +@deffnx {Prozedur} log @var{z} +@deffnx {Prozedur} sin @var{z} +@deffnx {Prozedur} cos @var{z} +@deffnx {Prozedur} tan @var{z} +@deffnx {Prozedur} asin @var{z} +@deffnx {Prozedur} acos @var{z} +@deffnx {Prozedur} atan @var{z} +@deffnx {Prozedur} atan @var{y} @var{x} + +Diese Prozeduren sind Teil jeder Implementierung, die +@c %R4%% +allgemeine +reelle Zahlen unterstützt; sie berechnen die üblichen transzendenten +Funktionen. @samp{Log} berechnet den natürlichen Logarithmus von +@var{z} (nicht den Logarithmus zur Basis 10). @samp{Asin}, @samp{Acos} +und @samp{Atan} berechnen jeweils den Arkussinus (sin^-1), Arkuskosinus +(cos^-1) und Arkustangens (tan^-1). Die Variante mit zwei Argumenten +von @samp{Atan} berechnet @t{(angle (make-rectangular @var{x} @var{y}))} +(siehe unten), selbst in Implementierungen, die komplexe Zahlen nicht +allgemein unterstützen. + +Im Allgemeinen sind die mathematischen Funktionen log, arcsine, +arccosine und arctangent verschiedenartig definiert. +Der Wert von log z ist definiert als diejenige Zahl, deren Imaginärteil +im Bereich von -Pi (nicht einschließlich) bis Pi (einschließlich) liegt. +log 0 ist undefiniert. +Mit dem so definierten log ergeben sich die Werte von sin^-1 z, cos^-1 z +und tan^-1 z anhand der folgenden Formeln: + + +@center sin^-1 z = -i log (i z + sqrt(1 - z^2)) + + + +@center cos^-1 z = pi / 2 - sin^-1 z + + + +@center tan^-1 z = (log (1 + i z) - log (1 - i z)) / (2 i) + + +Die obige Spezifikation folgt [CLtL], wo wiederum [Penfield81] zitiert +wird; konsultieren Sie diese Quellen für detailliertere Diskussionen von +Verzweigungsschnitten, Randbedingungen und die Implementierung dieser +Funktionen. Wenn möglich liefern diese Prozeduren ein reelles Ergebnis +für ein reelles Argument. + +@c %R4%% + +@ignore todo +The cited references are likely to change their branch cuts +soon to allow for the possibility of distinct positive and negative +zeroes, as in IEEE floating point. We may not want to follow those +changes, since we may want a complex number with zero imaginary part +(whether positive or negative zero) to be treated as a real. I don't +think there are any better standards for complex arithmetic than the +ones cited, so we're really on our own here. +@end ignore + + +@end deffn + + + +@deffn {Prozedur} sqrt @var{z} + +Gibt die Haupt-Quadratwurzel von @var{z} zurück. Das Ergebnis wird +entweder einen positiven Realteil oder haben, oder null Realteil und +nicht-negativen Imaginärteil haben. +@end deffn + + + +@deffn {Prozedur} expt z1 z2 + +Gibt @var{z1} zur Potenz @var{z2} zurück. Für z_1 ~= 0 + + +@center z_1^z_2 = e^z_2 log z_1 + +0^z ist 1 wenn z = 0, und 0 sonst. +@end deffn + +@c - \begin{entry}{%- +@c - \proto{approximate}{ z x}{Prozedur}} +@c - +@c - Returns an approximation to \vr{z} in a representation whose precision is +@c - the same as that +@c - of the representation of \vr{x}, which must be an inexact number. The +@c - result is always inexact. +@c - +@c - \begin{scheme} +@c - (approximate 3.1415926535 1F10) +@c - \ev 3.14159F0 +@c - (approximate 3.1415926535 \#I65535) +@c - \ev \#I3 +@c - (approximate 3.14F0 1L8) +@c - \ev 3.14L0 +@c - (approximate 3.1415926535F0 1L8) +@c - \ev 3.14159L0 +@c - \end{scheme} +@c - \end{entry} + + + + +@deffn {Prozedur} make-rectangular x1 x2 +@deffnx {Prozedur} make-polar x3 x4 +@deffnx {Prozedur} real-part @var{z} +@deffnx {Prozedur} imag-part @var{z} +@deffnx {Prozedur} magnitude @var{z} +@deffnx {Prozedur} angle @var{z} + +Diese Prozeduren sind Teil jeder Implementierung, die +@c %R4%% +allgemeine +komplexe Zahlen unterstützt. Angenommen @var{x1}, @var{x2}, @var{x3} +und @var{x4} sind reelle Zahlen und @var{z} ist eine komplexe Zahl, so +dass + + +@center @var{z} = @var{x1} + @var{x2}@w{i} = @var{x3} . e^@w{i} @var{x4} + +Dann + +@format +@t{(make-rectangular @var{x1} @var{x2}) ==> @var{z} +(make-polar @var{x3} @var{x4}) ==> @var{z} +(real-part @var{z}) ==> @var{x1} +(imag-part @var{z}) ==> @var{x2} +(magnitude @var{z}) ==> |@var{x3}| +(angle @var{z}) ==> x_Winkel +} +@end format + +wobei -Pi < x_Winkel <= Pi mit x_Winkel = @var{x4} + 2Pi n +für eine ganze Zahl n. + + +@quotation +@emph{Begründung:} +@samp{Magnitude} ist dasselbe wie @code{Abs} für ein reelles Argument, +@vindex @w{Abs} +aber @samp{Abs} muss in allen Implementierungen vorhanden sein, während +@samp{Magnitude} nur in Implementierungen vorhanden sein muss, die +allgemeine komplexe Zahlen unterstützen. +@end quotation + + +@end deffn + + + +@deffn {Prozedur} exact->inexact @var{z} +@deffnx {Prozedur} inexact->exact @var{z} + +@samp{Exact->inexact} gibt eine @r{inexakte} Darstellung von @var{z} +zurück. Der zurückgegebene Wert ist die @r{inexakte} Zahl, die +numerisch dem Argument am nächsten liegen. +@c %R4%%For +@c \tupe{exact} arguments which have no reasonably close \tupe{inexact} equivalent, +@c it is permissible to signal an error. +Wenn ein @r{exaktes} Argument kein @r{inexaktes} Gegenstück in +vernünftiger Nähe hat, dann darf eine Verletzung einer +Implementierungseinschränkung gemeldet werden. + +@samp{Inexact->exact} gibt eine @r{exakte} Darstellung von @var{z} +zurück. Der zurückgegebene Wert ist die @r{exakte} Zahl, die numerisch +dem Argument am nächsten liegt. +@c %R4%% For \tupe{inexact} arguments which have no +@c reasonably close \tupe{exact} equivalent, it is permissible to signal +@c an error. +Wenn ein @r{inexaktes} Argument kein @r{exaktes} Gegenstück in +vernünftiger Nähe hat, dann darf eine Verletzung einer +Implementierungseinschränkung gemeldet werden. + +@c %R%% I moved this to the section on implementation restrictions. +@c For any implementation that supports \tupe{inexact} quantities, +@c there is a subset of the integers for which there are both \tupe{exact} and +@c \tupe{inexact} representations. This subset must include the non-negative +@c integers up to a limit specified by the implementation. The limit +@c must be big enough to represent all digits in reasonable radices, and +@c may correspond to some natural word size for the implementation. For +@c such integers, these procedures implement the natural one-to-one +@c correspondence between the representations. + +Diese Prozeduren implementieren die natürliche +Eins-zu-eins-Korrespondenz zwischen @r{exakten} und @r{inexakten} ganzen +Zahlen innerhalb eines implementierungsabhängigen Wertebereichs. Siehe +den Abschnitt @ref{Implementierungseinschränkungen}. + +@end deffn + +@sp 3 + +@node Numerische Ein- und Ausgabe, , Numerische Operationen, Zahlen +@subsection Numerische Ein- und Ausgabe + + + +@deffn {Prozedur} number->string z +@deffnx {Prozedur} number->string z radix + +@var{Radix} muss eine exakte ganze Zahl sein, entweder 2, 8, 10 oder 16. +Wenn er nicht angegeben wird, nimmt @var{Radix} standardmäßig den Wert +10 an. +Die Prozedur @samp{Number->string} nimmt eine Zahl und eine Radix und +gibt als String eine externe Darstellung der gegebenen Zahl zur +angegebenen Basis (die Radix) zurück, so dass + +@format +@t{(let ((number @var{Zahl}) + (radix @var{Radix})) + (eqv? Zahl + (string->number (number->string Zahl + Radix) + Radix))) +} +@end format + +wahr ist. Es ist ein Fehler, wenn kein mögliches Ergebnis diesen +Ausdruck wahr macht. + +Wenn @var{z} inexakt ist, die Radix 10 beträgt und obiger Ausdruck durch +ein Ergebnis erfüllt werden kann, das ein Dezimaltrennzeichen enthält, +dann enthält das Ergebnis einen Dezimalpunkt als Dezimaltrennzeichen und +wird mit der geringstmöglichen Anzahl Ziffern ausgedrückt (den +Exponenten und folgende Nullen nicht eingeschlossen), die nötig sind, um +obigen Ausdruck wahr zu machen [howtoprint], [howtoread], andernfalls +ist das Format des Ergebnisses unbestimmt. + +Das von @samp{Number->string} zurückgegebene Ergebnis enthält niemals +ein explizites Radix-Präfix. + + +@quotation +@emph{Anmerkung:} +Der Fehlerfall kann nur eintreten, wenn @var{z} keine komplexe Zahl oder +eine komplexe Zahl mit nicht-rationalem reellem oder imaginären Anteil +ist. +@end quotation + + + +@quotation +@emph{Begründung:} +Wenn @var{z} eine inexakte Zahl ist, die mit Gleitkommazahlen +dargestellt ist, und die Radix 10 ist, dann wird obiger Ausdruck +normalerweise von einem Ergebnis mit Dezimaltrennzeichen erfüllt. Der +unbestimmte Fall erlaubt Unendlichkeiten, NaNs und +Nichtgleitkommadarstellungen. +@end quotation + + +@end deffn + + + +@deffn {Prozedur} string->number string +@deffnx {Prozedur} string->number string radix + +@c %R4%% I didn't include the (string->number string radix exactness) +@c case, since I haven't heard any resolution of the coding to be used +@c for the third argument. + +Gibt eine Zahl mit der genauestmöglichen Darstellung zurück, die von der +gegebenen Zeichenkette @var{String} ausgedrückt wird. @var{Radix} muss +eine exakte ganze Zahl, entweder 2, 8, 10 oder 16, sein. Wenn +angegeben, ist @var{Radix} eine Standardbasis, gegenüber der ein +ausdrücklich angegebenes Radix-Präfix in @var{String} Vorrang hat +(@abbr{z.B.} @t{"#o177"}). Wenn @var{Radix} nicht angegeben wird, ist +die Standardbasis 10. Wenn @var{String} keine syntaktisch gültige +Notation einer Zahl ist, dann gibt @samp{String->number} den Wert @t{#f} +zurück. + + +@format +@t{(string->number "100") ==> 100 +(string->number "100" 16) ==> 256 +(string->number "1e2") ==> 100.0 +(string->number "15##") ==> 1500.0 +} +@end format + + + +@quotation +@emph{Anmerkung:} +Die Definitionsmenge von @samp{String->number} darf auf folgende Arten +von Implementierungen eingeschränkt werden. @samp{String->number} darf +@t{#f} zurückgeben, wann immer @var{String} ein ausdrückliches +Radix-Präfix enthält. Wenn alle von einer Implementierung unterstützten +Zahlen reell sind, dann darf @samp{String->number} den Wert @t{#f} +zurückgeben, wann immer @var{String} polare oder kartesische Notationen +für komplexe Zahlen benutzt. Wenn alle Zahlen ganze Zahlen sind, darf +@samp{String->number} den Wert @t{#f} zurückgeben, wann immer die +Bruchdarstellung benutzt wird. Wenn alle Zahlen exakt sind, dann darf +@samp{String->number} den Wert @t{#f} zurückgeben, wann immer eine +Exponentenmarkierung oder ein ausdrückliches Exaktheitspräfix benutzt +wird, oder wenn ein @t{#} anstelle einer Ziffer vorkommt. Wenn alle +inexakten Zahlen ganze Zahlen sind, dann darf @samp{String->number} den +Wert @t{#f} zurückgeben, wann immer ein Dezimaltrennzeichen benutzt +wird. +@end quotation + + +@end deffn + +@node Andere Datentypen, Programmflussfunktionalitäten, Zahlen, Standardprozeduren +@section Andere Datentypen + +@menu +* Boolesche Werte:: +* Paare und Listen:: +* Symbole:: +* Zeichen:: +* Zeichenketten:: +* Vektoren:: +@end menu + + +Dieser Abschnitt beschreibt Operationen auf manchen von Schemes +nicht-numerischen Datentypen: booleschen Werten („booleans``), Paaren +(„pairs``), Listen („lists``), Symbolen („symbols``), Zeichen +(„characters``), Zeichenketten („strings``) und Vektoren +(„vectors``). + +@node Boolesche Werte, Paare und Listen, Andere Datentypen, Andere Datentypen +@subsection Boolesche Werte + + + +Die standardmäßigen booleschen Objekte für wahr und falsch werden +geschrieben als @t{#t} und @t{#f}. Was aber wirklich +@vindex #f +@vindex #t +wichtig ist, sind die Objekte, die die bedingten Ausdrücke von Scheme +(@samp{If}, @samp{Cond}, @samp{And}, @samp{Or}, @samp{Do}) als wahr oder +falsch behandeln. Die Formulierung „ein wahrer Wert`` +@cindex @w{falsch} +@cindex @w{wahr} +(oder manchmal kurz „wahr``) bedeutet ein beliebiges Objekt, das von +den bedingten Ausdrücken als wahr behandelt wird, und die Formulierung +„ein falscher Wert`` (oder +@cindex @w{falsch} +„falsch``) bedeutet ein beliebiges Objekt, das von den bedingten +Ausdrücken als falsch behandelt wird. + +Von allen Standard-Scheme-Werten zählt nur @t{#f} +@c is guaranteed to count +als falsch in bedingten Ausdrücken. +@c It is not +@c specified whether the empty list\index{empty list} counts as false +@c or as true in conditional expressions. +Außer @t{#f} +@c and possibly the empty list, +zählen alle Standard-Scheme-Werte, einschließlich @t{#t}, Paaren, der +leeren Liste, Symbolen, Zahlen, Zeichenketten, Vektoren und Prozeduren +als wahr. + +@c \begin{note} +@c In some implementations the empty list counts as false, contrary +@c to the above. +@c Nonetheless a few examples in this report assume that the +@c empty list counts as true, as in \cite{IEEEScheme}. +@c \end{note} + +@c \begin{rationale} +@c For historical reasons some implementations regard \schfalse{} and the +@c empty list as the same object. These implementations therefore cannot +@c make the empty list count as true in conditional expressions. +@c \end{rationale} + + +@quotation +@emph{Anmerkung:} +Programmierer, die an andere Dialekte von Lisp gewöhnt sind, sollten +beachten, dass Scheme sowohl @t{#f} als auch die leere Liste +@cindex @w{leere Liste} +vom Symbol @code{nil} unterscheidet. +@vindex @w{nil} +@end quotation + + +Boolesche Konstante werden zu sich selbst ausgewertet, also müssen sie +in Programmen nicht maskiert werden. + + +@example + +#t ==> #t +#f ==> #f +'#f ==> #f + +@end example + + + + +@deffn {Bibliotheksprozedur} not obj + +@samp{Not} gibt @t{#t} zurück, wenn @var{Obj} falsch ist, und gibt sonst +@t{#f} zurück. + + +@format +@t{(not #t) ==> #f +(not 3) ==> #f +(not (list 3)) ==> #f +(not #f) ==> #t +(not '()) ==> #f +(not (list)) ==> #f +(not 'nil) ==> #f +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} boolean? obj + +@samp{Boolean?} gibt @t{#t} zurück, wenn @var{Obj} entweder @t{#t} oder +@t{#f} ist, und gibt sonst @t{#f} zurück. + + +@format +@t{(boolean? #f) ==> #t +(boolean? 0) ==> #f +(boolean? '()) ==> #f +} +@end format + + +@end deffn + + +@node Paare und Listen, Symbole, Boolesche Werte, Andere Datentypen +@subsection Paare und Listen + + + +Ein @dfn{Paar} (manchmal auch ein @dfn{gepunktetes Paar}, „dotted +pair``) ist eine +@cindex @w{gepunktetes Paar} +@cindex @w{dotted pair} +@cindex @w{Paar} +Verbundsstruktur mit zwei Komponenten, die als die Car- und +Cdr-Komponenten bezeichnet werden (aus historischen Gründen). Paare +werden durch die Prozedur @samp{Cons} erzeugt. Auf die Car- und +Cdr-Komponenten wird durch die Prozeduren @samp{Car} und @samp{Cdr} +zugegriffen. Die Car- und Cdr-Komponenten werden durch die Prozeduren +@samp{Set-car!} und @samp{Set-cdr!} zugewiesen. + +Paare werden vorrangig benutzt, um Listen darzustellen. Eine Liste kann +rekursiv als entweder die leere Liste oder ein Paar, dessen +@cindex @w{leere Liste} +Cdr eine Liste ist, definiert werden. Genauer ist die Menge der Listen +definiert als die kleinste Menge @var{X}, so dass gilt: + + + +@itemize @bullet + +@item +Die leere Liste ist in @var{X}. +@item +Wenn @var{Liste} in @var{X} ist, ist auch jedes Paar in @var{X}, dessen +Cdr-Komponente @var{Liste} enthält. + +@end itemize + + +Die Objekte in den Car-Komponenten aufeinanderfolgender Paare einer +Liste sind die Elemente der Liste. Zum Beispiel ist eine zweielementige +Liste ein Paar, deren Car das erste Element ist und deren Cdr ein Paar +ist, deren Car das zweite Element und deren Cdr die leere Liste ist. +Die Länge einer Liste ist die Anzahl der Elemente, was dasselbe ist wie +die Anzahl der Paare. + +Die leere Liste ist ein besonderes Objekt mit seinem eigenen Typ +@cindex @w{leere Liste} +(sie ist kein Paar); sie hat keine Elemente und ihre Länge ist null. + + +@quotation +@emph{Anmerkung:} +Die obigen Definitionen haben zur Folge, dass alle Listen eine endliche +Länge haben und auf die leere Liste enden. +@end quotation + + +Die allgemeinste Notation (externe Darstellung) für Scheme-Paare ist die +„gepunktete`` Notation @w{@samp{(@var{c1} .@: @var{c2})}}, wobei +@var{c1} der Wert der Car-Komponente und @var{c2} der Wert der +Cdr-Komponente ist. Zum Beispiel ist @samp{(4 .@: 5)} ein Paar, deren +Car 4 ist und deren Cdr 5 ist. Beachten Sie, dass @samp{(4 .@: 5)} die +externe Darstellung eines Paares ist, nicht ein Ausdruck, der zu einem +Paar ausgewertet wird. + +Eine optimiertere Notation kann für Listen benutzt werden: Die Elemente +der Liste werden einfach von runden Klammern umschlossen und durch +Leerzeichen getrennt. Die leere Liste wird als @t{()} geschrieben. Zum +Beispiel sind +@cindex @w{leere Liste} + + +@example + +(a b c d e) + +@end example + + +und + + +@example + +(a . (b . (c . (d . (e . ()))))) + +@end example + + +äquivalente Notationen für eine Liste von Symbolen. + +Eine Kette aus Paaren, die nicht auf die leere Liste endet, wird +@dfn{unechte Liste} genannt. Beachten Sie, dass eine unechte Liste +keine Liste ist. +@cindex @w{unechte Liste} +Die Listennotation und die gepunktete Notation können zur Darstellung +unechter Listen kombiniert werden: + + +@example + +(a b c . d) + +@end example + + +ist äquivalent zu + + +@example + +(a . (b . (c . d))) + +@end example + + +Ob ein bestimmtes Paar eine Liste ist, hängt davon ab, was in der +Cdr-Komponente gespeichert ist. Wenn die Prozedur @code{Set-cdr!} +benutzt wird, kann ein Objekt im einen Moment eine Liste sein +@vindex @w{Set-cdr!} +und im nächsten nicht mehr: + + +@example + +(define x (list 'a 'b 'c)) +(define y x) +y ==> (a b c) +(list? y) ==> #t +(set-cdr! x 4) ==> @emph{unbestimmt} +x ==> (a . 4) +(eqv? x y) ==> #t +y ==> (a . 4) +(list? y) ==> #f +(set-cdr! x x) ==> @emph{unbestimmt} +(list? x) ==> #f + +@end example + + +@c It is often convenient to speak of a homogeneous list of objects +@c of some particular data type, as for example \hbox{\cf (1 2 3)} is a list of +@c integers. To be more precise, suppose \var{D} is some data type. (Any +@c predicate defines a data type consisting of those objects of which the +@c predicate is true.) Then + +@c \begin{itemize} +@c \item The empty list is a list of \var{D}. +@c \item If \var{list} is a list of \var{D}, then any pair whose cdr is +@c \var{list} and whose car is an element of the data type \var{D} is also a +@c list of \var{D}. +@c \item There are no other lists of \var{D}. +@c \end{itemize} + +Innerhalb literaler Ausdrücke und in Darstellungen von mit der Prozedur +@code{Read} gelesenen Objekten bezeichnen die Formen +@t{'}@r{<Datenelement>}, +@vindex ' +@vindex @w{Read} +@t{`}@r{<Datenelement>}, @t{,}@r{<Datenelement>} und +@vindex , +@t{,@@}@r{<Datenelement>} zweielementige Listen, deren erstes Element +jeweils die Symbole @code{Quote}, @code{Quasiquote}, @w{@code{Unquote}} +und +@vindex @w{Unquote} +@vindex @w{Quasiquote} +@vindex @w{Quote} +@code{Unquote-splicing} sind. Das zweite Element ist in allen Fällen +@vindex @w{Unquote-splicing} +@r{<Datenelement>}. Diese Konvention wird unterstützt, damit beliebige +Scheme-Programme als Listen dargestellt werden können. +@ignore todo +Can or need this be stated +more carefully? +@end ignore + Das heißt, dass laut der Grammatik von Scheme jeder <Ausdruck> auch ein +<Datenelement> ist (siehe den Abschnitt @pxref{Externe Darstellung}). +Dies erlaubt unter Anderem, die Prozedur @samp{Read} zu benutzen, um +Scheme-Programme zu verarbeiten. Siehe den Abschnitt @ref{Externe +Darstellungen}. + + + +@deffn {Prozedur} pair? obj + +@samp{Pair?} gibt @t{#t} zurück, wenn @var{Obj} ein Paar ist, und gibt +andernfalls @t{#f} zurück. + + +@format +@t{(pair? '(a . b)) ==> #t +(pair? '(a b c)) ==> #t +(pair? '()) ==> #f +(pair? '#(a b)) ==> #f +} +@end format + +@end deffn + + + +@deffn {Prozedur} cons obj1 obj2 + +Gibt ein neu zugeteiltes Paar zurück, deren Car @var{Obj1} ist und deren +Cdr @var{Obj2} ist. Es wird garantiert, dass das Paar sich (im Sinn von +@samp{Eqv?}) von jedem existierenden Objekt unterscheidet. + + +@format +@t{(cons 'a '()) ==> (a) +(cons '(a) '(b c d)) ==> ((a) b c d) +(cons "a" '(b c)) ==> ("a" b c) +(cons 'a 3) ==> (a . 3) +(cons '(a b) 'c) ==> ((a b) . c) +} +@end format + +@end deffn + + + +@deffn {Prozedur} car paar + +@ignore nodomain +@var{Pair} must be a pair. +@end ignore + +Gibt den Inhalt der Car-Komponente von @var{Paar} zurück. Beachten Sie, +dass es ein Fehler ist, das Car der leeren Liste zu nehmen. +@cindex @w{leere Liste} + + +@format +@t{(car '(a b c)) ==> a +(car '((a) b c d)) ==> (a) +(car '(1 . 2)) ==> 1 +(car '()) ==> @emph{Fehler} +} +@end format + + +@end deffn + + + +@deffn {Prozedur} cdr paar + +@ignore nodomain +@var{Pair} must be a pair. +@end ignore + +Gibt den Inhalt der Cdr-Komponente von @var{Paar} zurück. Beachten Sie, +dass es ein Fehler ist, den Cdr der leeren Liste zu nehmen. + + +@format +@t{(cdr '((a) b c d)) ==> (b c d) +(cdr '(1 . 2)) ==> 2 +(cdr '()) ==> @emph{Fehler} +} +@end format + + +@end deffn + + + +@deffn {Prozedur} set-car! paar obj + +@ignore nodomain +@var{Pair} must be a pair. +@end ignore + +Speichert @var{Obj} in der Car-Komponente von @var{Paar}. Der durch +@samp{Set-car!} zurückgegebene Wert ist unbestimmt. +@c <!> +@c This procedure can be very confusing if used indiscriminately. + + +@format +@t{(define (f) (list 'keine-konstante-Liste)) +(define (g) '(konstante-Liste)) +(set-car! (f) 3) ==> @emph{unbestimmt} +(set-car! (g) 3) ==> @emph{Fehler} +} +@end format + + +@end deffn + + + +@deffn {Prozedur} set-cdr! paar obj + +@ignore nodomain +@var{Pair} must be a pair. +@end ignore + +Speichert @var{Obj} in der Cdr-Komponente von @var{Paar}. Der durch +@samp{Set-cdr!} zurückgegebene Wert ist unbestimmt. +@c <!> +@c This procedure can be very confusing if used indiscriminately. + +@end deffn + + + + + + +@deffn {Bibliotheksprozedur} caar paar +@deffnx {Bibliotheksprozedur} cadr paar + +@deffnx { @w{ @dots{}}} @w{ @dots{}} + +@deffnx {Bibliotheksprozedur} cdddar paar +@deffnx {Bibliotheksprozedur} cddddr paar + +Diese Prozeduren sind Zusammensetzungen von @samp{Car} und @samp{Cdr}, +wobei zum Beispiel @samp{Caddr} definiert werden könnte als + + +@format +@t{(define caddr (lambda (x) (car (cdr (cdr x)))))@r{.} +} +@end format + + +Beliebige Zusammensetzungen, bis zur Tiefe vier, werden angeboten. Es +gibt insgesamt achtundzwanzig solche Prozeduren. + +@end deffn + + + +@deffn {Bibliotheksprozedur} null? obj + +Gibt @t{#t} zurück, wenn @var{Obj} die leere Liste ist, +@cindex @w{leere Liste} +und gibt sonst @t{#f} zurück. + +@c \begin{note} +@c In implementations in which the empty +@c list is the same as \schfalse{}, {\cf null?} will return \schtrue{} +@c if \var{obj} is \schfalse{}. +@c \end{note} + +@end deffn + + +@deffn {Bibliotheksprozedur} list? obj + +Gibt @t{#t} zurück, wenn @var{Obj} eine Liste ist, und gibt sonst @t{#f} +zurück. Per Definition haben alle Listen endliche Länge und enden auf +die leere Liste. + + +@format +@t{ (list? '(a b c)) ==> #t + (list? '()) ==> #t + (list? '(a . b)) ==> #f + (let ((x (list 'a))) + (set-cdr! x x) + (list? x)) ==> #f +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} list @var{obj} @dots{}, + +Gibt eine neu zugeteilte Liste ihrer Argumente zurück. + + +@format +@t{(list 'a (+ 3 4) 'c) ==> (a 7 c) +(list) ==> () +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} length liste + +@ignore nodomain +@var{List} must be a list. +@end ignore + +Gibt die Länge von @var{Liste} zurück. + + +@format +@t{(length '(a b c)) ==> 3 +(length '(a (b) (c d e))) ==> 3 +(length '()) ==> 0 +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} append liste @dots{}, + +@ignore nodomain +All @var{list}s should be lists. +@end ignore + +Gibt eine Liste zurück, die aus den Elementen der ersten @var{Liste}, +gefolgt von den Elementen der anderen @var{Liste}n, besteht. + + +@format +@t{(append '(x) '(y)) ==> (x y) +(append '(a) '(b c d)) ==> (a b c d) +(append '(a (b)) '((c))) ==> (a (b) (c)) +} +@end format + + +Die sich so ergebende Liste wird immer neu zugeteilt, außer dass sie +ihre Struktur mit dem letzten @var{Liste}nargument teilt. Das letzte +Argument darf tatsächlich ein beliebiges Objekt sein; eine unechte Liste +ergibt sich, wenn das letzte Argument keine echte Liste ist. +@ignore todo +This is pretty awkward. I should get Bartley to fix this. +@end ignore + + + +@format +@t{(append '(a b) '(c . d)) ==> (a b c . d) +(append '() 'a) ==> a +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} reverse liste + +@ignore nodomain +@var{List} must be a list. +@end ignore + +Gibt eine neu zugeteilte Liste zurück, die aus den Elementen der +@var{Liste} in umgekehrter Reihenfolge besteht. + + +@format +@t{(reverse '(a b c)) ==> (c b a) +(reverse '(a (b c) d (e (f)))) + ==> ((e (f)) d (b c) a) +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} list-tail liste @var{k} + +Gibt die Teilliste von @var{Liste} zurück, die man durch Weglassen der +ersten @var{k} Elemente erhält. Es ist ein Fehler, wenn @var{Liste} +weniger als @var{k} Elemente hat. @samp{List-tail} könnte definiert +werden als + + +@format +@t{(define list-tail + (lambda (x k) + (if (zero? k) + x + (list-tail (cdr x) (- k 1))))) +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} list-ref liste @var{k} + +Gibt das Element @var{k} der @var{Liste} zurück. (Dieses ist +dasselbe wie das Car von @t{(list-tail @var{list} @var{k})}.) Es ist +ein Fehler, wenn die @var{Liste} weniger als @var{k} Elemente hat. + + +@format +@t{(list-ref '(a b c d) 2) ==> c +(list-ref '(a b c d) + (inexact->exact (round 1.8))) + ==> c +} +@end format + +@end deffn + + +@c \begin{entry}{% +@c \proto{last-pair}{ list}{Bibliotheksprozedur}} + +@c Returns the last pair in the nonempty, possibly improper, list \var{list}. +@c {\cf Last-pair} could be defined by + +@c \begin{scheme} +@c (define last-pair +@c (lambda (x) +@c (if (pair? (cdr x)) +@c (last-pair (cdr x)) +@c x)))% +@c \end{scheme} + +@c \end{entry} + + + +@deffn {Bibliotheksprozedur} memq obj liste +@deffnx {Bibliotheksprozedur} memv obj liste +@deffnx {Bibliotheksprozedur} member obj liste + +Diese Prozeduren geben die erste Teilliste der @var{Liste} zurück, deren +Car @var{Obj} ist, wobei die Teillisten der @var{Liste} die von +@t{(list-tail @var{Liste} @var{k})} zurückgegebenen nicht-leeren Listen +für @var{k} kleiner als die Länge der Liste sind. Wenn @var{Obj} in +@var{Liste} nicht vorkommt, dann wird @t{#f} (nicht die leere Liste) +zurückgegeben. @samp{Memq} benutzt @samp{Eq?} zum Vergleichen von +@var{Obj} mit den Elementen der @var{Liste}, während @samp{Memv} die +Prozedur @samp{Eqv?} und @samp{Member} die Prozedur @samp{Equal?} +benutzt. + + +@format +@t{(memq 'a '(a b c)) ==> (a b c) +(memq 'b '(a b c)) ==> (b c) +(memq 'a '(b c d)) ==> #f +(memq (list 'a) '(b (a) c)) ==> #f +(member (list 'a) + '(b (a) c)) ==> ((a) c) +(memq 101 '(100 101 102)) ==> @emph{unbestimmt} +(memv 101 '(100 101 102)) ==> (101 102) +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} assq obj aliste +@deffnx {Bibliotheksprozedur} assv obj aliste +@deffnx {Bibliotheksprozedur} assoc obj aliste + +@var{Aliste} (für „assoziative Liste``) muss eine Liste von Paaren +sein. Diese Prozeduren finden das erste Paar in @var{Aliste}, dessen +Car-Komponente @var{Obj} ist, und geben dieses Paar zurück. Wenn kein +Paar in @var{Aliste} das @var{Obj} als sein Car hat, dann wird @t{#f} +zurückgegeben (nicht die leere Liste). @samp{Assq} benutzt @samp{Eq?} +zum Vergleich von @var{Obj} mit den Car-Komponenten der Paare in der +@var{Aliste}, während @samp{Assv} die Prozedur @samp{Eqv?} und +@samp{Assoc} die Prozedur @samp{Equal?} benutzt. + + +@format +@t{(define e '((a 1) (b 2) (c 3))) +(assq 'a e) ==> (a 1) +(assq 'b e) ==> (b 2) +(assq 'd e) ==> #f +(assq (list 'a) '(((a)) ((b)) ((c)))) + ==> #f +(assoc (list 'a) '(((a)) ((b)) ((c)))) + ==> ((a)) +(assq 5 '((2 3) (5 7) (11 13))) + ==> @emph{unbestimmt} +(assv 5 '((2 3) (5 7) (11 13))) + ==> (5 7) +} +@end format + + + + +@quotation +@emph{Begründung:} +Obwohl sie normalerweise als Prädikate benutzt werden, haben +@samp{Memq}, @samp{Memv}, @samp{Member}, @samp{Assq}, @samp{Assv} und +@samp{Assoc} keine Fragezeichen in ihren Namen, weil sie nützliche Werte +statt bloß @t{#t} oder @t{#f} zurückgeben. +@end quotation + +@end deffn + + +@node Symbole, Zeichen, Paare und Listen, Andere Datentypen +@subsection Symbole + + + +Symbole sind Objekte, deren Nützlichkeit auf der Tatsache beruht, dass +zwei Symbole genau dann identisch sind (im Sinn von @samp{Eqv?}), wenn +ihre Namen auf gleiche Weise geschrieben werden. Dies ist genau die +Eigenschaft, die gebraucht wird, um Bezeichner in Programmen +darzustellen, daher benutzen die meisten +@cindex @w{Bezeichner} +Implementierungen von Scheme intern Symbole als Bezeichner. Symbole +sind nützlich für viele andere Anwendungen, zum Beispiel können sie so +wie Aufzählungswerte in Pascal benutzt werden. + +Die Regeln, wie ein Symbol geschrieben wird, sind genau die gleichen wie +die Regeln, wie ein Bezeichner geschrieben wird, siehe die Abschnitte +@ref{Bezeichner} und @ref{Lexikalische Struktur}. + +Es wird garantiert, dass jedes Symbol, was als Teil eines literalen +Ausdrucks zurückgegeben wurde oder was von der Prozedur @samp{Read} +gelesen und anschließend durch die Prozedur @samp{Write} geschrieben +wurde, wieder als dasselbe Symbol einlesbar ist (im Sinne von +@samp{Eqv?}). Die Prozedur @samp{String->symbol} kann jedoch Symbole +erstellen, für die diese Schreib-/Lese-Invarianz nicht gelten könnte, +weil ihre Namen Sonderzeichen oder Buchstaben in nicht standardmäßiger +Groß- und Kleinschreibung enthalten. + + +@quotation +@emph{Anmerkung:} +Manche Implementierungen von Scheme haben eine Funktionalität, die als +Slashifizierung („slashification``) bekannt ist, um +Schreib-/Lese-Invarianz für alle Symbole zu garantieren, aber historisch +war die wichtigste Anwendung dieser Funktionalität, das Fehlen eines +Datentyps für Zeichenketten auszugleichen. + +Manche Implementierungen haben auch „nicht internierte Symbole``, +welche Schreib-/Lese-Invarianz unmöglich machen, selbst in +Implementierungen mit Slashifizierung, und auch Ausnahmen zu der Regel +bilden, dass zwei Symbole genau dann dasselbe sind, wenn ihre Namen +gleich geschrieben werden. +@end quotation + + + + +@deffn {Prozedur} symbol? obj + +Gibt @t{#t} zurück, wenn @var{Obj} ein Symbol ist, und gibt sonst @t{#f} +zurück. + + +@format +@t{(symbol? 'foo) ==> #t +(symbol? (car '(a b))) ==> #t +(symbol? "bar") ==> #f +(symbol? 'nil) ==> #t +(symbol? '()) ==> #f +(symbol? #f) ==> #f +} +@end format + +@end deffn + + + +@deffn {Prozedur} symbol->string symbol + +Gibt den Namen des @var{Symbol}s als eine Zeichenkette zurück. Wenn das +Symbol ein Teil eines Objekts war, das als der Wert eines literalen +Ausdrucks zurückgegeben wurde (Abschnitt @pxref{Literale Ausdrücke}) +oder von einem Aufruf der Prozedur @samp{Read} zurückgegeben wurde, und +sein Name Buchstabenzeichen enthält, dann wird die zurückgegebene +Zeichenkette Zeichen in der von der Implementierung bevorzugten Groß- +und Kleinschreibung enthalten---manche Implementierungen werden +Großbuchstaben bevorzugen, andere Kleinschreibung. Wenn das Symbol von +@samp{String->symbol} zurückgegeben wurde, wird die Groß- und +Kleinschreibung der Zeichen der zurückgegebenen Zeichenkette dieselbe +sein wie die, die an @samp{String->symbol} übergeben wurde. Es ist ein +Fehler, Veränderungsprozeduren wie @code{String-set!} auf von +@vindex @w{String-set!} +dieser Prozedur zurückgegebene Zeichenketten anzuwenden. + +Die folgenden Beispiele nehmen an, dass die standardmäßige +Groß-und-Kleinschreibung der Implementierung Kleinschreibung ist: + + +@format +@t{(symbol->string 'fliegende-Fische) + ==> "fliegende-fische" +(symbol->string 'Martin) ==> "martin" +(symbol->string + (string->symbol "Malvina")) + ==> "Malvina" +} +@end format + +@end deffn + + + +@deffn {Prozedur} string->symbol string + +Gibt das Symbol zurück, dessen Name @var{String} ist. Diese Prozedur +kann Symbole erzeugen, deren Namen Sonderzeichen enthalten oder +Buchstaben in nicht standardmäßiger Groß- und Kleinschreibung enthalten, +aber es ist meistens eine schlechte Idee, solche Symbole zu erzeugen, +denn in manchen Implementierungen von Scheme können sie nicht als sie +selbst eingelesen werden. Siehe @samp{Symbol->string}. + +Die folgenden Beispiele nehmen an, dass die standardmäßige Groß- und +Kleinschreibung der Implementierung Kleinschreibung ist: + + +@format +@t{(eq? 'mISSISSIppi 'mississippi) + ==> #t +(string->symbol "mISSISSIppi") + ==> + @r{}das Symbol namens "mISSISSIppi" +(eq? 'bitBlt (string->symbol "bitBlt")) + ==> #f +(eq? 'JollyWog + (string->symbol + (symbol->string 'JollyWog))) + ==> #t +(string=? "K. Harper, M.D." + (symbol->string + (string->symbol "K. Harper, M.D."))) + ==> #t +} +@end format + + +@end deffn + + +@node Zeichen, Zeichenketten, Symbole, Andere Datentypen +@subsection Zeichen + + + +Zeichen sind Objekte, die gedruckte Zeichen wie Buchstaben und Ziffern +darstellen. +@c There is no requirement that the data type of +@c characters be disjoint from other data types; implementations are +@c encouraged to have a separate character data type, but may choose to +@c represent characters as integers, strings, or some other type. +Zeichen werden mit der Notation #\@r{<Zeichen>} oder #\@r{<Zeichenname>} +geschrieben. Zum Beispiel: + + + +@c @center @c begin-tabular +@quotation +@table @asis +@item @t{#\a} +; Kleinbuchstabe +@item @t{#\A} +; Großbuchstabe +@item @t{#\(} +; linke runde Klammer +@item @t{#\ } +; das Leerzeichen +@item @t{#\space} +; die bevorzugte Art, ein Leerzeichen zu schreiben +@item @t{#\newline} +; das Zeilenvorschubs-Zeichen („newline``) +@c @item +@end table +@end quotation + + + + +Groß- und Kleinschreibung hat Auswirkungen in #\@r{<Zeichen>}, aber +nicht in #\@r{<Zeichenname>}. +@c \hyper doesn't + +@c allow a linebreak +Wenn @r{<Zeichen>} in +#\@r{<Zeichen>} ein Buchstabe ist, dann muss das auf @r{<Zeichen>} +folgende Zeichen ein Trennzeichen wie ein Leerzeichen oder eine runde +Klammer sein. Diese Regel löst den mehrdeutigen Fall auf, dass zum +Beispiel die Folge von Zeichen „@t{#\space}`` als entweder eine +Darstellung des Leerzeichens oder als eine Darstellung des Zeichens +„@t{#\s}`` gefolgt von einer Darstellung des Symbols „@t{pace}`` +verstanden werden könnte. + +@ignore todo +Fix +@end ignore + +Zeichen, die in der Notation #\ geschrieben werden, sind +selbtauswertend. Das heißt, sie müssen in Programmen nicht maskiert +werden. +@c The \sharpsign\backwhack{} +@c notation is not an essential part of Scheme, however. Even implementations +@c that support the \sharpsign\backwhack{} notation for input do not have to +@c support it for output. + +Manche der Prozeduren, die auf Zeichen arbeiten, ignorieren den +Unterschied zwischen Groß- und Kleinschreibung. Die Prozeduren, die +Groß- und Kleinschreibung ignorieren, haben @w{``@t{-ci}''} (für „case +insensitive``) in ihre Namen eingebettet. + + + +@deffn {Prozedur} char? obj + +Gibt @t{#t} zurück, wenn @var{Obj} ein Zeichen ist, sonst gibt sie +@t{#f} zurück. + +@end deffn + + + +@deffn {Prozedur} char=? char1 char2 +@deffnx {Prozedur} char<? char1 char2 +@deffnx {Prozedur} char>? char1 char2 +@deffnx {Prozedur} char<=? char1 char2 +@deffnx {Prozedur} char>=? char1 char2 + + +@ignore nodomain +Both @var{char1} and @var{char2} must be characters. +@end ignore + +Durch diese Prozeduren wird der Menge der Zeichen eine totale Ordnung +auferlegt. Es wird garantiert, dass gemäß dieser Ordnung gilt: + + + +@itemize @bullet + +@item +Die Großbuchstaben sind in der richtigen Reihenfolge. Zum Beispiel gibt +@samp{(char<? #\A #\B)} den Wert @t{#t} zurück. +@item +Die Kleinbuchstaben sind in der richtigen Reihenfolge. Zum Beispiel +gibt @samp{(char<? #\a #\b)} den Wert @t{#t} zurück. +@item +Die Ziffern sind in der richtigen Reihenfolge. Zum Beispiel gibt +@samp{(char<? #\0 #\9)} den Wert @t{#t} zurück. +@item +Entweder kommen alle Ziffern vor allen Großbuchstaben, oder umgekehrt. +@item +Entweder kommen alle Ziffern nach allen Großbuchstaben, oder umgekehrt. + +@end itemize + + +Manche Implementierungen können diese Prozeduren so verallgemeinern, +dass sie mehr als zwei Argumente nehmen, genau wie bei den +entsprechenden numerischen Prädikaten. + +@end deffn + + + +@deffn {Bibliotheksprozedur} char-ci=? char1 char2 +@deffnx {Bibliotheksprozedur} char-ci<? char1 char2 +@deffnx {Bibliotheksprozedur} char-ci>? char1 char2 +@deffnx {Bibliotheksprozedur} char-ci<=? char1 char2 +@deffnx {Bibliotheksprozedur} char-ci>=? char1 char2 + +@ignore nodomain +Both @var{char1} and @var{char2} must be characters. +@end ignore + +Diese Prozeduren sind ähnlich wie @samp{Char=?} et cetera, aber sie +behandeln Groß- und Kleinbuchstaben, als wären sie dasselbe. Zum +Beispiel gibt @samp{(char-ci=? #\A #\a)} den Wert @t{#t} zurück. Manche +Implementierungen können diese Prozeduren so verallgemeinern, dass sie +mehr als zwei Argumente nehmen, genau wie bei den entsprechenden +numerischen Prädikaten. + +@end deffn + + + +@deffn {Bibliotheksprozedur} char-alphabetic? char +@deffnx {Bibliotheksprozedur} char-numeric? char +@deffnx {Bibliotheksprozedur} char-whitespace? char +@deffnx {Bibliotheksprozedur} char-upper-case? letter +@deffnx {Bibliotheksprozedur} char-lower-case? letter + +Diese Prozeduren geben @t{#t} zurück, wenn ihre Argumente jeweils +Buchstaben, Zahlen, Leerraum, Großbuchstaben oder Kleinbuchstaben sind, +sonst geben sie @t{#f} zurück. Die folgenden Anmerkungen, welche +speziell für den ASCII-Zeichensatz gelten, sind nur als Orientierung +gedacht: Die Buchstabenzeichen sind die 52 Groß- und Kleinbuchstaben. +Die Ziffernzeichen sind die zehn Dezimalziffern. Die Leerraumzeichen +sind das Leerzeichen, das Tabulatorzeichen, der Zeilenvorschub, der +Seitenvorschub und der Wagenrücklauf. +@end deffn + + +@c %R4%%\begin{entry}{% +@c \proto{char-upper-case?}{ letter}{Prozedur} +@c \proto{char-lower-case?}{ letter}{Prozedur}} + +@c \domain{\var{Letter} must be an alphabetic character.} +@c These procedures return \schtrue{} if their arguments are upper case or +@c lower case characters, respectively, otherwise they return \schfalse. +@c \end{entry} + + + +@deffn {Prozedur} char->integer char +@deffnx {Prozedur} integer->char @var{n} + +Gegeben ein Zeichen gibt @samp{Char->integer} eine exakte ganzzahlige +Darstellung des Zeichens zurück. Gegeben eine exakte ganze Zahl, die +das Bild eines Zeichens unter @samp{Char->integer} ist, gibt +@samp{Integer->char} dieses Zeichen zurück. Diese Prozeduren +implementieren ordnungserhaltende Isomorphismen zwischen der Menge an +Zeichen unter der Ordnung von @code{Char<=?} und einer der +@vindex @w{Char<=?} +Teilmengen der ganzen Zahlen unter der Ordnung von @samp{<=}. Das +heißt, wenn + + +@format +@t{(char<=? @var{a} @var{b}) @result{} #t @r{}und (<= @var{x} @var{y}) @result{} #t +} +@end format + + + +@noindent + und @var{x} und @var{y} in der Definitionsmenge von +@samp{Integer->char} sind, dann + + +@format +@t{(<= (char->integer @var{a}) + (char->integer @var{b})) ==> #t + +(char<=? (integer->char @var{x}) + (integer->char @var{y})) ==> #t +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} char-upcase char +@deffnx {Bibliotheksprozedur} char-downcase char + +@ignore nodomain +@var{Char} must be a character. +@end ignore + +Diese Prozeduren geben ein Zeichen @var{Char2} zurück, für das +@samp{(char-ci=? @var{char} @var{char2})} gilt. Zudem ist, wenn +@var{Char} ein Buchstabe ist, das Ergebnis von @samp{Char-upcase} ein +Großbuchstabe und das Ergebnis von @samp{Char-downcase} ein +Kleinbuchstabe. + +@end deffn + + +@node Zeichenketten, Vektoren, Zeichen, Andere Datentypen +@subsection Zeichenketten + + + +Zeichenketten sind Folgen von Zeichen. +@c In some implementations of Scheme +@c they are immutable; other implementations provide destructive procedures +@c such as {\cf string-set!}\ that alter string objects. +Zeichenketten werden als Folge von Zeichen geschrieben, die in doppelte +Anführungszeichen eingeschlossen sind (@samp{"}). Doppelte +Anführungszeichen können nur in eine Zeichenkette geschrieben werden, +indem man sie mit einem Backslash (\) maskiert, wie hier: + + +@example + +"Das Wort \"Rekursion\" hat viele Bedeutungen." + +@end example + + +Ein Backslash kann nur in einer Zeichenkette geschrieben werden, indem +man ihn mit einem anderen Backslash maskiert. Scheme legt die Wirkung +eines Backslashs innerhalb eines Strings, auf den keine doppelten +Anführungszeichen oder ein Backslash folgt, nicht fest. + +Eine konstante Zeichenkette darf sich von einer Zeile bis auf die +nächste erstrecken, aber der genaue Inhalt einer solchen Zeichenkette +ist unbestimmt. +@c this is +@c usually a bad idea because +@c the exact effect may vary from one computer +@c system to another. + +Die @emph{Länge} einer Zeichenkette ist die Anzahl der Zeichen, die sie +enthält. Diese Anzahl ist eine exakte, nicht negative ganze Zahl, die +von der Erstellung einer Zeichenkette an fest ist. Die @dfn{gültigen +Indizes} einer Zeichenkette sind die +@cindex @w{gültige Indizes} +exakten, nicht negativen ganzen Zahlen, die kleiner als die Länge der +Zeichenkette ist. Das erste Zeichen einer Zeichenkette hat den Index 0, +das zweite hat den Index 1, und so weiter. + +In Formulierungen wie „die Zeichen von @var{String} vom Index +@var{Anfang} bis zum Index @var{Ende}`` ist damit gemeint, dass der +Index @var{Anfang} dazugehört und der Index @var{Ende} nicht mehr +dazugehört. Wenn also @var{Anfang} und @var{Ende} derselbe Index sind, +wird auf eine leere Teilzeichenkette Bezug genommen, und wenn +@var{Anfang} null und @var{Ende} die Länge von @var{String} ist, dann +wird auf die gesamte Zeichenkette Bezug genommen. + +Manche der Prozeduren, die auf Zeichenketten arbeiten, ignorieren den +Unterschied zwischen Groß- und Kleinschreibung. Die Prozeduren, die +Groß- und Kleinschreibung ignorieren, haben @w{„@samp{-ci}``} (für +``case insensitive'') in ihre Namen eingebettet. + + + +@deffn {Prozedur} string? obj + +Gibt @t{#t} zurück, wenn @var{Obj} eine Zeichenkette ist, und +andernfalls @t{#f}. +@end deffn + + + +@deffn {Prozedur} make-string @var{k} +@deffnx {Prozedur} make-string @var{k} char + +@c \domain{\vr{k} must be a non-negative integer, and \var{char} must be +@c a character.} +@samp{Make-string} gibt eine neu zugeteilte Zeichenkette der Länge +@var{k} zurück. Wenn @var{Char} angegeben wurde, dann werden alle +Elemente der Zeichenkette auf @var{Char} initialisiert, andernfalls ist +der Inhalt der zurückgegebenen Zeichenkette unbestimmt. + +@end deffn + + +@deffn {Bibliotheksprozedur} string char @dots{}, + +Gibt eine neu zugeteilte Zeichenkette zurück, die sich aus den +Argumenten zusammensetzt. + +@end deffn + + +@deffn {Prozedur} string-length string + +Gibt die Anzahl der Zeichen in der gegebenen Zeichenkette @var{String} +zurück. +@end deffn + + + +@deffn {Prozedur} string-ref string @var{k} + +@var{k} muss ein gültiger Index der Zeichenkette @var{String} sein. +@samp{String-ref} gibt das Zeichen @var{k} von @var{String} zurück, +wobei Indizes von null an gezählt werden. +@end deffn + + + +@deffn {Prozedur} string-set! string k char + + +@c \var{String} must be a string, +@var{k} muss ein gültiger Index der Zeichenkette @var{String} sein +@c , and \var{char} must be a character +. +@samp{String-set!} speichert @var{Char} in das Element @var{k} von +@var{String} und gibt einen unbestimmten Wert zurück. +@c <!> + + +@format +@t{(define (f) (make-string 3 #\*)) +(define (g) "***") +(string-set! (f) 0 #\?) ==> @emph{unbestimmt} +(string-set! (g) 0 #\?) ==> @emph{Fehler} +(string-set! (symbol->string 'unveränderlich) + 0 + #\?) ==> @emph{Fehler} +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} string=? string1 string2 +@deffnx {Bibliotheksprozedur} string-ci=? string1 string2 + +Gibt @t{#t} zurück, wenn die beiden Zeichenketten dieselbe Länge haben +und dieselben Zeichen an den selben Stellen haben, sonst gibt sie @t{#f} +zurück. +@samp{String-ci=?} behandelt +Groß- und Kleinbuchstaben als wären sie dasselbe Zeichen, aber +@samp{String=?} behandelt Groß- und Kleinbuchstaben als verschiedene +Zeichen. + +@end deffn + + + +@deffn {Bibliotheksprozedur} string<? string1 string2 +@deffnx {Bibliotheksprozedur} string>? string1 string2 +@deffnx {Bibliotheksprozedur} string<=? string1 string2 +@deffnx {Bibliotheksprozedur} string>=? string1 string2 +@deffnx {Bibliotheksprozedur} string-ci<? string1 string2 +@deffnx {Bibliotheksprozedur} string-ci>? string1 string2 +@deffnx {Bibliotheksprozedur} string-ci<=? string1 string2 +@deffnx {Bibliotheksprozedur} string-ci>=? string1 string2 + +Diese Prozeduren sind die alphabetisch geordnete Erweiterung auf +Zeichenketten von der entsprechenden Ordnung auf Zeichen. Zum Beispiel +ist @samp{String<?} die alphabetische Ordnung auf Zeichenketten, die von +der Ordnung @samp{Char<?} auf Zeichen induziert wird. Wenn zwei +Zeichenketten verschiedene Längen haben, aber bis zur Länge der kürzeren +Zeichenkette identisch sind, wird die kürzere Zeichenkette als +alphabetisch kleiner angesehen als die längere Zeichenkette. + +Implementierungen dürfen diese Prozeduren ebenso wie die Prozeduren +@samp{String=?} und @samp{String-ci=?} verallgemeinern, so dass sie mehr +als zwei Argumente annehmen, wie bei den entsprechenden Prädikaten auf +Zahlen. + +@end deffn + + + +@deffn {Bibliotheksprozedur} substring string anfang ende + +@var{String} muss eine Zeichenkette und @var{Anfang} und @var{Ende} +müssen exakte ganze Zahlen sein, so dass gilt + + +@center 0 <= @var{anfang} <= @var{ende} <= @w{@t{(string-length @var{string})@r{.}}} + +@samp{Substring} gibt eine neu zugeteilte Zeichenkette zurück, die aus +den Zeichen von String zusammengesetzt wird, angefangen mit dem Index +@var{Anfang} (einschließlich) und bis zum Index @var{Ende} (nicht +einschließlich). +@end deffn + + + +@deffn {Bibliotheksprozedur} string-append @var{string} @dots{}, + +Gibt eine neu zugeteilte Zeichenkette zurück, deren Zeichen die +Verkettung der übergebenen Zeichenketten darstellt. + +@end deffn + + + +@deffn {Bibliotheksprozedur} string->list string +@deffnx {Bibliotheksprozedur} list->string list + +@samp{String->list} gibt eine neu zugeteilte Liste der Zeichen zurück, +die die übergebene Zeichenkette bilden. @samp{List->string} gibt eine +neu zugeteilte Zeichenkette zurück, die aus den Zeichen in der Liste +@var{List} gebildet wird, welche eine Liste von Zeichen sein muss. +@samp{String->list} und @samp{List->string} sind jeweils +Umkehrfunktionen voneinander bezüglich @samp{Equal?}. +@c Implementations that provide +@c destructive operations on strings should ensure that the result of +@c {\cf list\coerce{}string} is newly allocated. + +@end deffn + + + +@deffn {Bibliotheksprozedur} string-copy string + +Gibt eine neu zugeteilte Kopie der übergebenen Zeichenkette @var{String} +zurück. + +@end deffn + + + +@deffn {Bibliotheksprozedur} string-fill! string char + +Speichert @var{Char} in jedem Element der übergebener Zeichenkette +@var{String} und gibt einen unbestimmten Wert zurück. +@c <!> + +@end deffn + + +@node Vektoren, , Zeichenketten, Andere Datentypen +@subsection Vektoren + + + +Vektoren sind heterogene Strukturen, deren Elements durch ganze Zahlen +indiziert werden. Ein Vektor belegt typischerweise weniger +Speicherplatz als eine Liste derselben Länge und die durchschnittliche +Zeit, die nötig ist, um auf ein zufällig gewähltes Element zuzugreifen, +ist typischerweise weniger für den Vektor als für die Liste. + +Die @emph{Länge} eines Vektors ist die Anzahl der Elemente, die er +enthält. Diese Zahl ist eine nicht negative ganze Zahl, die von der +Erstellung eines Vektors an fest ist. Die @emph{gültigen Indizes} eines +@cindex @w{gültige Indizes} +Vektors sind die exakt nicht-negativen ganzen Zahlen, die kleiner als +die Länge des Vektors sind. Das erste Element eines Vektors hat den +Index null und das letzte Element hat als Index eins weniger als die +Länge des Vektors. + +Vektoren werden mit der Notation @t{#(@var{obj} @dots{},)} geschrieben. +Zum Beispiel kann ein Vektor der Länge 3, der die Zahl null in Element +0, die Liste @samp{(2 2 2 2)} in Element 1 und die Zeichenkette +@samp{"Anna"} in Element 2 hat, wie folgt geschrieben werden: + + +@example + +#(0 (2 2 2 2) "Anna") + +@end example + + +Beachten Sie, dass dies die externe Darstellung eines Vektors ist, kein +Ausdruck, der zu einem Vektor ausgewertet wird. Wie bei konstanten +Listen müssen auch konstante Vektoren maskiert werden: + + +@example + +'#(0 (2 2 2 2) "Anna") + ==> #(0 (2 2 2 2) "Anna") + +@end example + + +@ignore todo +Pitman sez: The visual similarity to lists is bound to be confusing +to some. Elaborate on the distinction. +@end ignore + + + + +@deffn {Prozedur} vector? obj + +Gibt @t{#t} zurück, wenn @var{Obj} ein Vektor ist, und gibt sonst @t{#f} +zurück. +@end deffn + + + +@deffn {Prozedur} make-vector k +@deffnx {Prozedur} make-vector k fill + +Gibt einen neu zugeteilten Vektor mit @var{k} Elementen zurück. Wenn +ein zweites Argument übergeben wurde, dann wird jedes Element auf +@var{Fill} initialisiert. Sonst ist der anfängliche Inhalt jedes +Elements unbestimmt. + +@end deffn + + + +@deffn {Bibliotheksprozedur} vector obj @dots{}, + +Gibt einen neu zugeteilten Vektor zurück, dessen Elemente die +übergebenen Argumente enthalten. Analog zu @samp{List}. + + +@format +@t{(vector 'a 'b 'c) ==> #(a b c) +} +@end format + +@end deffn + + + +@deffn {Prozedur} vector-length vector + +Gibt die Anzahl der Elemente im Vektor @var{Vector} als eine exakte +ganze Zahl zurück. +@end deffn + + + +@deffn {Prozedur} vector-ref vector k + +@var{k} muss ein gültiger Index des Vektors @var{Vector} sein. +@samp{Vector-ref} gibt den Inhalt des Elements @var{k} des Vektors +@var{Vector} zurück. + + +@format +@t{(vector-ref '#(1 1 2 3 5 8 13 21) + 5) + ==> 8 +(vector-ref '#(1 1 2 3 5 8 13 21) + (let ((i (round (* 2 (acos -1))))) + (if (inexact? i) + (inexact->exact i) + i))) + ==> 13 +} +@end format + +@end deffn + + + +@deffn {Prozedur} vector-set! vector k obj + +@var{k} muss ein gültiger Index des Vektors @var{Vector} sein. +@samp{Vector-set!} speichert @var{Obj} im Element @var{k} des Vektors +@var{Vector}. Der von @samp{Vector-set!} zurückgegebene Wert ist +unbestimmt. +@c <!> + + +@format +@t{(let ((vec (vector 0 '(2 2 2 2) "Anna"))) + (vector-set! vec 1 '("Sue" "Sue")) + vec) + ==> #(0 ("Sue" "Sue") "Anna") + +(vector-set! '#(0 1 2) 1 "doe") + ==> @emph{Fehler} ; konstanter Vektor +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} vector->list vector +@deffnx {Bibliotheksprozedur} list->vector list + +@samp{Vector->list} gibt eine neu zugeteilte Liste der Objekte, die in +den Elementen des Vektors @var{Vector} enthalten sind, zurück. +@samp{List->vector} gibt einen neu erstellten Vektor zurück, der auf die +Elemente der Liste @var{List} initialisiert ist. + + +@format +@t{(vector->list '#(dah dah didah)) + ==> (dah dah didah) +(list->vector '(dididit dah)) + ==> #(dididit dah) +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} vector-fill! vector fill + +Speichert @var{Fill} in jedem Element des Vektors @var{Vector}. Der von +@samp{Vector-fill!} zurückgegebene Wert ist unbestimmt. +@c <!> + +@end deffn + + +@node Programmflussfunktionalitäten, Eval, Andere Datentypen, Standardprozeduren +@section Programmflussfunktionalitäten + + + +@c Intro flushed; not very a propos any more. +@c Procedures should be discussed somewhere, however. + +Dieses Kapitel beschreibt verschiedene grundlegende Prozeduren, die den +Fluss der Programmausführung auf besondere Arten steuern. +Das Prädikat @samp{Procedure?} wird hier auch beschrieben. + +@ignore todo +@t{Procedure?} doesn't belong in a section with the name +``control features.'' What to do? +@end ignore + + + +@deffn {Prozedur} procedure? obj + +Gibt @t{#t} zurück, wenn @var{Obj} eine Prozedur ist, und sonst @t{#f}. + + +@format +@t{(procedure? car) ==> #t +(procedure? 'car) ==> #f +(procedure? (lambda (x) (* x x))) + ==> #t +(procedure? '(lambda (x) (* x x))) + ==> #f +(call-with-current-continuation procedure?) + ==> #t +} +@end format + + +@end deffn + + + +@deffn {Prozedur} apply proc arg1 @dots{} args + +@var{Proc} muss eine Prozedur und @var{Args} eine Liste sein. +@samp{Apply} (deutsch „anwenden``) ruft @var{Proc} mit den Elementen der +Liste @samp{(append (list @var{arg1} @dots{},) @var{args})} als die +tatsächlichen Argumente auf. + + +@format +@t{(apply + (list 3 4)) ==> 7 + +(define compose + (lambda (f g) + (lambda args + (f (apply g args))))) + +((compose sqrt *) 12 75) ==> 30 +} +@end format + +@end deffn + + + +@deffn {Bibliotheksprozedur} map proc list1 list2 @dots{}, + +Die @var{List}en müssen Listen sein und @var{Proc} muss eine Prozedur +sein, die ebensoviele Argumente nimmt, wie es Listenargumente @i{List} +gibt, und einen einzelnen Wert zurückgibt. Wenn mehr als eine Liste +@var{List} übergeben wird, dann müssen sie alle dieselbe Länge haben. +@samp{Map} (deutsch „abbilden``) wendet @var{Proc} elementweise auf die +Elemente der @var{List}en an und gibt eine Liste der Ergebnisse in +derselben Reihenfolge zurück. Die Reihenfolge, mit der @var{Proc} auf +die Elemente der @var{List}en zur Laufzeit angewandt wird, ist +unbestimmt. + + +@format +@t{(map cadr '((a b) (d e) (g h))) + ==> (b e h) + +(map (lambda (n) (expt n n)) + '(1 2 3 4 5)) + ==> (1 4 27 256 3125) + +(map + '(1 2 3) '(4 5 6)) ==> (5 7 9) + +(let ((count 0)) + (map (lambda (ignoriert) + (set! count (+ count 1)) + count) + '(a b))) ==> (1 2) @var{oder} (2 1) +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} for-each proc list1 list2 @dots{}, + +Die Argumente von @samp{For-each} sind wie die Argumente von @samp{Map}, +aber @samp{For-each} ruft @var{Proc} für ihre Wirkungen statt für ihre +Werte auf. Anders als @samp{Map} ruft @samp{For-each} die Prozedur +@var{Proc} garantiert der Reihe nach auf die Elemente der @var{List}en +auf, vom ersten Element @abbr{bzw.} den ersten Elementen bis zu dem +@abbr{bzw.} den letzten, und der von @samp{For-each} zurückgegebene Wert +ist unbestimmt. + + +@format +@t{(let ((v (make-vector 5))) + (for-each (lambda (i) + (vector-set! v i (* i i))) + '(0 1 2 3 4)) + v) ==> #(0 1 4 9 16) +} +@end format + + +@end deffn + + + +@deffn {Bibliotheksprozedur} force promise + +Erzwingt („force``) den Wert vom Versprechen @var{Promise} (siehe @code{Delay}, +@vindex @w{Delay} +Abschnitt @pxref{Verzögerte Auswertung}). Wenn noch kein Wert für +@cindex @w{Versprechen} +@cindex @w{Promise} +das Versprechen berechnet wurde, dann wird ein Wert berechnet und +zurückgegeben. Der Wert des Versprechens wird zwischengespeichert +(gecachet @abbr{bzw.} „memoisiert``), so dass, wenn es ein weiteres Mal +erzwungen wird, der vormals berechnete Wert zurückgegeben wird. +@c without any recomputation. +@c [As pointed out by Marc Feeley, the "without any recomputation" +@c isn't necessarily true. --Will] + + +@format +@t{(force (delay (+ 1 2))) ==> 3 +(let ((p (delay (+ 1 2)))) + (list (force p) (force p))) + ==> (3 3) + +(define ein-Strom ; Strom = englisch Stream + (letrec ((next + (lambda (n) + (cons n (delay (next (+ n 1))))))) + (next 0))) +(define head car) +(define tail + (lambda (stream) (force (cdr stream)))) + +(head (tail (tail ein-Strom))) + ==> 2 +} +@end format + + +@samp{Force} und @samp{Delay} sind hauptsächlich für im funktionalen +Stil geschriebene Programme gedacht. Die folgenden Beispiele sollten +nicht als Vorzeigebeispiele guten Programmierstils angesehen werden, +sondern lediglich die Eigenschaft aufzeigen, dass für ein Versprechen +nur ein Wert berechnet wird, egal wie oft es erzwungen wird. +@c the value of a promise is computed at most once. +@c [As pointed out by Marc Feeley, it may be computed more than once, +@c but as I observed we can at least insist that only one value be +@c used! -- Will] + + +@format +@t{(define count 0) +(define p + (delay (begin (set! count (+ count 1)) + (if (> count x) + count + (force p))))) +(define x 5) +p ==> @i{}ein Versprechen +(force p) ==> 6 +p ==> @i{}ein Versprechen, immer noch +(begin (set! x 10) + (force p)) ==> 6 +} +@end format + + +Hier ist eine mögliche Implementierung von @samp{Delay} und +@samp{Force}. Versprechen werden hier als Prozeduren ohne Argumente +implementiert und @samp{Force} ruft einfach sein Argument auf: + + +@format +@t{(define force + (lambda (object) + (object))) +} +@end format + + +Wir definieren dazu den Ausdruck + + +@format +@t{(delay @r{<Ausdruck>}) +} +@end format + + +als gleichbedeutend mit dem Prozeduraufruf + + +@format +@t{(make-promise (lambda () @r{<Ausdruck>}))@r{} +} +@end format + + +wie folgt + + +@format +@t{(define-syntax delay + (syntax-rules () + ((delay expression) + (make-promise (lambda () expression))))), +} +@end format + + +wobei @samp{Make-promise} wie folgt definiert ist: + +@c \begin{scheme} +@c (define make-promise +@c (lambda (proc) +@c (let ((already-run? \schfalse) (result \schfalse)) +@c (lambda () +@c (cond ((not already-run?) +@c (set! result (proc)) +@c (set! already-run? \schtrue))) +@c result))))% +@c \end{scheme} + + +@format +@t{(define make-promise + (lambda (proc) + (let ((Ergebnis-bereit? #f) + (Ergebnis #f)) + (lambda () + (if Ergebnis-bereit? + Ergebnis + (let ((x (proc))) + (if Ergebnis-bereit? + Ergebnis + (begin (set! Ergebnis-bereit? #t) + (set! Ergebnis x) + Ergebnis)))))))) +} +@end format + + + +@quotation +@emph{Begründung:} +Ein Versprechen darf seinen eigenen Wert referenzieren, wie das letzte +Beispiel oben zeigt. Das Erzwingen eines solchen Versprechens kann dazu +führen, dass das Versprechehen ein weiteres Mal erzwungen wird, bevor +der Wert des ersten Erzwingens berechnet wurde. Dies verkompliziert die +Definition von @samp{Make-promise}. +@end quotation + + +Manche Implementierungen unterstützen eine Vielzahl von Erweiterungen +dieser Semantik von @samp{Delay} und @samp{Force}: + + + +@itemize @bullet + +@item +@samp{Force} auf ein Objekt aufzurufen, das kein Versprechen ist, könnte +einfach dieses Objekt zurückgeben. + +@item +Es kann der Fall sein, dass es unmöglich ist, ein Versprechen von seinem +erzwungenen Wert operativ zu unterscheiden. Das heißt, Ausdrücke wie +die folgenden dürfen entweder zu @t{#t} oder zu @t{#f} ausgewertet +werden, abhängig von der Implementierung: + + +@format +@t{(eqv? (delay 1) 1) ==> @emph{unbestimmt} +(pair? (delay (cons 1 2))) ==> @emph{unbestimmt} +} +@end format + + +@item +Manche Implementierungen könnten „implizites Erzwingen`` +implementieren, wobei der Wert eines Versprechens durch grundlegende +Prozeduren wie @samp{Cdr} und @samp{+} erzwungen wird: + + +@format +@t{(+ (delay (* 3 7)) 13) ==> 34 +} +@end format + + +@end itemize + +@end deffn + + +@deffn {Prozedur} call-with-current-continuation proc + + @var{Proc} muss eine Prozedur mit einem Argument sein. Die Prozedur +@samp{Call-with-current-continuation} verpackt die aktuelle Fortsetzung +(siehe die Begründung unten) als eine „Ausstiegsprozedur`` („escape +procedure``) und übergibt sie als Argument +@cindex @w{Ausstiegsprozedur} +@cindex @w{Escape procedure} +an @var{Proc}. Die Ausstiegsprozedur ist eine Scheme-Prozedur, die, +wenn sie später aufgerufen wird, egal welche Fortsetzung zu diesem +späteren Zeitpunkt aktiv ist, mit dieser Fortsetzung aufhört und +stattdessen mit der Fortsetzung fortfährt, die aktiv war, als die +Ausstiegsprozedur erzeugt wurde. Ein Aufruf der Ausstiegsprozedur kann +einen Aufruf von mit @code{Dynamic-wind} +@vindex @w{dynamic-wind} +installierten @var{Before}- und @var{After}-Thunks verursachen. + +Die Ausstiegsprozedur nimmt dieselbe Anzahl an Argumenten an, wie die +Fortsetzung bis zum ursprünglichen Aufruf von +@t{Call-with-current-continuation}. Abgesehen von Fortsetzungen, die +durch die Prozedur @samp{Call-with-values} erzeugt wurden, nehmen alle +Fortsetzungen genau einen Wert an. Wie es sich auswirkt, wenn kein oder +mehr als ein Wert an nicht durch @t{Call-with-values} erzeugte +Fortsetzungen übergeben wird, ist unbestimmt. + +Die Ausstiegsprozedur, die an @var{Proc} übergeben wird, hat einen +unbeschränkten Gültigkeitsbereich, genau wie jede andere Prozedur in +Scheme. Sie darf in Variablen oder Datenstrukturen gespeichert werden +und so oft aufgerufen werden, wie es gewünscht ist. + +Die folgenden Beispiele zeigen nur die häufigsten Arten, auf die +@samp{Call-with-current-continuation} benutzt wird. Wenn alle +wirklichen Anwendungen so einfach wären wie diese Beispiele, bräuchte +man keine Prozedur, die so mächtig ist wie +@samp{Call-with-current-continuation}. + + +@format +@t{(call-with-current-continuation + (lambda (exit) + (for-each (lambda (x) + (if (negative? x) + (exit x))) + '(54 0 37 -3 245 19)) + #t)) ==> -3 + +(define list-length + (lambda (obj) + (call-with-current-continuation + (lambda (return) + (letrec ((r + (lambda (obj) + (cond ((null? obj) 0) + ((pair? obj) + (+ (r (cdr obj)) 1)) + (else (return #f)))))) + (r obj)))))) + +(list-length '(1 2 3 4)) ==> 4 + +(list-length '(a b . c)) ==> #f +} +@end format + + + +@quotation +@emph{Begründung:} + +Eine übliche Nutzung von @samp{Call-with-current-continuation} sind +strukturierte, nicht-lokale Sprünge aus Schleifen oder Prozedurrümpfen +heraus, aber tatsächlich ist @samp{Call-with-current-continuation} für +die Implementierung einer große Vielfalt fortgeschrittener +Programmflussstrukturen von extremem Nutzen. + +Wann immer ein Scheme-Ausdruck ausgewertet wird, gibt es eine +@dfn{Fortsetzung} („continuation``), die das Ergebnis des Ausdrucks +haben will. Die Fortsetzung +@cindex @w{Fortsetzung} +@cindex @w{Continuation} +stellt die gesamte (standardmäßige) Zukunft der Berechnung dar. Wenn +der Ausdruck zum Beispiel auf oberster Ebene ausgewertet wird, dann kann +die Fortsetzung das Ergebnis entgegennehmen, auf dem Bildschirm +ausgeben, nach der nächsten Eingabe fragen, und ewig so weiter. Die +meiste Zeit schließt die Fortsetzung vom Nutzer-Code festgelegte +Aktionen mit ein, wie zum Beispiel eine Fortsetzung, die das Ergebnis +nimmt, mit dem in einer lokalen Variablen gespeicherten Wert +multipliziert, sieben addiert und die Antwort an die Fortsetzung auf +oberster Ebene zum Ausgeben weitergibt. Normalerweise sind diese +allgegenwärtigen Fortsetzungen im Hintergrund verborgen und +Programmierer denken nicht viel über sie nach. In seltenen Fällen +könnte ein Programmierer jedoch mit Fortsetzungen ausdrücklich umgehen +müssen. +@samp{Call-with-current-continuation} erlaubt es Scheme-Programmierern, +dazu eine Prozedur zu erstellen, die sich genau wie die momentane +Fortsetzung verhält. + +Die meisten Programmiersprachen enthalten eines oder mehr +Ausstiegskonstrukte für ganz bestimmte Zwecke mit Namen wie @t{Exit}, +@w{@samp{Return}} oder sogar @t{Goto}. 1965 hat Peter Landin [Landin65] +jedoch einen für allgemeine Zwecke bestimmten Ausstiegsoperator namens +J-Operator erfunden. John Reynolds [Reynolds72] hat 1972 ein +einfacheres, aber ebenso mächtiges Konstrukt beschrieben. Die +Sonderform @samp{Catch}, die Sussman und Steele im Scheme-Bericht von +1975 beschrieben haben, ist genau dasselbe wie Reynolds' Konstrukt, doch +sein Name kommt von einem weniger allgemeinen Konstrukt in MacLisp. +Mehrere Scheme-Implementierer bemerkten, dass die ganze Macht des +@code{Catch}-Konstrukts durch eine Prozedur statt eines +@vindex @w{Catch} +besonderen syntaktischen Konstrukts bereitgestellt werden könnte, und +der Name @samp{Call-with-current-continuation} wurde 1982 geprägt. +Dieser Name ist beschreibend, aber die Meinungen gehen über die Vorzüge +eines derart langen Namens auseinander und manche Leute benutzen +stattdessen den Namen @code{Call/cc}. +@vindex @w{Call/cc} +@end quotation + + +@end deffn + + +@deffn {Prozedur} values obj @dots{} + +Liefert all ihre Argumente an ihre Fortsetzung. Abgesehen von mit der +Prozedur @code{Call-with-values} +@vindex @w{Call-with-values} +erstellten Fortsetzungen nehmen alle Fortsetzungen genau einen Wert +entgegen. @t{Values} kann wie folgt definiert werden: + +@format +@t{(define (values . things) + (call-with-current-continuation + (lambda (cont) (apply cont things)))) +} +@end format + + +@end deffn + + +@deffn {Prozedur} call-with-values produzent konsument + +Ruft ihr @var{Produzent}en-Argument mit keinen Werten und einer +Fortsetzung auf, die, wenn ihr Werte übergeben werden, die +@var{Konsument}en-Prozedur mit diesen Werten als Argumente aufruft. Die +Fortsetzung des @var{Konsument}enaufrufs ist die Fortsetzung des Aufrufs +von @t{Call-with-values}. + + +@format +@t{(call-with-values (lambda () (values 4 5)) + (lambda (a b) b)) + ==> 5 + +(call-with-values * -) ==> -1 +} +@end format + + +@end deffn + + +@deffn {Prozedur} dynamic-wind before thunk after + +Ruft @var{Thunk} ohne Argumente auf und gibt das Ergebnis oder die +Ergebnisse dieses Aufrufs zurück. @var{Before} und @var{After} werden, +ebenso ohne Argumente, wie von den folgenden Regeln vorausgesetzt +aufgerufen (beachten Sie, dass ohne Aufrufe von mit +@code{Call-with-current-continuation} gefangenen Fortsetzungen die drei +Argumente +@vindex @w{Call-with-current-continuation} +jeweils einmal der Reihe nach aufgerufen werden). @var{Before} wird +immer dann aufgerufen, wenn die Ausführung den dynamischen Bereich des +Aufrufs von @var{Thunk} betritt, und @var{After} wird immer dann +aufgerufen, wenn sie diesen dynamischen Bereich verlässt. Der +dynamische Bereich eines Prozeduraufrufs ist die Zeit zwischen dem +Verursachen des Aufrufs und seiner Rückgabe. In Scheme kann, wegen +@samp{Call-with-current-continuation}, der dynamische Bereich etwas +anderes als eine einzelne, zusammenhängende Zeitspanne sein. Er ist wie +folgt definiert: + + +@itemize @bullet + +@item +Der dynamische Bereich wird betreten, wenn die Ausführung des Rumpfs der +aufgerufenen Prozedur beginnt. + +@item +Der dynamische Bereich wird auch betreten, wenn die Ausführung sich +nicht im dynamischen Bereich befindet und eine Fortsetzung aufgerufen +wird, die (mit @samp{Call-with-current-continuation}) innerhalb des +dynamischen Bereichs eingefangen wurde. + +@item +Er wird verlassen, wenn die aufgerufene Prozedur ihr Ergebnis oder ihre +Ergebnisse zurückgibt. + +@item +Er wird auch verlassen, wenn sich die Ausführung innerhalb des +dynamischen Bereichs befindet und eine Fortsetzung, die außerhalb des +dynamischen Bereichs gefangen wurde, aufgerufen wird. + +@end itemize + + +Wenn ein zweiter Aufruf von @samp{Dynamic-wind} innerhalb des +dynamischen Bereichs des Aufrufs von @var{Thunk} stattfindet und eine +Fortsetzung auf eine Art aufgerufen wird, dass die @var{After}s dieser +beiden Aufrufe von @samp{Dynamic-wind} beide aufzurufen sind, dann wird +die @var{After}, die mit dem zweiten (inneren) Aufruf von +@samp{Dynamic-wind} assoziiert ist, zuerst aufgerufen. + +Wenn der zweite Aufruf von @samp{Dynamic-wind} innerhalb des dynamischen +Bereichs des Aufrufs von @var{Thunk} stattfindet und dann eine +Fortsetzung auf eine Art aufgerufen wird, dass die @var{Before}s dieser +beiden Aufrufe von @samp{Dynamic-wind} beide auszuführen sind, dann wird +@var{Before}, die mit dem ersten (äußeren) Aufruf von +@samp{Dynamic-wind} assoziiert ist, zuerst aufgerufen. + +Wenn das Aufrufen einer Fortsetzung das Aufrufen der @var{Before} des +einen Aufrufs von @samp{Dynamic-wind} und der @var{After} eines anderen +Aufrufs erfordert, dann wird die @var{After} zuerst aufgerufen. + +Die Auswirkung, eine eingefangene Fortsetzung zu benutzen, um aus dem +dynamischen Bereich eines Aufrufs von @var{Before} oder @var{After} +auszusteigen, ist undefiniert. + + +@format +@t{(let ((path '()) + (c #f)) + (let ((add (lambda (s) + (set! path (cons s path))))) + (dynamic-wind + (lambda () (add 'connect)) + (lambda () + (add (call-with-current-continuation + (lambda (c0) + (set! c c0) + 'talk1)))) + (lambda () (add 'disconnect))) + (if (< (length path) 4) + (c 'talk2) + (reverse path)))) + + ==> (connect talk1 disconnect + connect talk2 disconnect) +} +@end format + +@end deffn + +@node Eval, Ein- und Ausgabe, Programmflussfunktionalitäten, Standardprozeduren +@section Eval + + + +@deffn {Prozedur} eval ausdruck umgebungsangabe + +Wertet @var{Ausdruck} in der angegebenen Umgebung aus und gibt seinen +Wert zurück. @var{Ausdruck} muss ein gültiger Scheme-Ausdruck sein, der +als Daten dargestellt ist, und @var{Umgebungsangabe} muss ein von einer +der drei unten beschriebenen Prozeduren zurückgegebener Wert sein. +Implementierungen dürfen @samp{Eval} erweitern, um Programme, die keine +Ausdrücke sind (Definitionen) als das erste Argument zu erlauben und um +andere Werte als Umgebungen zuzulassen, mit der Einschränkung, dass +@samp{Eval} keine neuen Bindungen in den mit @samp{Null-environment} +oder @samp{Scheme-report-environment} assoziierten Umgebungen erzeugen +darf. + + +@format +@t{(eval '(* 7 3) (scheme-report-environment 5)) + ==> 21 + +(let ((f (eval '(lambda (f x) (f x x)) + (null-environment 5)))) + (f + 10)) + ==> 20 +} +@end format + + +@end deffn + + +@deffn {Prozedur} scheme-report-environment version +@deffnx {Prozedur} null-environment version + +@var{Version} muss die exakte ganze Zahl @samp{5} sein, entsprechend +dieser Fassung des Scheme-Berichts (des Revised^5 Report on Scheme). +@samp{Scheme-report-environment} gibt eine Angabe einer Umgebung zurück, +die leer ist bis auf alle in diesem Bericht angegebenen Bindungen, die +entweder notwendig oder sowohl optional als auch von der Implementierung +unterstützt sind. @samp{Null-environment} gibt eine Angabe der Umgebung +zurück, die leer ist außer den (syntaktischen) Bindungen aller +syntaktischen Schlüsselwörtern, die in diesem Bericht definiert werden +und die entweder notwendig oder sowohl optional als auch von der +Implementierung unterstützt sind. + +Andere Werte von @var{Version} können benutzt werden, um zu vergangenen +Fassungen passende Umgebungen zu definieren, aber ihre Unterstützung +wird nicht vorausgesetzt. Eine Implementierung wird einen Fehler +signalisieren, wenn @var{Version} weder @samp{5} noch ein anderer von +der Implementierung unterstützter Wert ist. + +Die Auswirkung davon, eine in einer @samp{Scheme-report-environment} +gebundene Variable (durch Nutzung von @samp{Eval}) zuzuweisen, ist +unbestimmt. Die durch @samp{Scheme-report-environment} angegebenen +Umgebungen dürfen also unveränderlich sein. + +@end deffn + + +@deffn {optionale Prozedur} interaction-environment + +Diese Prozedur gibt eine Angabe der Umgebung zurück, die +implementierungsdefinierte Bindungen enthält, typischerweise eine +Teilmenge der im Bericht aufgelisteten Bindungen. Die Absicht ist, dass +diese Prozedur die Umgebung zurückgibt, in der die Implementierung von +der Nutzerin dynamisch eingetippte Ausdrücke auswertet. + +@end deffn + +@node Ein- und Ausgabe, , Eval, Standardprozeduren +@section Ein- und Ausgabe + +@menu +* Ports:: +* Eingabe:: +* Ausgabe:: +* Systemschnittstelle:: +@end menu + + +@node Ports, Eingabe, Ein- und Ausgabe, Ein- und Ausgabe +@subsection Ports + + + +Ports stellen Ein- und Ausgabegeräte dar. Gegenüber Scheme ist ein +Eingabe-Port ein Scheme-Objekt, das auf Anfrage hin Zeichen liefern +kann, während ein Ausgabe-Port ein Scheme-Objekt ist, das Zeichen +annehmen kann. +@cindex @w{Port} + +@ignore todo +Haase: Mention that there are alternatives to files? +@end ignore + + + +@deffn {Bibliotheksprozedur} call-with-input-file string proc +@deffnx {Bibliotheksprozedur} call-with-output-file string proc + +@var{String} sollte eine Zeichenkette sein, die eine Datei benennt, und +@var{Proc} sollte eine Prozedur sein, die ein Argument nimmt. Für +@samp{Call-with-input-file} sollte die Datei bereits existieren; für +@samp{Call-with-output-file} ist die Auswirkung unbestimmt, wenn die +Datei bereits existiert. Diese Prozeduren rufen @var{Proc} mit einem +Argument auf: dem Port, der durch das Öffnen der benannten Datei zur +Ein- oder Ausgabe erhalten wurde. Wenn die Datei nicht geöffnet werden +kann, wird ein Fehler signalisiert. Wenn @var{Proc} einen Wert +zurückgibt, dann wird der Port automatisch geschlossen und der Wert oder +die Werte, die @var{Proc} geliefert hat, zurückgegeben. Wenn @var{Proc} +keinen Wert zurückgibt, wird der Port nicht automatisch geschlossen, +solange es nicht möglich ist, zu beweisen, dass der Port niemals wieder +für eine Lese- oder Schreibe-Operation benutzt werden wird. +@c Scheme +@c will not close the port unless it can prove that the port will never +@c again be used for a read or write operation. + + +@quotation +@emph{Begründung:} +Weil Schemes Ausstiegsprozeduren einen unbegrenzten Gültigkeitsbereich +haben, ist es möglich, aus der aktuellen Fortsetzung auszusteigen, aber +später wieder hinein zurückzukehren. Wenn Implementierungen den Port +bei jedem Ausstieg aus der aktuellen Fortsetzung schließen dürften, wäre +es unmöglich, portablen Code zu schreiben, der sowohl +@samp{Call-with-current-continuation} als auch +@samp{Call-with-input-file} oder @samp{Call-with-output-file} benutzt. +@ignore todo +Pitman wants more said here; maybe encourage users to call +@var{close-foo-port}; maybe talk about process switches (?). +@end ignore + +@end quotation + +@end deffn + + + +@deffn {Prozedur} input-port? obj +@deffnx {Prozedur} output-port? obj + +Gibt @t{#t} zurück, wenn @var{Obj} jeweils ein Eingabe-Port oder +Ausgabe-Port ist, und gibt sonst @t{#f} zurück. + +@ignore todo +Won't necessarily return true after port is closed. +@end ignore + + +@end deffn + + + +@deffn {Prozedur} current-input-port +@deffnx {Prozedur} current-output-port + +Gibt den aktuellen standardmäßigen Eingabe- oder Ausgabe-Port zurück. + +@end deffn + + + +@deffn {optionale Prozedur} with-input-from-file string thunk +@deffnx {optionale Prozedur} with-output-to-file string thunk + +@var{String} sollte eine Zeichenkette sein, die eine Datei benennt, und +@var{Proc} sollte eine Prozedur ohne Argumente sein. Bei +@samp{With-input-from-file} sollte die Datei bereits existieren, bei +@samp{With-output-to-file} ist die Auswirkungs unbestimmt, wenn die +Datei bereits existiert. Die Datei wird zur Eingabe oder Ausgabe +geöffnet, ein Eingabe- oder Ausgabe-Port mit ihr verbunden, zum +standardmäßigen Wert gemacht, der von @samp{Current-input-port} oder +@samp{Current-output-port} zurückgegeben (und von @t{(read)}, @t{(write +@var{obj})}, und so weiter) benutzt wird, und der @var{Thunk} wird ohne +Argumente aufgerufen. Wenn der @var{Thunk} einen Wert zurückgibt, wird +der Port geschlossen und der vorherige standardmäßige Wert +wiederhergestellt. @samp{With-input-from-file} und +@samp{With-output-to-file} geben den Wert oder die Werte, die +@var{Thunk} geliefert hat, zurück. Wenn eine Ausstiegsprozedur benutzt +wird, um aus der Fortsetzung dieser Prozeduren auszusteigen, ist das +Verhalten der beiden implementierungsabhängig. + +@ignore todo +OK this with authors?? +@end ignore + +@c current continuation changes in such a way +@c as to make it doubtful that the \var{thunk} will ever return. + +@ignore todo +Freeman: +Throughout this section I wanted to see ``the value of @t{(current-input-port)}'' +instead of ``the value returned by @var{current-input-port}''. (Same for +@var{current-output-port}.) +@end ignore + + + +@end deffn + + + +@deffn {Prozedur} open-input-file dateiname + +Nimmt eine Zeichenkette entgegen, die eine existierende Datei benennt, +und gibt einen Eingabe-Port zurück, der in der Lage ist, Zeichen aus +dieser Datei zu liefern. Wenn die Datei nicht geöffnet werden kann, +wird ein Fehler signalisiert. + +@end deffn + + + +@deffn {Prozedur} open-output-file dateiname + +Nimmt eine Zeichenkette entgegen, die eine Ausgabedatei benennt, die zu +erstellen ist, und gibt einen Ausgabe-Port zurück, der in der Lage ist, +Zeichen in eine neue Datei dieses Namens zu schreiben. Wenn die Datei +nicht geöffnet werden kann, wird ein Fehler signalisiert. Wenn eine +Datei mit dem angegebenen Namen bereits existiert, ist die Auswirkung +unbestimmt. + +@end deffn + + + +@deffn {Prozedur} close-input-port port +@deffnx {Prozedur} close-output-port port + +Schließt die mit @var{Port} assoziierte Datei, was den @var{Port} nicht +mehr in der Lage belässt, Zeichen zu liefern oder zu akzeptieren. +@ignore todo +But maybe a no-op +on some ports, e.g. terminals or editor buffers. +@end ignore + +Diese Routinen haben keine Auswirkung, wenn die Datei bereits +geschlossen wurde. Der zurückgegebene Wert ist unbestimmt. + +@ignore todo +Ramsdell: Some note is needed explaining why there are two +different close procedures. +@end ignore + + +@ignore todo +A port isn't necessarily still a port after it has been closed? +@end ignore + + +@end deffn + + +@node Eingabe, Ausgabe, Ports, Ein- und Ausgabe +@subsection Eingabe + + + + +@noindent + @w{ } +@c ??? +@sp 5 +@ignore todo +The input routines have some things in common, maybe explain here. +@end ignore + + + +@deffn {Bibliotheksprozedur} read +@deffnx {Bibliotheksprozedur} read port + +@samp{Read} („lesen``) wandelt externe Darstellungen von Scheme-Objekten +in die Objekte selbst um. Das heißt, sie dient zur Analyse des +nichtterminalen <Datenelement>s (siehe die Abschnitte @pxref{Externe +Darstellung} und @pxref{Paare und Listen}). @samp{Read} gibt das +nächste analysierbare Objekt des angegebenen Eingabe-@var{Port}s zurück +und aktualisiert dabei den @var{Port}, so dass er auf das erste Zeichen +nach dem Ende der externen Darstellung des Objekts zeigt. + +Wenn @samp{Read} auf ein Dateiende in der Eingabe trifft, bevor jegliche +Zeichen gefunden wurden, die der Anfang eines Objekts sein können, dann +wird ein Dateiende-Objekt zurückgegeben. +@ignore todo + +@end ignore + Der Port bleibt offen und weitere Versuche zu lesen, werden auch ein +Dateiende-Objekt zurückgeben. Wenn auf ein Dateiende nach dem Anfang +der externen Darstellung eines Objekts getroffen wird, aber die externe +Darstellung unvollständig und daher nicht analysierbar ist, wird ein +Fehler signalisiert. + +Das @var{Port}-Argument darf weggelassen werden und nimmt in diesem Fall +standardmäßig den Wert an, der durch @samp{Current-input-port} +zurückgegeben wird. Es ist ein Fehler, von einem geschlossenen Port zu +lesen. +@end deffn + + +@deffn {Prozedur} read-char +@deffnx {Prozedur} read-char port + +Gibt das nächste vom Eingabe@var{port} verfügbare Zeichen zurück und +aktualisiert dabei den @var{Port}, so dass er auf das darauf folgende +Zeichen zeigt. Wenn keine Zeichen mehr verfügbar sind, wird ein +Dateiende-Objekt zurückgegeben. @var{Port} darf weggelassen werden und +nimmt in diesem Fall standardmäßig den Wert an, der durch +@samp{Current-input-port} zurückgegeben wird. + +@end deffn + + + +@deffn {Prozedur} peek-char +@deffnx {Prozedur} peek-char port + +Gibt das nächste vom Eingabe-@var{Port} verfügbare Zeichen zurück, +@emph{ohne} den @var{Port} zu aktualisieren, also ohne ihn auf das +nachfolgende Zeichen zeigen zu lassen. Wenn keine Zeichen mehr +verfügbar sind, wird ein Dateiende-Objekt zurückgegeben. @var{Port} +darf weggelassen werden, in diesem Fall nimmt er standardmäßig den Wert +an, der von @samp{Current-input-port} zurückgegeben wird. + + +@quotation +@emph{Anmerkung:} +Der vom Aufruf von @samp{Peek-char} zurückgegebene Wert ist derselbe wie +der von einem Aufruf von @samp{Read-char} mit demselben @var{Port} +zurückgegeben wird. Der einzige Unterschied ist, dass der direkt +folgende Aufruf von @samp{Read-char} oder @samp{Peek-char} auf diesem +@var{Port} den Wert zurückgeben wird, den der vorhergehende Aufruf von +@samp{Peek-char} zurückgegeben hat. Insbesondere wird ein Aufruf von +@samp{Peek-char} auf einem interaktiven Port hängen, während er auf eine +Eingabe wartet, wann immer ein Aufruf von @samp{Read-char} gehangen +hätte. +@end quotation + + +@end deffn + + + +@deffn {Prozedur} eof-object? obj + +Gibt @t{#t} zurück, wenn @var{Obj} ein Dateiende-Objekt ist, und gibt +sonst @t{#f} zurück. Die genaue Menge von Dateiende-Objekten wird sich +je nach Implementierung unterscheiden, jedenfalls wird ein +Dateiende-Objekt aber niemals ein durch Benutzung von @samp{Read} +lesbares Objekt sein. + +@end deffn + + + +@deffn {Prozedur} char-ready? +@deffnx {Prozedur} char-ready? port + +Gibt @t{#t} zurück, wenn ein Zeichen auf dem Eingabe@var{port} bereit +ist, und gibt sonst @t{#f} zurück. Wenn @samp{Char-ready} den Wert +@t{#t} zurückgibt, dann ist garantiert, dass die nächste +@samp{Read-char}-Operation auf dem übergebenen @var{Port} nicht hängen +wird. Wenn der @var{Port} am Dateiende ist, dann gibt +@samp{Char-ready?} den Wert @t{#t} zurück. @var{Port} darf weggelassen +werden, in diesem Fall nimmt er standardmäßig den von +@samp{Current-input-port} zurückgegebenen Wert an. + + +@quotation +@emph{Begründung:} +@samp{Char-ready?} existiert, um es einem Programm zu ermöglichen, +Zeichen von interaktiven Ports zu akzeptieren, ohne im Warten auf +Eingaben festzustecken. Jeder Eingabebearbeiter, der mit solchen Ports +assoziiert ist, muss sicherstellen, dass Zeichen, deren Existenz durch +@samp{Char-ready?} zugesichert wurde, nicht mehr ausradiert werden +können. Wenn @samp{Char-ready?} den Wert @t{#f} am Dateiende +zurückgeben würde, könnte man einen Port am Dateiende nicht von einem +interaktiven Port unterscheiden, der keine bereitstehenden Zeichen hat. +@end quotation + +@end deffn + + +@node Ausgabe, Systemschnittstelle, Eingabe, Ein- und Ausgabe +@subsection Ausgabe + + + +@c We've got to put something here to fix the indentation!! + +@noindent + @w{} +@sp 5 + + +@deffn {Bibliotheksprozedur} write obj +@deffnx {Bibliotheksprozedur} write obj port + +Schreibt eine geschriebene Darstellung von @var{Obj} auf den übergebenen +@var{Port}. Zeichenketten, die in der geschriebenen Darstellung +vorkommen, werden in doppelte Anführungszeichen eingeschlossen, und +innerhalb dieser Zeichenketten wird jeder Backslash und jedes doppelte +Anführungszeichen durch einen Backslash maskiert. Zeichenobjekte werden +durch Nutzung der Notation @samp{#\} geschrieben. @samp{Write} gibt +einen unbestimmten Wert zurück. Das @var{Port}-Argument darf +weggelassen werden, in diesem Fall nimmt es standardmäßig den von +@samp{Current-output-port} zurückgegebenen Wert an. + +@end deffn + + + +@deffn {Bibliotheksprozedur} display obj +@deffnx {Bibliotheksprozedur} display obj port + +Schreibt eine Darstellung von @var{Obj} auf den übergebenen @var{Port}. +Zeichenketten, die in der geschriebenen Darstellung auftauchen, werden +nicht mit doppelten Anführungszeichen umschlossen und keine Zeichen +werden innerhalb dieser Zeichenketten maskiert. Zeichenobjekte kommen +in der Darstellung so vor, als würden sie mit @samp{Write-char} statt +mit @samp{Write} geschrieben. @samp{Display} gibt einen unbestimmten +Wert zurück. Das @var{Port}-Argument darf weggelassen werden, in diesem +Fall nimmt es standardmäßig den Wert an, den @samp{Current-output-port} +zurückgibt. + + +@quotation +@emph{Begründung:} +Die Absicht hinter @samp{Write} ist, maschinenlesbare Ausgaben zu +produzieren, während @samp{Display} dazu dienen soll, menschenlesbare +Ausgaben zu produzieren. Implementierungen, die „Slashifizierung`` +innerhalb von Symbolen zulassen, werden wahrscheinlich wollen, dass +@samp{Write}, aber nicht @samp{Display}, komische Zeichen in Symbolen +slashifiziert. +@end quotation + +@end deffn + + + +@deffn {Bibliotheksprozedur} newline +@deffnx {Bibliotheksprozedur} newline port + +Schreibt ein Zeilenende auf den @var{Port}. Wie genau dies umgesetzt +wird, unterscheidet sich je nach Betriebssystem. Gibt einen +unbestimmten Wert zurück. Das @var{Port}-Argument darf weggelassen +werden, in diesem Fall nimmt es standardmäßig den durch +@samp{Current-output-port} zurückgegebenen Wert an. + +@end deffn + + + +@deffn {Prozedur} write-char char +@deffnx {Prozedur} write-char char port + +Schreibt das Zeichen @var{Char} (nicht eine externe Darstellung dieses +Zeichens) auf den übergebenen @var{Port} und gibt einen unbestimmten +Wert zurück. Das @var{Port}-Argument darf weggelassen werden, in diesem +Fall nimmt es standardmäßig den von @samp{Current-output-port} +zurückgegebenen Wert an. + +@end deffn + + +@node Systemschnittstelle, , Ausgabe, Ein- und Ausgabe +@subsection Systemschnittstelle + + +Fragen der Systemschnittstelle fallen im allgemeinen nicht in den +Zuständigkeitsbereich dieses Berichts. Die folgenden Operationen sind +jedoch wichtig genug, um eine Beschreibung hier zu verdienen. + + + +@deffn {optionale Prozedur} load dateiname + +@ignore todo +Fix +@end ignore + + +@c \domain{\var{Filename} should be a string naming an existing file +@c containing Scheme source code.} The {\cf load} procedure reads +@var{Dateiname} sollte eine Zeichenkette sein, die eine existierende +Datei benennt, welche Scheme-Quellcode enthält. Die Prozedur +@samp{Load} liest Ausdrücke und Definitionen aus der Datei und wertet +sie der Reihe nach aus. Es ist unbestimmt, ob die Ergebnisse der +Ausdrücke ausgegeben werden. Die Prozedur @samp{Load} beeinflusst den +von @samp{Current-input-port} und @samp{Current-output-port} +zurückgegebenen Wert nicht. @samp{Load} gibt einen unbestimmten Wert +zurück. + + +@quotation +@emph{Begründung:} +Der Portabilität wegen wird vorausgesetzt, dass @samp{Load} auf +Quelldateien arbeiten muss. Wie es mit anderen Arten von Dateien +umgeht, unterscheidet sich notwendigerweise zwischen Implementierungen. +@end quotation + +@end deffn + + + +@deffn {optionale Prozedur} transcript-on dateiname +@deffnx {optionale Prozedur} transcript-off + +@var{Dateiname} muss eine Zeichenkette sein, die eine Ausgabedatei +benennt, die erstellt werden soll. Die Auswirkung von +@samp{Transcript-on} ist, die benannte Datei zur Ausgabe zu öffnen und +eine Abschrift der nachfolgenden Interaktion zwischen der Nutzerin und +dem Scheme-System in die Datei schreiben zu lassen. Die Abschrift endet +mit einem Aufruf von @samp{Transcript-off}, welche die Datei der +Abschrift schließt. Nur eine Abschrift darf gleichzeitig angefertigt +werden, wobei manche Implementierungen diese Einschränkung lockern +könnten. Die Werte, die von diesen Prozeduren zurückgegeben werden, +sind unbestimmt. + +@c \begin{note} +@c These procedures are redundant in some systems, but +@c systems that need them should provide them. +@c \end{note} +@end deffn + +@page + +@c @include{syn} +@node Formale Syntax und Semantik, Bemerkungen, Standardprozeduren, top +@chapter Formale Syntax und Semantik + +@menu +* Formale Syntax:: +* Formale Semantik:: +* Abgeleiteter Ausdruckstyp:: +@end menu + + + +Dieses Kapitel bietet formale Beschreibungen dessen, was in vorherigen +Kapiteln dieses Berichts bereits informell beschrieben wurde. + +@ignore todo +Allow grammar to say that else clause needn't be last? +@end ignore + + + +@node Formale Syntax, Formale Semantik, Formale Syntax und Semantik, Formale Syntax und Semantik +@section Formale Syntax + +@menu +* Lexikalische Struktur:: +* Externe Darstellung:: +* Ausdruck:: +* Quasimaskierungen:: +* Umwandler:: +* Programme und Definitionen:: +@end menu + + + +Dieser Abschnitt bietet eine formale Syntax für Scheme, die in einer +erweiterten BNF geschrieben ist. + +Jeglicher Leerraum in der Grammatik dient nur der Lesbarkeit. Groß- und +Kleinschreibung wird nicht unterschieden, zum Beispiel sind @samp{#x1A} +und @samp{#X1a} äquivalent. <leer> steht für die leere Zeichenkette. + +Die folgenden Erweiterungen der BNF werden benutzt, um eine knappere +Beschreibung zu ermöglichen: <Ding>* bedeutet null oder mehr Vorkommen +von <Ding> und <Ding>+ bedeutet mindestens ein <Ding>. + + +@node Lexikalische Struktur, Externe Darstellung, Formale Syntax, Formale Syntax +@subsection Lexikalische Struktur + + +Dieser Abschnitt beschreibt, wie einzelne Tokens („Marken``, +d.h. Bezeichner, +@cindex @w{Token} +Zahlen, etc.) aus Folgen von Zeichen gebildet werden. Die danach +folgenden Abschnitte beschreiben, wie Ausdrücke und Programme aus Folgen +von Tokens gebildet werden. + +<Leerraum zwischen Tokens> darf auf beiden Seiten eines beliebigen +Tokens auftreten, aber nicht innerhalb eines Tokens. + +Tokens, die ein implizites Ende erfordern (Bezeichner, Zahlen, Zeichen +und der Punkt) dürfen von jedem <Trennzeichen> beendet werden, aber +nicht unbedingt von irgendetwas anderem. + +Die folgenden fünf Zeichen werden für spätere Erweiterungen der Sprache +reserviert: @t{[ ] @{ @} |} + + +@format +@cindex @w{Bezeichner} +@cindex @w{Kommentar} +@t{<Token> --> <Bezeichner> | <boolescher Wert> | <Zahl> +@c @cindex @w{Bezeichner} + | <Zeichen> | <Zeichenkette> + | ( | ) | #( | @t{'} | @t{`} | , | ,@@ | @b{.} +<Trennzeichen> --> <Leerraum> | ( | ) | " | ; +<Leerraum> --> <Leerzeichen oder Zeilenvorschub> +<Kommentar> --> ; <@r{alle nachfolgenden Zeichen bis zu einem} + @r{Zeilenvorschub>} +@c @cindex @w{Kommentar} +<Atmosphäre> --> <Leerraum> | <Kommentar> +<Leerraum zwischen Tokens> --> <Atmosphäre>*} + +@end format + + + + + + +@c This is a kludge, but \multicolumn doesn't work in tabbing environments. + + + +@format +@cindex @w{syntaktisches Schlüsselwort} +@cindex @w{Schlüsselwort} +@cindex @w{Variable} +@t{<Bezeichner> --> <Anfangselement> <Folgeelement>* + | <besonderer Bezeichner> +<Anfangselement> --> <Buchstabe> | <spezielles Anfangselement> +<Buchstabe> --> a | b | c | ... | z + +<spezielles Anfangselement> --> ! | $ | % | & | * | / | : + | < | = | > | ? | ^ | _ | ~ +<Folgeelement> --> <Anfangselement> | <Ziffer> + | <spezielles Folgeelement> +<Ziffer> --> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 +<spezielles Folgeelement> --> + | - | .@: | @@ +<besonderer Bezeichner> --> + | - | ... +<syntaktisches Schlüsselwort> --> <Ausdrucksschlüsselwort> +@c @cindex @w{syntaktisches Schlüsselwort} +@c @cindex @w{Schlüsselwort} + | else | => | define + | unquote | unquote-splicing +<Ausdrucksschlüsselwort> --> quote | lambda | if + | set! | begin | cond | and | or | case + | let | let* | letrec | do | delay + | quasiquote + +@w{@samp{<Variable> @result{} <}}@r{beliebiger Bezeichner, der nicht} +@c @cindex @w{Variable} + @w{ @r{auch ein <syntaktisches Schlüsselwort> ist>}} + +<boolescher Wert> --> #t | #f +<Zeichen> --> #\ <beliebiges Zeichen> + | #\ <Zeichenname> +<Zeichenname> --> space | newline + +<Zeichenkette> --> " <Zeichenkettenelement>* " +<Zeichenkettenelement> --> <beliebiges Zeichen außer " oder \> + | \" | \\ } + +@end format + + + + + + + +@format +@t{<Zahl> --> <num 2>| <num 8> + | <num 10>| <num 16> +} + +@end format + + + +Die folgenden Regeln für <num R>, <complex R>, <real R>, <ureal R>, +<uinteger R> und <prefix R> sollten für @w{R = 2, 8, 10,} und 16 +nachgebildet werden. Es gibt keine Regeln für <decimal 2>, <decimal 8> +und <decimal 16>, was bedeutet, dass Zahlen, die Dezimaltrennzeichen +oder Exponenten enthalten, Radix 10 (d.h. Basis 10) haben müssen. +@ignore todo +Mark Meyer and David Bartley want to fix this. (What? -- Will) +@end ignore + + + +@format +@t{<num R> --> <Präfix R> <complex R> +<complex R> --> <real R> | <real R> @@ <real R> + | <real R> + <ureal R> i | <real R> - <ureal R> i + | <real R> + i | <real R> - i + | + <ureal R> i | - <ureal R> i | + i | - i +<real R> --> <Vorzeichen> <ureal R> +<ureal R> --> <uinteger R> + | <uinteger R> / <uinteger R> + | <decimal R> +<decimal 10> --> <uinteger 10> <Suffix> + | . <Ziffer 10>+ #* <Suffix> + | <Ziffer 10>+ . <Ziffer 10>* #* <Suffix> + | <Ziffer 10>+ #+ . #* <Suffix> +<uinteger R> --> <digit R>+ #* +<Präfix R> --> <Radix R> <Exaktheit> + | <Exaktheit> <Radix R> +} + +@end format + + + + +@format +@vindex #e +@vindex #i +@vindex #b +@vindex #o +@vindex #x +@t{<Suffix> --> <leer> + | <Exponentenmarkierung> <Vorzeichen> <Ziffer 10>+ +<Exponentenmarkierung> --> e | s | f | d | l +<Vorzeichen> --> <leer> | + | - +<Exaktheit> --> <leer> | #i | #e +@c @vindex #e +@c @vindex #i +<Radix 2> --> #b +@c @vindex #b +<Radix 8> --> #o +@c @vindex #o +<Radix 10> --> <empty> | #d +<Radix 16> --> #x +@c @vindex #x +<Ziffer 2> --> 0 | 1 +<Ziffer 8> --> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 +<Ziffer 10> --> <Ziffer> +<Ziffer 16> --> <Ziffer 10> | a | b | c | d | e | f } + +@end format + + + +@ignore todo +Mark Meyer of TI sez, shouldn't we allow @t{1e3/2}? +@end ignore + + + +@node Externe Darstellung, Ausdruck, Lexikalische Struktur, Formale Syntax +@subsection Externe Darstellungen + + + +<Datenelement> ist, was die Prozedur @code{Read} (siehe den Abschnitt +@pxref{Eingabe}) +@vindex @w{Read} +erfolgreich analysiert. Beachten Sie, dass jede Zeichenkette, die als +ein <Ausdruck> analysiert werden kann, auch als ein <Datenelement +analysiert werden kann>. + + +@format +@t{<Datenelement> --> <einfaches Datenelement> + | <zusammengesetztes Datenelement> +<einfaches Datenelement> --> <boolescher Wert> | <Zahl> + | <Zeichen> | <Zeichenkette> | <Symbol> +<Symbol> --> <Bezeichner> +<zusammengesetztes Datenelement> --> <Liste> | <Vektor> +<Liste> --> (<Datenelement>*) + | (<Datenelement>+ .@: <Datenelement>) | <Abkürzung> +<Abkürzung> --> <Abk-Präfix> <Datenelement> +<Abk-Präfix> --> ' | ` | , | ,@@ +<Vektor> --> #(<Datenelement>*) } + +@end format + + + + +@node Ausdruck, Quasimaskierungen, Externe Darstellung, Formale Syntax +@subsection Ausdrücke + + + +@format +@t{<Ausdruck> --> <Variable> + | <Literal> + | <Prozeduraufruf> + | <lambda-Ausdruck> + | <Bedingung> + | <Zuweisung> + | <abgeleiteter Ausdruck> + | <Makronutzung> + | <Makroblock> + +<Literal> --> <Maskierung> | <Selbstauswertung> +<Selbstauswertung> --> <boolescher Wert> | <Zahl> + | <Zeichen> | <Zeichenkette> +<Maskierung> --> '<Datenelement> | (quote <Datenelement>) +<Prozeduraufruf> --> (<Operator> <Operand>*) +<Operator> --> <Ausdruck> +<Operand> --> <Ausdruck> + +<lambda-Ausdruck> --> (lambda <Formale> <Rumpf>) +<Formale> --> (<Variable>*) | <Variable> + | (<Variable>+ .@: <Variable>) +<Rumpf> --> <Definition>* <Folge> +<Folge> --> <Befehl>* <Ausdruck> +<Befehl> --> <Ausdruck> + +<Bedingung> --> (if <Test> <Folgerung> <Alternative>) +<Test> --> <Ausdruck> +<Folgerung> --> <Ausdruck> +<Alternative> --> <Ausdruck> | <leer> + +<Zuweisung> --> (set! <Variable> <Ausdruck>) + +<abgeleiteter Ausdruck> --> + (cond <cond-Klausel>+) + | (cond <cond-Klausel>* (else <Folge>)) + | (case <Ausdruck> + <case-Klausel>+) + | (case <Ausdruck> + <case-Klausel>* + (else <Folge>)) + | (and <Test>*) + | (or <Test>*) + | (let (<Bindungsspezifikation>*) <Rumpf>) + | (let <Variable> (<Bindungsspezifikation>*) <Rumpf>) + | (let* (<Bindungsspezifikation>*) <Rumpf>) + | (letrec (<Bindungsspezifikation>*) <Rumpf>) + | (begin <Folge>) + | (do (<Iterationsspezifikation>*) + (<Test> <do-Ergebnis>) + <Befehl>*) + | (delay <Iterationsspezifikation>) + | <Quasimaskierung> + +<cond-Klausel> --> (<Test> <Folge>) + | (<Test>) + | (<Test> => <Empfänger>) +<Empfänger> --> <Ausdruck> +<case-Klausel> --> ((<Datenelement>*) <Folge>) +<Bindungsspezifikation> --> (<Variable> <Ausdruck>) +<Iterationsspezifikation> --> (<Variable> <Anfang> <Schritt>) + | (<Variable> <Anfang>) +<Anfang> --> <Ausdruck> +<Schritt> --> <Ausdruck> +<do-Ergebnis> --> <Folge> | <leer> + +<Makronutzung> --> (<Schlüsselwort> <Datenelement>*) +<Schlüsselwort> --> <Bezeichner> + +<Makroblock> --> + (let-syntax (<Syntaxspezifikation>*) <Rumpf>) + | (letrec-syntax (<Syntaxspezifikation>*) <Rumpf>) +<Syntaxspezifikation> --> (<Schlüsselwort> <Umwandlerspezifikation>) + +} + +@end format + + + +@node Quasimaskierungen, Umwandler, Ausdruck, Formale Syntax +@subsection Quasimaskierungen + + +Die folgende Grammatik für Quasimaskierungsausdrücke ist nicht +kontextfrei. Sie wird als ein Rezept zur Generierung unendlich vieler +Produktionsregeln vorgestellt. Stellen Sie sich eine Kopie der +folgenden Regeln für jedes D = 1, 2,3, @dots{} vor. D misst die +Verschachtelungstiefe. + + +@format +@t{<Quasimaskierung> --> <Quasimaskierung 1> +<qq-Schablone 0> --> <Ausdruck> +<Quasimaskierung D> --> `<qq-Schablone D> + | (quasiquote <qq-Schablone D>) +<qq-Schablone D> --> <einfaches Datenelement> + | <Listen-qq-Schablone D> + | <Vektor-qq-Schablone D> + | <Demaskierung D> +<Listen-qq-Schablone D> --> (<qq-Schablone oder Spleißung D>*) + | (<qq-Schablone oder Spleißung D>+ .@: <qq-Schablone D>) + | '<qq-Schablone D> + | <Quasimaskierung D+1> +<Vektor-qq-Schablone D> --> #(<qq-Schablone oder Spleißung D>*) +<Demaskierung D> --> ,<qq-Schablone D-1> + | (unquote <qq-Schablone D-1>) +<qq-Schablone oder Spleißung D> --> <qq-Schablone D> + | <spleißende Demaskierung D> +<spleißende Demaskierung D> --> ,@@<qq-Schablone D-1> + | (unquote-splicing <qq-Schablone D-1>) } + +@end format + + + +In <Quasimaskierung>en kann eine <Listen-qq-Schablone D> manchmal +verwechselt werden mit entweder einer <Demaskierung D> oder einem +Vorkommen von <spleißende Demaskierung D>. Die Interpretation als eine +<Demaskierung> oder <spleißende Demaskierung D> hat Vorrang. + +@node Umwandler, Programme und Definitionen, Quasimaskierungen, Formale Syntax +@subsection Umwandler + + + +@format +@t{<Umwandlerspezifikation> --> + (syntax-rules (<Bezeichner>*) <Syntaxregel>*) +<Syntaxregel> --> (<Muster> <Schablone>) +<Muster> --> <Musterbezeichner> + | (<Muster>*) + | (<Muster>+ . <Muster>) + | (<Muster>* <Muster> <Auslassungspunkte>) + | #(<Muster>*) + | #(<Muster>* <Muster> <Auslassungspunkte>) + | <Musterdatenelement> +<Musterdatenelement> --> <Zeichenkette> + | <Zeichen> + | <boolescher Wert> + | <Zahl> +<Schablone> --> <Musterbezeichner> + | (<Schablonenelement>*) + | (<Schablonenelement>+ . <Schablone>) + | #(<Schablonenelement>*) + | <Schablonendatenelement> +<Schablonenelement> --> <Schablone> + | <Schablone> <Auslassungspunkte> +<Schablonendatenelement> --> <Musterdatenelement> +<Musterbezeichner> --> <beliebiger Bezeichner außer @samp{...}> +<Auslassungspunkte> --> <der Bezeichner @samp{...}> +} + +@end format + + + +@node Programme und Definitionen, , Umwandler, Formale Syntax +@subsection Programme und Definitionen + + + +@format +@t{<Programm> --> <Befehl oder Definition>* +<Befehl oder Definition> --> <Befehl> + | <Definition> + | <Syntaxdefinition> + | (begin <Befehl oder Definition>+) +<Definition> --> (define <Variable> <Ausdruck>) + | (define (<Variable> <Def-Formale>) <Rumpf>) + | (begin <Definition>*) +<Def-Formale> --> <Variable>* + | <Variable>* .@: <Variable> +<Syntaxdefinition> --> + (define-syntax <Schlüsselwort> <Umwandlerspezifikation>) +} + +@end format + + + +@node Formale Semantik, Abgeleiteter Ausdruckstyp, Formale Syntax, Formale Syntax und Semantik +@section Formale Semantik + + +Dieser Abschnitt bietet eine formale, denotationelle Semantik für die +grundlegenden Ausdrücke von Scheme und ausgewählte eingebaute +Prozeduren. Das hier benutzte Konzept und die Notation werden in +@sc{[Stoy77]} beschrieben. + +@quotation +@emph{Anmerkung:} Der Abschnitt zur formalen Semantik wurde in La@TeX{} +geschrieben, das mit @TeX{}info inkompatibel ist. Siehe den Abschnitt +zur formalen Semantik im Originaldokument, von dem dieses hier eine +Bearbeitung ist. +@end quotation + + +@c @include{derive} +@node Abgeleiteter Ausdruckstyp, , Formale Semantik, Formale Syntax und Semantik +@section Abgeleiteter Ausdruckstyp + + + +Dieser Abschnitt gibt Makrodefinitionen für abgeleitete Ausdruckstypen +aufgebaut aus den grundlegenden Ausdruckstypen an (Literal, Variable, +Aufruf, @samp{Lambda}, @samp{If}, @samp{Set!}). Siehe den Abschnitt +@ref{Programmflussfunktionalitäten} für eine mögliche Definition von +@samp{Delay}. + + +@example + +(define-syntax cond + (syntax-rules (else =>) + ((cond (else result1 result2 ...)) + (begin result1 result2 ...)) + ((cond (test => result)) + (let ((temp test)) + (if temp (result temp)))) + ((cond (test => result) clause1 clause2 ...) + (let ((temp test)) + (if temp + (result temp) + (cond clause1 clause2 ...)))) + ((cond (test)) test) + ((cond (test) clause1 clause2 ...) + (let ((temp test)) + (if temp + temp + (cond clause1 clause2 ...)))) + ((cond (test result1 result2 ...)) + (if test (begin result1 result2 ...))) + ((cond (test result1 result2 ...) + clause1 clause2 ...) + (if test + (begin result1 result2 ...) + (cond clause1 clause2 ...))))) + +@end example + + + +@example + +(define-syntax case + (syntax-rules (else) + ((case (key ...) + clauses ...) + (let ((atom-key (key ...))) + (case atom-key clauses ...))) + ((case key + (else result1 result2 ...)) + (begin result1 result2 ...)) + ((case key + ((atoms ...) result1 result2 ...)) + (if (memv key '(atoms ...)) + (begin result1 result2 ...))) + ((case key + ((atoms ...) result1 result2 ...) + clause clauses ...) + (if (memv key '(atoms ...)) + (begin result1 result2 ...) + (case key clause clauses ...))))) + +@end example + + + +@example + +(define-syntax and + (syntax-rules () + ((and) #t) + ((and test) test) + ((and test1 test2 ...) + (if test1 (and test2 ...) #f)))) + +@end example + + + +@example + +(define-syntax or + (syntax-rules () + ((or) #f) + ((or test) test) + ((or test1 test2 ...) + (let ((x test1)) + (if x x (or test2 ...)))))) + +@end example + + + +@example + +(define-syntax let + (syntax-rules () + ((let ((name val) ...) body1 body2 ...) + ((lambda (name ...) body1 body2 ...) + val ...)) + ((let tag ((name val) ...) body1 body2 ...) + ((letrec ((tag (lambda (name ...) + body1 body2 ...))) + tag) + val ...)))) + +@end example + + + +@example + +(define-syntax let* + (syntax-rules () + ((let* () body1 body2 ...) + (let () body1 body2 ...)) + ((let* ((name1 val1) (name2 val2) ...) + body1 body2 ...) + (let ((name1 val1)) + (let* ((name2 val2) ...) + body1 body2 ...))))) + +@end example + + +Das folgende Makro für @samp{Letrec} benutzt das Symbol +@samp{<undefiniert>} für einen Ausdruck, der etwas zurückgibt, was, wenn +es an einer Stelle gespeichert ist, zu einem Fehler führt, wenn man +versucht, den Wert an der Stelle zu ermitteln (kein solcher Ausdruck ist +in Scheme definiert). Ein Trick wird benutzt, um temporäre Namen zu +generieren, damit die Reihenfolge, in der die Werte ausgewertet werden, +nicht festgelegt wird. Dies könnte auch über ein Hilfsmakro erreicht +werden. + + +@example + +(define-syntax letrec + (syntax-rules () + ((letrec ((var1 init1) ...) body ...) + (letrec "erzeuge temp. Namen" + (var1 ...) + () + ((var1 init1) ...) + body ...)) + ((letrec "erzeuge temp. Namen" + () + (temp1 ...) + ((var1 init1) ...) + body ...) + (let ((var1 <undefiniert>) ...) + (let ((temp1 init1) ...) + (set! var1 temp1) + ... + body ...))) + ((letrec "erzeuge temp. Namen" + (x y ...) + (temp ...) + ((var1 init1) ...) + body ...) + (letrec "erzeuge temp. Namen" + (y ...) + (newtemp temp ...) + ((var1 init1) ...) + body ...)))) + +@end example + + + +@example + +(define-syntax begin + (syntax-rules () + ((begin exp ...) + ((lambda () exp ...))))) + +@end example + + +Der folgende alternative Ausdruck für @samp{Begin} benutzt die +Möglichkeit nicht, mehr als einen Ausdruck in den Rumpf eines +lambda-Ausdrucks zu schreiben. Beachten Sie jedenfalls, dass diese +Regeln nur anwendbar sind, wenn der Rumpf des @samp{Begin} keine +Definitionen enthält. + + +@example + +(define-syntax begin + (syntax-rules () + ((begin exp) + exp) + ((begin exp1 exp2 ...) + (let ((x exp1)) + (begin exp2 ...))))) + +@end example + + +Die folgende Definition +von @samp{Do} benutzt einen Trick, um die Variablenklauseln zu +entfalten. Wie bei obigem @samp{Letrec} würde ein Hilfsmakro auch +funktionieren. Der Ausdruck @samp{(if #f #f)} wird benutzt, um einen +nicht näher bestimmten Wert zu erhalten. + + +@example + +(define-syntax do + (syntax-rules () + ((do ((var init step ...) ...) + (test expr ...) + command ...) + (letrec + ((loop + (lambda (var ...) + (if test + (begin + (if #f #f) + expr ...) + (begin + command + ... + (loop (do "step" var step ...) + ...)))))) + (loop init ...))) + ((do "step" x) + x) + ((do "step" x y) + y))) + +@end example + + +@c `a = Q_1[a] +@c `(a b c ... . z) = `(a . (b c ...)) +@c `(a . b) = (append Q*_0[a] `b) +@c `(a) = Q*_0[a] +@c Q*_0[a] = (list 'a) +@c Q*_0[,a] = (list a) +@c Q*_0[,@a] = a +@c Q*_0[`a] = (list 'quasiquote Q*_1[a]) +@c `#(a b ...) = (list->vector `(a b ...)) +@c ugh. + +@page + +@c @include{notes} +@node Bemerkungen, Weiteres Material, Formale Syntax und Semantik, top +@unnumbered Bemerkungen + +@menu +* Sprachänderungen:: +@end menu + + + +@ignore todo +Perhaps this section should be made to disappear. +Can these remarks be moved somewhere else? +@end ignore + + +@node Sprachänderungen, , Bemerkungen, Bemerkungen +@unnumberedsec Sprachänderungen + + + +Dieser Abschnitt zählt die Änderungen auf, die an Scheme vorgenommen +wurde, seit der „Revised^4 report`` [R4RS] veröffentlicht wurde. + + + +@itemize @bullet + + +@item +Dieser Bericht ist nun eine Obermenge des IEEE-Standards für Scheme +[IEEEScheme]: Implementierungen, die diesem Bericht hier genügen, werden +auch dem Standard genügen. Dies machte folgende Änderungen +erforderlich: + + +@itemize @bullet + + +@item +Es wird nun vorausgesetzt, dass die leere List als wahr zählt. + +@item +Die Klassifikation von Funktionalitäten als essenziell oder nicht +essenziell wurde entfernt. Es gibt nun drei Klassen von eingebauten +Prozeduren: grundlegende Prozeduren, Bibliotheksprozeduren und optionale +Prozeduren. Die optionalen Prozeduren sind @samp{Load}, +@samp{With-input-from-file}, @samp{With-output-to-file}, +@samp{Transcript-on}, @samp{Transcript-off} und +@samp{Interaction-environment}, sowie @samp{-} und @samp{/} mit mehr als +zwei Argumenten. Keine von diesen gibt es im IEEE-Standard. + +@item +Programme dürfen eingebaute Prozeduren umdefinieren. Dies wird das +Verhalten anderer eingebauter Prozeduren nicht verändern. + +@end itemize + + +@item +@emph{Port} wurde zur Liste untereinander typfremder Typen hinzugefügt. + +@item +Der Makro-Anhang wurde entfernt. Hochsprachliche Makros sind nun im +Hauptteil des Berichts zu finden. Die Umschreiberegeln für abgeleitete +Ausdrücke wurden durch Makrodefinitionen ersetzt. Es gibt keine +reservierten Bezeichner. + +@item +@samp{Syntax-rules} erlaubt nun Vektormuster. + +@item +Rückgabe mehrerer Werte, @samp{Eval} und @samp{Dynamic-wind} wurden +hinzugefügt. + +@item +Die Aufrufe, die endständig implementiert werden müssen, werden +ausdrücklich definiert. + +@item +,@samp{@@}` kann innerhalb von Bezeichnern verwendet werden. `@samp{|}' +ist für mögliche zukünftige Erweiterungen reserviert. + + +@end itemize + + +@c %R4%% +@c \subsection*{Keywords as variable names} + +@c Some implementations allow arbitrary syntactic +@c keywords \index{keyword}\index{syntactic keyword}to be used as variable +@c names, instead of reserving them, as this report would have +@c it.\index{variable} But this creates ambiguities in the interpretation +@c of expressions: for example, in the following, it's not clear whether +@c the expression {\tt (if 1 2 3)} should be treated as a procedure call or +@c as a conditional. + +@c \begin{scheme} +@c (define if list) +@c (if 1 2 3) \ev 2 {\em{}or} (1 2 3)% +@c \end{scheme} + +@c These ambiguities are usually resolved in some consistent way within any +@c given implementation, but no particular treatment stands out as being +@c clearly superior to any other, so these situations were excluded for the +@c purposes of this report. + +@c %R4%% +@c \subsection*{Macros} + +@c Scheme does not have any standard facility for defining new kinds of +@c expressions.\index{macros} + +@c \vest The ability to alter the syntax of the language creates +@c numerous problems. All current implementations of Scheme have macro +@c facilities that solve those problems to one degree or another, but the +@c solutions are quite different and it isn't clear at this time which +@c solution is best, or indeed whether any of the solutions are truly +@c adequate. Rather than standardize, we are encouraging implementations +@c to continue to experiment with different solutions. + +@c \vest The main problems with traditional macros are: They must be +@c defined to the system before any code using them is loaded; this is a +@c common source of obscure bugs. They are usually global; macros can be +@c made to follow lexical scope rules \todo{flushed: ``as in Common +@c Lisp's {\tt macrolet}''; OK?}, but many people find the resulting scope rules +@c confusing. Unless they are written very carefully, macros are +@c vulnerable to inadvertent capture of free variables; to get around this, +@c for example, macros may have to generate code in which procedure values +@c appear as quoted constants. There is a similar problem with syntactic +@c keywords if the keywords of special forms are not reserved. If keywords +@c are reserved, then either macros introduce new reserved words, +@c invalidating old code, or else special forms defined by the programmer +@c do not have the same status as special forms defined by the system. + +@c \todo{Refer to Pitman's special forms paper.} +@c \todo{Pitman sez: Discuss importance of having a small number of special forms +@c so that programs can inspect each other.} + +@ignore todo +Move cwcc history back here? --- Andy Cromarty is concerned about +confusion over who the audience is. +@end ignore + + +@ignore todo +Cromarty: +23. NOTES, p.35ff.: This material should stay somehow. We need to + make it clear that R^3 Scheme is not being touted as Yet Another + Ultimate Solution To The Programming Language Problem, but rather + as a snapshot of a *process* of good design, for which not all + answers have yet been found. We also ought to use the opportunity + for publicity afforded us by SIGPLAN to advertise some of the thorny + unsolved problems that need further research, and encourage + language designers to work on them. +@end ignore + + +@c @include{repository} +@node Weiteres Material, Beispiel, Bemerkungen, top +@unnumbered Weiteres Material + + +Das Internet Scheme Repository unter + +@c @center +@center @url{http://www.cs.indiana.edu/scheme-repository/} +@c @center + +enthält eine umfassende Scheme-Bibliographie, sowie wissenschaftliche +Arbeiten, Programme, Implementierungen und anderes Material, das mit +Scheme zu tun hat. + +@page + +@c @include{example} + +@node Beispiel, Bibliographie, Weiteres Material, top +@unnumbered Beispiel + +@c -*- Mode: Lisp; Package: SCHEME; Syntax: Common-lisp -*- + + +@samp{Integrate-system} integriert das System + + +@center y_k^^ = f_k(y_1, y_2, @dots{}, y_n), k = 1, @dots{}, n + +von Differentialgleichungen mit der Methode von Runge-Kutta. + +Der Parameter @t{System-derivative} ist eine Funktion, die einen +Systemzustand nimmt (einen Vektor von Werten für die Zustandsvariablen +y_1, @dots{}, y_n) und produziert eine System-Ableitung (die Werte +y_1^^, @dots{},y_n^^). Der Parameter @t{Initial-state} liefert einen +initialen Systemzustand und @t{h} ist eine erste Schätzung für die Länge +des Integrationsschritts. + +Der von @samp{Integrate-system} zurückgegebene Wert ist ein unendlicher +Strom von Systemzuständen. + + +@example + +(define integrate-system + (lambda (system-derivative initial-state h) + (let ((next (runge-kutta-4 system-derivative h))) + (letrec ((states + (cons initial-state + (delay (map-streams next + states))))) + states)))) + +@end example + + +@samp{Runge-Kutta-4} nimmt eine Funktion, @t{f}, die eine +Systemableitung aus einem Systemzustand produziert. +@samp{Runge-Kutta-4} produziert eine Funktion, die einen Systemzustand +nimmt und einen neuen Systemzustand produziert. + + +@example + +(define runge-kutta-4 + (lambda (f h) + (let ((*h (scale-vector h)) + (*2 (scale-vector 2)) + (*1/2 (scale-vector (/ 1 2))) + (*1/6 (scale-vector (/ 1 6)))) + (lambda (y) + ;; y @r{}ist ein Systemzustand + (let* ((k0 (*h (f y))) + (k1 (*h (f (add-vectors y (*1/2 k0))))) + (k2 (*h (f (add-vectors y (*1/2 k1))))) + (k3 (*h (f (add-vectors y k2))))) + (add-vectors y + (*1/6 (add-vectors k0 + (*2 k1) + (*2 k2) + k3)))))))) +@c |--------------------------------------------------| + +(define elementwise + (lambda (f) + (lambda vectors + (generate-vector + (vector-length (car vectors)) + (lambda (i) + (apply f + (map (lambda (v) (vector-ref v i)) + vectors))))))) + +@c |--------------------------------------------------| +(define generate-vector + (lambda (size proc) + (let ((ans (make-vector size))) + (letrec ((loop + (lambda (i) + (cond ((= i size) ans) + (else + (vector-set! ans i (proc i)) + (loop (+ i 1))))))) + (loop 0))))) + +(define add-vectors (elementwise +)) + +(define scale-vector + (lambda (s) + (elementwise (lambda (x) (* x s))))) + +@end example + + +@samp{Map-streams} ist analog zu @samp{Map}: Sie wendet ihr erstes +Argument (eine Prozedur) auf alle Elemente ihres zweiten Arguments (ein +Strom) an. + + +@example + +(define map-streams + (lambda (f s) + (cons (f (head s)) + (delay (map-streams f (tail s)))))) + +@end example + + +Unendliche Ströme sind als Paare implementiert, deren Car das erste +Element des Stroms enthält und deren Cdr ein Versprechen, den Rest des +Stroms zu liefern, enthält. + + +@example + +(define head car) +(define tail + (lambda (stream) (force (cdr stream)))) + +@end example + + +@sp 6 +Im Folgenden wird die Nutzung von @samp{Integrate-system} illustriert, +um das System + + +@center C dv_C / dt = -i_L - v_C / R + + + +@center L di_L / dt = v_C + +zu integrieren, welches einen gedämpften Oszillator modelliert. + + +@example + +(define damped-oscillator + (lambda (R L C) + (lambda (state) + (let ((Vc (vector-ref state 0)) + (Il (vector-ref state 1))) + (vector (- 0 (+ (/ Vc (* R C)) (/ Il C))) + (/ Vc L)))))) + +(define the-states + (integrate-system + (damped-oscillator 10000 1000 .001) + '#(1 0) + .01)) + +@end example + + +@ignore todo +Show some output? +@end ignore + + +@c (letrec ((loop (lambda (s) +@c (newline) +@c (write (head s)) +@c (loop (tail s))))) +@c (loop the-states)) + +@c #(1 0) +@c #(0.99895054 9.994835e-6) +@c #(0.99780226 1.9978681e-5) +@c #(0.9965554 2.9950552e-5) +@c #(0.9952102 3.990946e-5) +@c #(0.99376684 4.985443e-5) +@c #(0.99222565 5.9784474e-5) +@c #(0.9905868 6.969862e-5) +@c #(0.9888506 7.9595884e-5) +@c #(0.9870173 8.94753e-5) + +@page + +@c \newpage % Put bib on it's own page (it's just one) +@c \twocolumn[\vspace{-.18in}]% Last bib item was on a page by itself. +@c \renewcommand{\bibname}{References} +@c @include{bib} + +@c My reference for proper reference format is: +@c Mary-Claire van Leunen. +@c {\em A Handbook for Scholars.} +@c Knopf, 1978. +@c I think the references list would look better in ``open'' format, +@c i.e. with the three blocks for each entry appearing on separate +@c lines. I used the compressed format for SIGPLAN in the interest of +@c space. In open format, when a block runs over one line, +@c continuation lines should be indented; this could probably be done +@c using some flavor of latex list environment. Maybe the right thing +@c to do in the long run would be to convert to Bibtex, which probably +@c does the right thing, since it was implemented by one of van +@c Leunen's colleagues at DEC SRC. +@c -- Jonathan + +@c I tried to follow Jonathan's format, insofar as I understood it. +@c I tried to order entries lexicographically by authors (with singly +@c authored papers first), then by date. +@c In some cases I replaced a technical report or conference paper +@c by a subsequent journal article, but I think there are several +@c more such replacements that ought to be made. +@c -- Will, 1991. + +@c This is just a personal remark on your question on the RRRS: +@c The language CUCH (Curry-Church) was implemented by 1964 and +@c is a practical version of the lambda-calculus (call-by-name). +@c One reference you may find in Formal Language Description Languages +@c for Computer Programming T.~B.~Steele, 1965 (or so). +@c -- Matthias Felleisen + +@c Rather than try to keep the bibliography up-to-date, which is hopeless +@c given the time between updates, I replaced the bulk of the references +@c with a pointer to the Scheme Repository. Ozan Yigit's bibliography in +@c the repository is a superset of the R4RS one. +@c The bibliography now contains only items referenced within the report. +@c -- Richard, 1996. + +@node Bibliographie, Register, Beispiel, top +@unnumbered Bibliographie + + +@itemize @bullet +@c 999 + + +@item [SICP] +@pindex SICP +Harold Abelson und Gerald Jay Sussman mit Julie Sussman. +@emph{Structure and Interpretation of Computer Programs, second edition.} +MIT Press, Cambridge, 1996. + +@item [Bawden88] +@c new +Alan Bawden und Jonathan Rees. +@pindex Bawden88 +Syntactic closures. +In @emph{Proceedings of the 1988 ACM Symposium on Lisp and + Functional Programming}, Seiten 86--95. + +@item [howtoprint] +@pindex howtoprint +Robert G. Burger und R. Kent Dybvig. +Printing floating-point numbers quickly and accurately. +In @emph{Proceedings of the ACM SIGPLAN '96 Conference + on Programming Language Design and Implementation}, Seiten 108--116. + +@item [RRRS] +@pindex RRRS +William Clinger, Herausgeber. +The revised revised report on Scheme, or an uncommon Lisp. +MIT Artificial Intelligence Memo 848, August 1985. +Auch veröffentlicht als Computer Science Department Technical Report 174, + Indiana University, Juni 1985. + +@item [howtoread] +@c new +William Clinger. +@pindex howtoread +How to read floating point numbers accurately. +In @emph{Proceedings of the ACM SIGPLAN '90 Conference + on Programming Language Design and Implementation}, Seiten 92--101. +Sammelband veröffentlicht als @emph{SIGPLAN Notices} 25(6), Juni 1990. + +@item [R4RS] +@pindex R4RS +William Clinger und Jonathan Rees, Herausgeber. +The revised^4 report on the algorithmic language Scheme. +In @emph{ACM Lisp Pointers} 4(3), Seiten 1--55, 1991. + +@item [macrosthatwork] +@c new +William Clinger und Jonathan Rees. +@pindex macrosthatwork +Macros that work. +In @emph{Proceedings of the 1991 ACM Conference on Principles of + Programming Languages}, Seiten 155--162. + +@item [propertailrecursion] +@c new +William Clinger. +@pindex propertailrecursion +Proper Tail Recursion and Space Efficiency. +Zu erscheinen in @emph{Proceedings of the 1998 ACM Conference on Programming + Language Design and Implementation}, Juni 1998. + +@item [syntacticabstraction] +@pindex syntacticabstraction +R. Kent Dybvig, Robert Hieb und Carl Bruggeman. +Syntactic abstraction in Scheme. +@emph{Lisp and Symbolic Computation} 5(4):295--326, 1993. + +@item [Scheme311] +@pindex Scheme311 +Carol Fessenden, William Clinger, Daniel P. Friedman und Christopher Haynes. +Scheme 311 version 4 reference manual. +Indiana University Computer Science Technical Report 137, Februar 1983. +Abgelöst von [Scheme84]. + +@item [Scheme84] +@pindex Scheme84 +D. Friedman, C. Haynes, E. Kohlbecker und M. Wand. +Scheme 84 interim reference manual. +Indiana University Computer Science Technical Report 153, Januar 1985. + +@item [IEEE] +@pindex IEEE +@emph{IEEE Standard 754-1985. IEEE Standard for Binary Floating-Point +Arithmetic.} IEEE, New York, 1985. + +@item [IEEEScheme] +@pindex IEEEScheme +@emph{IEEE Standard 1178-1990. IEEE Standard for the Scheme + Programming Language.} IEEE, New York, 1991. + +@item [Kohlbecker86] +@pindex Kohlbecker86 +Eugene E. Kohlbecker Jr. +@emph{Syntactic Extensions in the Programming Language Lisp.} +Doktorarbeit (PhD), Indiana University, August 1986. + +@item [hygienic] +@pindex hygienic +Eugene E. Kohlbecker Jr., Daniel P. Friedman, Matthias Felleisen und Bruce Duba. +Hygienic macro expansion. +In @emph{Proceedings of the 1986 ACM Conference on Lisp + and Functional Programming}, Seiten 151--161. + +@item [Landin65] +@pindex Landin65 +Peter Landin. +A correspondence between Algol 60 and Church's lambda notation: Part I. +@emph{Communications of the ACM} 8(2):89--101, Februar 1965. + +@item [MITScheme] +@pindex MITScheme +MIT Department of Electrical Engineering and Computer Science. +Scheme manual, seventh edition. +September 1984. + +@item [Naur63] +@pindex Naur63 +Peter Naur et al. +Revised report on the algorithmic language Algol 60. +@emph{Communications of the ACM} 6(1):1--17, Januar 1963. + +@item [Penfield81] +@pindex Penfield81 +Paul Penfield, Jr. +Principal values and branch cuts in complex APL. +In @emph{APL '81 Conference Proceedings,} Seiten 248--256. +ACM SIGAPL, San Francisco, September 1981. +Sammelband veröffentlicht als @emph{APL Quote Quad} 12(1), ACM, September 1981. + +@item [Pitman83] +@pindex Pitman83 +Kent M. Pitman. +The revised MacLisp manual (Saturday evening edition). +MIT Laboratory for Computer Science Technical Report 295, Mai 1983. + +@item [Rees82] +@pindex Rees82 +Jonathan A. Rees und Norman I. Adams IV. +T: A dialect of Lisp or, lambda: The ultimate software tool. +In @emph{Conference Record of the 1982 ACM Symposium on Lisp and + Functional Programming}, Seiten 114--122. + +@item [Rees84] +@pindex Rees84 +Jonathan A. Rees, Norman I. Adams IV und James R. Meehan. +The T manual, fourth edition. +Yale University Computer Science Department, Januar 1984. + +@item [R3RS] +@pindex R3RS +Jonathan Rees und William Clinger, editors. +The revised^3 report on the algorithmic language Scheme. +In @emph{ACM SIGPLAN Notices} 21(12), Seiten 37--79, Dezember 1986. + +@item [Reynolds72] +@pindex Reynolds72 +John Reynolds. +Definitional interpreters for higher order programming languages. +In @emph{ACM Conference Proceedings}, Seiten 717--740. +ACM, +@ignore todo +month? +@end ignore + 1972. + +@item [Scheme78] +@pindex Scheme78 +Guy Lewis Steele Jr. und Gerald Jay Sussman. +The revised report on Scheme, a dialect of Lisp. +MIT Artificial Intelligence Memo 452, Januar 1978. + +@item [Rabbit] +@pindex Rabbit +Guy Lewis Steele Jr. +Rabbit: a compiler for Scheme. +MIT Artificial Intelligence Laboratory Technical Report 474, Mai 1978. + +@item [CLtL] +@pindex CLtL +Guy Lewis Steele Jr. +@emph{Common Lisp: The Language, second edition.} +Digital Press, Burlington MA, 1990. + +@item [Scheme75] +@pindex Scheme75 +Gerald Jay Sussman und Guy Lewis Steele Jr. +Scheme: an interpreter for extended lambda calculus. +MIT Artificial Intelligence Memo 349, Dezember 1975. + +@item [Stoy77] +@pindex Stoy77 +Joseph E. Stoy. +@emph{Denotational Semantics: The Scott-Strachey Approach to + Programming Language Theory.} +MIT Press, Cambridge, 1977. + +@item [TImanual85] +@pindex TImanual85 +Texas Instruments, Inc. +TI Scheme Language Reference Manual. +Preliminary version 1.0, November 1985. + +@end itemize + + + + +@page + + +@c Adjustment to avoid having the last index entry on a page by itself. +@c \addtolength{\baselineskip}{-0.1pt} + +@node Register, , Bibliographie, top +@unnumbered Alphabetisches Register der Definitionen von Konzepten, Schlüsselwörtern und Prozeduren + + + +Der Haupteintrag für jeden Begriff, jede Prozedur bzw. jedes +Schlüsselwort wird zuerst aufgeführt, von den anderen Einträgen +getrennt. + +@sp 6 + +@unnumberedsec Konzepte +@printindex cp +@page +@unnumberedsec Prozeduren +@printindex fn + +@ifinfo +@unnumberedsec Referenzen +@printindex pg +@end ifinfo + + +@contents +@bye diff --git a/doc/translation-rationale-de b/doc/translation-rationale-de new file mode 100644 index 000000000..79274a957 --- /dev/null +++ b/doc/translation-rationale-de @@ -0,0 +1,263 @@ +The German translation of .texi files is contained in files ending in +.de.texi. An attempt is made to ensure the German translation of +Scheme-specific terms is close to the English term such that German +readers are more likely to understand English error messages and +discussions. Translations follow official new German orthography +because people expect it. Generic masculine form is used for plural +forms (e.g. “students” becomes “Studenten”, “researchers” becomes +“Forscher”) when alternatives that do not generalize the male form are +cumbersome. For singular forms (“user”) the female translation is +preferred (“Nutzerin”). Common variable names (e.g. “char”, “string”, +“tail”) are not translated. For R5RS, which is not case-sensitive, +variable names are capitalized as nouns, but not within code. + +TODO: @samp and other Texinfo constructs do not yet use German +punctuation. @node uses semicolons in place of commas. + +The following mapping was used for translations. German Wikipedia was +frequently consulted for building the mapping. + +absolute value => Absolutbetrag +actor => Akteur +allocation => Zuteilung +alphabetic character => Buchstabenzeichen +alternate [of a logical + implication] => Alternative +appear => vorkommen +approximation => Annäherung +association list => assoziative ListeT +at sign => At-Zeichen (rather than “Klammeraffe” or + other colloquial terms) +backquote => Backquote (there is no common German term) +backslash => Backslash (there is no common German term) +backtracking => Rücksetzverfahren (also mention the more + common English term!) +binding => Bindung +block structure => Blockstruktur +body => Rumpf +boundary condition => Randbedingung +brace => geschweifte Klammer +bracket => eckige Klammer +branch cut [of a complex + function] => Verzweigungsschnitt +call by name => als Namensparameter +call by need => als Bedarfsparameter +call by value => als Wertparameter +carriage return => Wagenrücklauf +category => Kategorie +character => Zeichen +clause [as in logic] => Klausel +coerce => aufzwingen +combination [procedure + call] => Kombination +command => Befehl +comment => Kommentar +compiler => Übersetzer +component => Bestandteil +computer => Rechner +consequent => Folgerung +consistent => widerspruchsfrei, im Einklang, + konsistent, … +constant => Konstante (declined as an adjective, i.e. + plural form is “zwei Konstante”, because it + is more logical than “zwei Konstanten”) +construct => Konstrukt +consumer [opposite of + producer] => Konsument +contagious => ansteckend +continuation => Fortsetzung +control flow => Programmfluss (instead of alternative + Kontrollfluss, because it seems easier to + comprehend) +coroutine => Ko-Routine +datum => Datenelement +definition => Definition +delayed evaluation => verzögerte Auswertung +denotational semantics => denotationelle Semantik +derive => ableiten (rather than “herleiten”) +dimension of type => Größendimension (in analogy to dimensions + in physics, which I suppose is meant by + ) +disjointness of types => Typfremdheit +domain [mathematical + concept] => Definitionsbereich, Definitionsmenge +dotted pair => gepunktetes Paar +dynamic extent => dynamischer Bereich +dynamically typed => dynamisch typisiert +effect => Wirkung, Auswirkung +entry [of the manual] => Eintrag +enumerate => aufzählen +environment => Umgebung +equivalent [math] => äquivalent +equivalent [sense of eqv?] => gleichwertig (this puts more emphasis on + the difference between eq? and eqv? and + math than “äquivalent”) +error situation => Fehlersituation +escape [of a character] => maskieren +escape procedure => Ausstiegsprozedur (because it is easier to + understand than Fluchtprozedur) +evaluation => Auswertung +exact [of numbers] => exakt +exclusive [of an interval] => nicht einschließlich +expand [of a macro] => umschreiben (like “rewrite”, “transcribe”) +expression => Ausdruck +extension => Erweiterung +extent [where an object is + alive] => Gültigkeitsbereich +external representation => externe Darstellung (rather than + “Darstellung nach Außen” because “extern” + is closer to the English term, also rather + than “externe Repräsentation” because + “Darstellung” seems like the more usual + term in non-scientific circles) +feature => Funktionalität +field [of a record] => Komponente +fix point => Festkomma +fixnum => Festkommazahl +floating point => Gleitkomma +flonum => Gleitkommazahl +force [a promise] => erzwingen +form feed => Seitenvorschub +formals => Formale +hygienic => hygienisch +identifier => Bezeichner +inclusive [of an interval] => einschließlich +index [list of terms] => Register +index [position] => Index (plural “Indizes”) +input => Eingabe +integer => ganze Zahl +interned symbol => interniertes Symbol +interpreter => Interpreter (at first glance) +iteration => Iteration +keyword => Schlüsselwort +latent type => latenter Typ +lazy evaluation => verzögerte Auswertung (same as “delayed + evaluation”) +level => Stufe +lexical conventions => Schreibkonventionen +lexical environment => lexikalische Umgebung +lexicographic => alphabetisch (this translation is not + always correct but it is correct and more + common for the usages in the R5RS) +library => Bibliothek +line feed => Zeilenvorschub (not “Zeilenumbruch”, mind + the difference) +list => Liste +literal [kind of constant] => Literal +location => Stelle +loop => Schleife +lower case => Kleinschreibung +lowest terms [of a + fraction] => unkürzbar +machine word => Maschinenwort +macro => Makro +manifest type => ausdrücklicher Typ +memory => Speicher +message passing style => nachrichtenübermittelnder Stil +mutate => verändern (rather than “mutieren”, which + is not usually understood correctly) +mutually recursive => wechselseitig rekursiv +named let => benanntes let (bzw. großgeschrieben “Let” + in R5RS) +newline => Zeilenvorschub +non-local exit => nicht-lokaler Sprung (alternatively + “Sprung heraus” or perhaps “Ausstieg”, + depending on context) +notation => Notation +note => Anmerkung +optional => optional +output => Ausgabe +parenthesis => (runde) Klammer +parse => aufgliedern, verstehen, umwandeln, + verarbeiten, analysieren (as appropriate) +pattern => Muster +polar [coordinates] => polar +port => Port (rather than e.g. “Buchse”, because + “Port” is closer to the English term) +portable => portabel +precision => Genauigkeit +predicate => Prädikat +primitive => Grundbaustein +procedure => Prozedur +proceedings [scientific + publication] => Sammelband +producer [opposite of + consumer] => Produzent +promise => Versprechen +proper [mathematical + concept] => echt +quote => maskieren (see “escape”) +radix => Radix (“die Radix” rather than “Basis”) +range => Bereich, Wertebereich (note similarity to + “scope” and to “extent”) +rational number => rationale Zahl (rather than “Bruchzahl”) +rationale => Begründung +read-only memory => Nur-Lese-Speicher (instead of + “schreibgeschützter Speicher”, because it + is closer to the original wording) +record => Verbund +rectangular [complex + number] => kartesisch +reference [bibliography] => Verweis +reference [naming a value] => Referenz +region [of a binding] => Region +report [of a Scheme +standards document] => Bericht +report [to signal sth] => melden +representation => Darstellung +restriction => Einschränkung +result => Ergebnis +return [of a function] => einen Wert zurückgeben (since Scheme never + returns without a return value, this + translation can always be used), einen + Rücksprung durchführen +rewrite => umschreiben (same as “expand”, + “transcribe”) +rule => Regel +scope => Sichtbarkeitsbereich +sequencing [of operations] => Sequenzierung +shadow [another variable] => überschatten +side effect => Wirkung (rather than “Nebeneffekt”) +signal [an error] => signalisieren +slashification => Slashifizierung +space character => Leerzeichen +splice => spleißen (rather use the not so common + German term instead of the not so common + English term) +state => Zustand +storage => Speicher +stream => Strom +string => Zeichenkette (the term “String” is + mentioned but not preferred within the + text) +strip [remove] => wegnehmen +symbol => Symbol +syntactic sugar => syntaktischer Zucker +tab => Tabulatorzeichen +tag [of a procedure + location] => Beschriftung +tail call => endständiger Aufruf +tail context => endständig +tail recursion => Endrekursion +template => Schablone +test [verb] => prüfen +Test [as an identifier] => Test (because it is easier to understand + compared to “Prüfung”) +token => Token (rather than “Marke”) +top level => oberste Ebene +transcribe [of macros] => umschreiben (same as “rewrite”, “expand”) +transcript [for logging] => Abschrift +transformer [of macros] => Umwandler +type => Typ (genitive “des Typs”) +uninterned symbol => nicht interniertes Symbol +unquote => demaskieren (see “quote”) +unspecified => unbestimmt +upper case => Großschreibung +value => Wert +variable => Variable (declined as an adjective, see + “constant”) +vector => Vektor +violation => Verletzung +whitespace => Leerraum +write [of the ‘write’ + Scheme procedure] => schreiben |