imported>Neubadener: Vereinheitliche Großschreibung vom Namen „Lisp“ (keine Abkürzung im üblichen Sinne)

2025-07-13T21:12:39Z

Vereinheitliche Großschreibung vom Namen „Lisp“ (keine Abkürzung im üblichen Sinne)

Neue Seite

{{Dieser Artikel|behandelt die Programmiersprache. Für die Bedeutung des alemannischen Wortes Scheme für Maske siehe [[Larve (Maske)]].}}

{{Infobox Programmiersprache
| Name = Scheme
| Logo = [[Datei:Lambda lc.svg|100px|Logo]]
| Paradigma = [[Programmierparadigma|Multi-Paradigma]]: [[Funktionale Programmierung|funktional]], [[Prozedurale Programmierung|prozedural]], [[Metaprogrammierung|meta]]
| Erscheinungsjahr = 1975
| Entwickler = [[Guy L. Steele]] und [[Gerald Jay Sussman]]
| AktuelleVersion = R7RS (ratified standard)
| AktuelleVersionFreigabeDatum = 2013
| Typisierung = [[Starke Typisierung|stark]], [[Dynamische Typisierung|dynamisch]]
| Implementierung = viele z. B. MIT/GNU Scheme
| Beeinflusst_von = [[Lisp]], [[ALGOL]], [[MDL (Programmiersprache)|MDL]]
| Beeinflusste = [[Common Lisp]], [[JavaScript]], [[R (Programmiersprache)|R]], [[Ruby (Programmiersprache)|Ruby]], [[Dylan (Programmiersprache)|Dylan]], [[Lua]], [[Racket (Programmiersprache)|Racket]], [[Snap! (Programmiersprache)|Snap! / BYOB]]
}}

Die [[Programmiersprache]] '''Scheme''' ist eine [[Lisp]]-Variante.
Sie ist [[Funktionale Programmierung|funktional]], unterstützt jedoch auch andere [[Programmierparadigma|Programmierparadigmen]] (z. B. [[imperative Programmierung]]).

Scheme zeichnet sich dadurch aus, dass nur wenige Programmierkonzepte durch die [[Syntax]] vorgegeben sind.
In Scheme gibt es daher mehr Möglichkeiten ein Programm zu beschreiben als in vielen anderen Programmiersprachen.

Beispielsweise gibt es im Scheme-Standard keine Hilfsmittel zur objektorientierten Programmierung; solche können aber mittels [[Makro]]s und [[Lambda-Ausdruck|λ-Ausdrücken]] in Scheme programmiert und zur objektorientierten Programmierung in Scheme verwendet werden:
Scheme ist eine programmierbare Programmiersprache.

Entwickelt wurde Scheme von [[Gerald Jay Sussman]] und [[Guy Lewis Steele Jr.]] am [[Massachusetts Institute of Technology]], wo auch die formale [[Spezifikation]] zur Verfügung steht, der sogenannte [[The Revised Report on the Algorithmic Language Scheme|Revised Report]]. Die derzeit aktuelle Spezifikation ist R7RS.<ref>[http://www.scheme-reports.org/2015/working-group-1.html Seite des Standards R7RS]</ref>

== Syntax und Semantik ==
Die [[Syntax]] von Scheme ist sehr regelmäßig und einfach. Grundlage ist eine vollständig geklammerte Präfix-Notation (siehe auch [[Polnische Notation]]). Ein Programm besteht aus [[Ausdruck (Programmierung)|Ausdrücken]] und Definitionen. Ausdrücke sind entweder [[Literal#Literale in Programmiersprachen|Literale]] oder ''zusammengesetzte Ausdrücke'', die einen Funktionsaufruf darstellen:
<syntaxhighlight lang="scheme">
(operator operand-1 operand-2 ... operand-n)
</syntaxhighlight>
Jedes Element eines zusammengesetzten Ausdrucks ist wieder ein Ausdruck.

Die Bedeutung (oder Semantik) von Ausdrücken ist über ihre [[Auswertung (Informatik)|Auswertung]] definiert.
Die Bedeutung (Semantik) eines literalen Ausdrucks ist der konstante Wert des Ausdrucks. Zum Beispiel hat die Zeichenfolge <syntaxhighlight lang="scheme" inline>2</syntaxhighlight> den Wert der Zahl 2 und die Zeichenfolge <syntaxhighlight lang="scheme" inline>#t</syntaxhighlight> hat den booleschen [[Wahrheitswert]] für „wahr“.
Bei der Auswertung zusammengesetzter Ausdrücke muss der Ausdruck <code>operator</code> (in Anlehnung an mathematische [[Operator (Mathematik)|Operatoren]]) zu einer Funktion auswerten. Rechts des Operators stehen beliebig viele [[Ausdruck (Programmierung)|Operanden]], die wiederum einfache oder zusammengesetzte Formen sind.

Die Klammern sind damit von besonderer Bedeutung und können im Gegensatz zu den meisten anderen [[Programmiersprache]]n nicht beliebig gesetzt werden. Die zusammengesetzte Form
<syntaxhighlight lang="scheme">
(foo 42)
</syntaxhighlight>
etwa ist ein Ausdruck, der auf semantischer Ebene den Aufruf der an die Variable <code>foo</code> gebundenen Funktion mit dem Argument <code>42</code> bedeutet. Die Auswertung des Ausdrucks
<syntaxhighlight lang="scheme">
(foo (42))
</syntaxhighlight>
dagegen führt zu einem Fehler zur Laufzeit: Bei <code>(42)</code> handelt es sich um eine zusammengesetzte Form und die Semantik sieht die Anwendung des Operators vor. Da <code>42</code> allerdings eine Zahl und keine Funktion ist, kommt es zu einem Fehler.

Ein Vorteil der vollständig geklammerten Präfix-Notation besteht darin, dass diese Notation nur mit einer einzigen [[Operatorrangfolge|Präzedenz]] für alle [[Operator (Mathematik)|Operatoren]] auskommt. Eine gängige Kritik an der [[Syntax]] von Scheme bezieht sich auf die hohe Zahl der Klammern, die die Erstellung und Bearbeitung des Quelltextes erschweren. Scheme-Programmierer begegnen dieser Schwierigkeit, indem sie [[Editor (Software)|Editoren]] verwenden, die die Bearbeitung von Scheme-Quelltexten in besonderer Weise unterstützen (zum Beispiel [[Emacs]]). Zu diesen Hilfen zählen die automatische Einrückung des Codes und die Markierung zusammengehöriger Klammerpaare während des Editierens.

Einige Scheme-Implementierungen, wie zum Beispiel Racket, erlauben abweichend vom Sprachstandard zusätzlich die Verwendung von eckigen Klammern. Dadurch soll die Übersichtlichkeit erhöht werden. Beispiel:
<syntaxhighlight lang="scheme">
(let ([x 42]
[y 23])
(+ x y))
</syntaxhighlight>

== Spezialform Lambda ==
Das Schlüsselwort ''lambda'' leitet die Spezialform für sogenannte Lambda-Ausdrücke ein. Ein Lambda-Ausdruck wertet zu einer Prozedur aus, die in Scheme ein Wert erster Klasse ist. Prozeduren können damit wie Werte anderer Typen im Programm verwendet werden, also etwa an Namen gebunden werden, als Argumente bei einem Prozeduraufruf übergeben werden oder von einer Prozedur zurückgegeben werden.

Definition der Spezialform lambda:

''(lambda (argument) expression)''

<syntaxhighlight lang="scheme">
(lambda (x) (* x x)) ; Bildet das Quadrat von x
</syntaxhighlight>
Aufruf der vom obigen Lambda-Ausdruck erzeugten Prozedur:

<syntaxhighlight lang="scheme">
((lambda(x) (* x x)) 5) ; Bildet das Quadrat von 5
; (Rückgabe = 25)
</syntaxhighlight>

Der Name dieser Spezialform geht auf den [[Lambda-Kalkül]] zurück.

== Globale Definitionen ==
Eine Definition mit dem Schlüsselwort <code>define</code> bindet einen Wert an einen Namen. Der Name ist global gebunden, kann also an einer beliebigen Stelle im Programm nach der Definition verwendet werden. Da Prozeduren in Scheme ebenfalls Werte sind, können mit <code>define</code> auch globale Prozeduren definiert werden. Im folgenden Code-Abschnitt wird der Name <code>a-number</code> an die Zahl 42 gebunden und anschließend der Name <code>square</code> an eine Funktion, die eine Zahl quadriert:
<syntaxhighlight lang="scheme">
(define a-number 42)

(define square
(lambda (x)
(* x x)))
</syntaxhighlight>

Zur Definition globaler Prozeduren kann auch eine vereinfachte Notation verwendet werden, bei der der <code>lambda</code>-Ausdruck weggelassen wird. Obige Definition von <code>square</code> kann in abgekürzter Form wie folgt geschrieben werden:
<syntaxhighlight lang="scheme">
(define (square x)
(* x x))
</syntaxhighlight>

Ein Beispiel dafür, dass eine Funktion eine andere Funktion zurückgeben kann, liefert folgender Ausdruck:

<syntaxhighlight lang="scheme">
(define (sum-with x)
(lambda (y) (+ y x)))
</syntaxhighlight>
Der Parameter x der Funktion sum-with bestimmt, wie sich die zurückgegebene Funktion verhält: Die zurückgegebene Funktion addiert ein Argument y genau um den in sum-with angegebenen Faktor x.

<syntaxhighlight lang="scheme">
((sum-with 5) 1)
; Ergebnis: 6
</syntaxhighlight>

== Lokale Bindungen ==
Die [[Deklaration (Programmierung)|Variablen- und Funktionsdeklaration]] gestaltet sich in Scheme etwas anders als in konventionellen Programmiersprachen. Zum einen müssen Variablen und Funktionen (Prozeduren) ''nicht'' an [[Bezeichner]] gebunden werden, zum anderen geschieht die Deklaration über Prozeduren, es gibt keine gesonderten Schlüsselwörter.

Zur Deklaration stehen die Formen '''define''' und '''let''' zur Verfügung, je nach Bedarf können anstelle von '''let''' auch die Variationen '''let*''' und '''letrec''' verwendet werden.

=== let ===
<code>let</code> bindet mehrere Werte an die angegebenen Bezeichner. Diese Bindungen sind nur innerhalb des Rumpfes von <code>let</code> sichtbar. <code>let</code> hat die folgende Syntax:
<syntaxhighlight lang="scheme">
(let ((name-1 ''ausdruck-1'')
(name-2 ''ausdruck-2'')
...
(name-n ''ausdruck-n''))
...
; Rumpf des let-Ausdrucks
; name-1, ..., name-n sind nur innerhalb des Rumpfes von '''let''' gebunden
...
)
</syntaxhighlight>

Die Ausdrücke <code>ausdruck-1</code> bis <code>ausdruck-n</code> werden in einer nicht spezifizierten Reihenfolge ausgewertet, bevor die resultierenden Werte an die jeweiligen Namen gebunden werden. Danach wird der Rumpf des <code>let</code>-Ausdrucks ausgewertet. Erst im Rumpf gelten die Bindungen <code>name-1</code> bis <code>name-n</code>. Es ist insbesondere mit <code>let</code> nicht möglich, im Ausdruck <code>ausdruck-''i''</code> auf einen anderen Namen zuzugreifen, der im selben <code>let</code>-Ausdruck gebunden wird (vgl. <code>let*</code>).

Der Wert des letzten Ausdrucks im Rumpf ergibt den Wert des gesamten <code>let</code>-Ausdrucks. Da die Auswertungsreihenfolge der Ausdrücke <code>ausdruck-''i''</code> nicht festgelegt ist und theoretisch sogar alle Ausdrücke zeitgleich ausgewertet werden dürfen, spricht man auch von einem ''parallelen <code>let</code>''.

Beispiele:
<syntaxhighlight lang="scheme">
(let ((a 3)
(b (+ 10 12))
(c (lambda (n) (* n 2))))
(c (+ a b)))
=> 50

(let ((a 1))
(let ((a 0)
(b a))
b))
=> 1
</syntaxhighlight>

<code>let</code> ist eine vereinfachte Syntax, die in einen Funktionsaufruf übersetzt wird. Beispiel:
<syntaxhighlight lang="scheme">
(let ((a (+ 1 1)) (b (+ 2 2)))
(+ a b))
</syntaxhighlight>

expandiert zu:
<syntaxhighlight lang="scheme">
((lambda (a b) (+ a b)) (+ 1 1) (+ 2 2))
</syntaxhighlight>

=== let* ===
<code>let*</code> hat dieselbe Syntax wie <code>let</code> und eine ähnliche Semantik. Im Unterschied zu <code>let</code> ist bei <code>let*</code> die Reihenfolge, in der die Ausdrücke in den Name-Ausdruck-Paaren ausgewertet werden, festgelegt: Die Auswertung erfolgt von links nach rechts. Man spricht daher auch von einem ''sequentiellen <code>let*</code>''. Im Unterschied zu <code>let</code> kann in den Ausdrücken (rechte Seiten der Name-Ausdruck-Paare) auf die Namen der weiter links stehenden Bindungspaare zugegriffen werden.

Beispiel:
<syntaxhighlight lang="scheme">
(let ((a 1))
(let* ((a 0)
(b a))
b))
=> 0
</syntaxhighlight>

Wie <code>let</code> ist auch <code>let*</code> eine vereinfachte Syntax und wird in verschachtelte Funktionsaufrufe übersetzt:
<syntaxhighlight lang="scheme">
(let* ((a (+ 1 1))
(b (+ a 1)))
(* a b))
</syntaxhighlight>

expandiert zu:
<syntaxhighlight lang="scheme">
((lambda (a)
((lambda (b) (* a b)) (+ a 1)))
(+ 1 1))
</syntaxhighlight>

=== letrec und named let ===
<code>letrec</code>-Ausdrücke haben dieselbe Syntax wie <code>let</code>-Ausdrücke. Hinsichtlich der Sichtbarkeit der zu bindenden Namen gibt es jedoch einige Unterschiede. Die Namen (also die linken Seiten der Bindungspaare) können in jedem Ausdruck der Bindungspaare verwendet werden. Die vom <code>let*</code> her bekannte Einschränkung, dass sich die Namen in einem Ausdruck nur auf vorhergehende (also weiter links stehende) Namen beziehen können, fällt also weg. Insbesondere kann <code>letrec</code> zur Definition von lokalen rekursiven Funktionen verwendet werden. Beispiel:
<syntaxhighlight lang="scheme">
(letrec ((sum (lambda (lst s)
(if (null? lst)
s
(sum (cdr lst) (+ s (car lst)))))))
(sum (list 1 2 3) 0))
=> 6
</syntaxhighlight>

Es können auch wechselseitig rekursive Funktionen definiert werden:
<syntaxhighlight lang="scheme">
(letrec ((even? (lambda (n)
(if (zero? n)
#t
(odd? (- n 1)))))
(odd? (lambda (n)
(if (zero? n)
#f
(even? (- n 1))))))
(even? 42))
=> #t
</syntaxhighlight>

Eine Variante von <code>letrec</code> ist das sogenannte ''named <code>let</code>'', das besonders zur Programmierung von Schleifen verwendet wird. Die Syntax ist
<syntaxhighlight lang="scheme">
(let ''name'' (''bindungen'') ''rumpf'')
</syntaxhighlight>

, wobei <code>bindungen</code> die vom <code>let</code> her bekannten Paare aus Name und Ausdruck sind. Der Rumpf des ''named <code>let</code>'' wird als Rumpf einer Prozedur mit dem Namen <code>name</code> verwendet, die genau so viele Argumente hat wie Bindungspaare angegeben wurden. Das ''named <code>let</code>'' ist ein Makro, welches in den Aufruf dieser Prozedur <code>name</code> expandiert. Als Argumente werden die rechten Seiten der Bindungspaare verwendet. Das Beispiel für <code>letrec</code> kann mit einem ''named <code>let</code>'' folgendermaßen geschrieben werden:
<syntaxhighlight lang="scheme">
(let sum ((lst (list 1 2 3))
(s 0))
(if (null? lst)
s
(sum (cdr lst) (+ s (car lst)))))
</syntaxhighlight>

=== define ===
<code>define</code> wird meist benutzt, um auf globaler Ebene Funktionen und Konstanten zu deklarieren, aber es ist auch innerhalb des Rumpfes von Prozeduren verwendbar. Die Sichtbarkeit der so gebundenen Variablen beschränkt sich auf den Rumpf, in dem die Definition steht. <code>define</code>, die nicht auf globaler Ebene stehen, werden ''interne Definitionen'' genannt und gelegentlich der besseren Lesbarkeit wegen anstatt eines <code>letrec</code> verwendet.

Die Syntax ist:
<syntaxhighlight lang="scheme">
(define bezeichner ausdruck)
</syntaxhighlight>

Der Ausdruck darf sich auch rekursiv auf ''bezeichner'' beziehen.

In diesem Beispiel werden <code>foo</code> und <code>bar</code> intern definiert. Beide Variablen sind nur innerhalb des Rumpfes des <code>let</code>-Ausdrucks sichtbar.
<syntaxhighlight lang="scheme">
(let ((x 5))

(define (foo y)
(bar x y))

(define (bar a b)
(+ (* a b) a))

(foo (+ x 3)))
</syntaxhighlight>

Obiger Code entspricht dieser Version mit <code>letrec</code>:
<syntaxhighlight lang="scheme">
(let ((x 5))
(letrec ((foo (lambda (y) (bar x y)))
(bar (lambda (a b) (+ (* a b) a))))
(foo (+ x 3))))
</syntaxhighlight>

== Datentypen ==
=== Prozeduren ===
Prozeduren gehören zu den wichtigsten Sprachelementen von Scheme. Sie können mit einem [[Lambda-Ausdruck]] ('''lambda''') beschrieben werden. Da sie in Scheme wie jeder andere Datentyp behandelt werden, ist es möglich, sie mit '''let''' oder '''define''' an einen [[Bezeichner]] zu binden.

Beispiel: Eine Prozedur mit zwei Argumenten:
<syntaxhighlight lang="scheme">
(define test
(lambda (arg1 arg2)
... ))
</syntaxhighlight>

Es gibt eine vereinfachte Notation, mit der der '''define'''- und der '''lambda'''-Ausdruck zusammengefasst werden können:
<syntaxhighlight lang="scheme">
(define (test arg1 arg2)
...)
</syntaxhighlight>

Aufgerufen wird diese Prozedur wie folgt:
<syntaxhighlight lang="scheme">
(test wert1 wert2)
</syntaxhighlight>

Prozeduraufrufe müssen generell mit zwei Klammern eingeschlossen werden. Scheme betont die Rolle von Ausdrücken, die einen Wert haben, gegenüber Befehlen, die etwas tun. Deswegen ist es – im Gegensatz zu vielen anderen Sprachen – nicht nötig, den Ausdruck im Körper der Prozedurbeschreibung als Rückgabewert zu markieren. Im Gegenteil: Es sind besondere Konstrukte wie ''begin'' nötig, um Anweisungen ohne Rückgabe ihres Wertes auszuführen.

Natürlich gibt es eine Reihe von vordefinierten Prozeduren wie ''cons'', ''car'', ''cdr'', ''+'', ''-'', ''*'', ''<''. Diese vordefinierten Prozeduren können neu definiert werden, wie folgendes Beispiel zeigt:
<syntaxhighlight lang="scheme">
(define (+ x y)
(- x y))
</syntaxhighlight>

''+'' würde jetzt nicht addieren, sondern subtrahieren.

Dadurch, dass die mathematischen Operatoren ebenfalls durch Prozeduren realisiert sind, ergibt sich für Berechnungen eine [[Präfixnotation]]. Scheme kennt keine Operatorhierarchie, alle Formeln sind eindeutig.

=== Paare und Listen ===
[[Liste (Datenstruktur)|Listen]] werden in Scheme-Programmen relativ häufig gebraucht. Wichtigster Baustein für Listen in Scheme sind ''Paare''. Ein Paar ist eine Datenstruktur, die zwei beliebige Scheme-Werte enthält. Mit <code>cons</code> wird ein neues Paar erzeugt. Beispiel:
<syntaxhighlight lang="scheme">
(cons 'sinn 42)
</syntaxhighlight>

Dieser Aufruf von <code>cons</code> erzeugt ein neues Paar, dessen erstes Feld das [[Symbol (Informatik)|Symbol]] <code>'sinn</code> enthält und dessen zweites Feld die Zahl 42. Auf das erste Feld eines Paares kann mit der eingebauten Funktion <code>car</code> (sprich: „carr“) zugegriffen werden, auf das zweite Feld mit <code>cdr</code> (sprich: „kudder“). Die Namen <code>car</code> („''c''ontent of ''a''ddress ''r''egister“) und <code>cdr</code> („''c''ontent of ''d''ecrement ''r''egister“) sind historisch begründet, haben sich aber so erhalten. Sie beziehen sich auf Operationen, die seinerzeit bei der ersten [[Lisp]]-Implementation auf der [[IBM 704]] benutzt wurden. Die eingebauten Funktionen <code>set-car!</code> und <code>set-cdr!</code> setzen die Werte der entsprechenden Felder eines Paares auf einen neuen Wert. Das Typ-Prädikat <code>pair?</code> gibt genau dann <code>#t</code> (für wahr) zurück, wenn es auf ein Paar, also einen mit <code>cons</code> erzeugten Wert angewendet wurde.

Die Definition von Listen ist [[Vollständige Induktion|induktiv]]: Die leere Liste, geschrieben <code>'()</code>, ist eine Liste. Außerdem ist ein Paar, dessen <code>cdr</code> eine Liste ist, eine Liste. Durch die Definition ergibt sich, dass eine Liste aus Paaren besteht: Im <code>car</code>-Feld eines Paares steht ein beliebiger Wert, im <code>cdr</code>-Feld das Paar, das das nächste Listenelement enthält. Das Ende der Liste ist erreicht, wenn im <code>cdr</code>-Feld die leere Liste zu finden ist, was sich mit der eingebauten Funktion <code>null?</code> überprüfen lässt. Beispiele für Listen:
<syntaxhighlight lang="scheme">
'()
(cons 1 '())
(cons 1 (cons 2 '()))
</syntaxhighlight>

Für die Erzeugung von Listen gibt es außerdem noch die komfortable Funktion <code>list</code>, die eine beliebige Anzahl von Argumenten nimmt und diese als Liste zurückgibt. Die folgenden beiden Listen sind äquivalent:
<syntaxhighlight lang="scheme">
(list 1 2 3)
(cons 1 (cons 2 (cons 3 '())))
</syntaxhighlight>

Funktionen, die Listen verarbeiten, sind meist rekursive Funktionen. Mit dieser Funktion lässt sich zum Beispiel die Länge einer Liste bestimmen:
<syntaxhighlight lang="scheme">
(define (length lst)
(if (null? lst)
0
(+ 1 (length (cdr lst)))))
</syntaxhighlight>

Scheme-Programmierer machen von der Möglichkeit, die Felder eines Paares mit <code>set-car!</code> oder <code>set-cdr!</code> zu ändern, fast nie Gebrauch. Die Verarbeitung von Listen erfolgt fast immer rein [[Funktionale Programmiersprache|funktional]], d. h. aus Listen werden neue Listen erzeugt. Ein Beispiel ist diese Funktion <code>map</code>, die eine Funktion <code>f</code> auf alle Elemente einer Liste anwendet:
<syntaxhighlight lang="scheme">
(define (map f lst)
(if (null? lst)
'()
(cons (f (car lst)) (map f (cdr lst)))))
</syntaxhighlight>

=== Weitere Datentypen ===
Weitere Datentypen sind unter anderem:
* integer (ganze Zahlen, beliebige Stellenzahl)
* rational (Brüche, beliebige Genauigkeit)
* real ([[Dezimalzahl]]en)
* komplexe Zahlen
* [[Symbol (Informatik)|Symbole]]
* Zeichen
* Strings (Zeichenkette)
* Paare
* Vektoren
* Port (Repräsentation für Eingabe/Ausgabe-Geräte, Dateien etc.)
* Boolean

''wahr'' und ''falsch'' werden durch <code>#t</code> und <code>#f</code> dargestellt, wobei Scheme jedoch nur <code>#f</code> (in veralteten Implementierungen nur ein Synonym für leere Liste <code>'()</code>) als logisch falsch interpretiert; alle anderen Werte gelten als wahr.

== Fallunterscheidung ==
'''If'''

<code>if</code> wertet einen ''Test-Ausdruck'' aus und wertet je nach dessen Wahrheitswert den zweiten Operanden (''Konsequente'') oder den dritten Operanden (''Alternative'') aus. Der Wert des gesamten ''If-Ausdrucks'' ergibt sich aus der Auswertung der Konsequente bzw. Alternative. Nur wenn der Test-Ausdruck den Wert <code>#f</code> hat, wird die Alternative ausgewertet, andernfalls die Konsequente. D. h. jeder Wert außer <code>#f</code> gilt als logisch wahr.

Ein entsprechender Ausdruck sieht zum Beispiel so aus:
<syntaxhighlight lang="scheme">
(if (> x 0)
'positive
'not-positive)
</syntaxhighlight>

Dieser Ausdruck wertet entweder zum Symbol <code>'positive</code> oder zum Symbol <code>'not-positive</code> aus. Da ''If'' ein Ausdruck ist, kann ''If'' innerhalb von Ausdrücken verwendet werden:
<syntaxhighlight lang="scheme">
(* 2 (if (> x max) max x))
</syntaxhighlight>

'''Cond'''

Mit <code>cond</code> ist es möglich, mehrere Fälle zu unterscheiden. Ein ''Fall'' besteht aus einem ''Test'' und einer ''Konsequente''. Die Fälle werden von links nach rechts überprüft. Liefert der Test eines Falles nicht <code>#f</code> zurück, wird die entsprechende Konsequente ausgewertet: Dieser Wert ergibt dann den Wert des gesamten <code>cond</code>-Ausdrucks. Trifft keiner der angegebenen Fälle zu, wird, falls vorhanden, der ''else-Fall'' ausgewertet. Ist kein else-Fall vorhanden, ist der Wert des <code>cond</code>-Ausdrucks nicht definiert. Beispiel:
<syntaxhighlight lang="scheme">
(cond ((= wert 65) 'a)
((= wert 66) 'b)
(else 'unbekannt))
</syntaxhighlight>

== Schleifen ==
Scheme besitzt keinerlei Programmiersprachen-Konstrukte für Schleifen (allerdings wird in den automatisch inkorporierten „Scheme Standard Libraries“ beispielsweise mit dem do-Konstrukt die Möglichkeit von Schleifen angeboten). Schleifen werden in der Regel durch [[Rekursion|rekursive Funktionsaufrufe]] implementiert. Eine [[Endlosschleife (Programmierung)|Endlosschleife]] sieht im einfachsten Fall so aus:
<syntaxhighlight lang="scheme">
(define (loop)
(loop))
</syntaxhighlight>

Ein häufig gezeigtes Beispiel, um dies zu demonstrieren, ist die Berechnung der [[Fakultät (Mathematik)|Fakultät]]:
<syntaxhighlight lang="scheme">
(define (fak n)
(if (= n 0) 1
(* n (fak (- n 1)))))
</syntaxhighlight>

Um dieses theoretisch ansprechende Konzept praktikabel umzusetzen, optimiert Scheme die endstämmige Rekursion (bzw. allgemeiner: alle endstämmigen Funktionsaufrufe). Bei der nicht-endstämmigen [[Rekursion]] leistet die Funktion nach dem Selbstaufruf noch Arbeit. Im Beispiel die Multiplikation:
<syntaxhighlight lang="scheme">
(fak 4)
(* 4 (fak 3))
(* 4 (* 3 (fak 2)))
(* 4 (* 3 (* 2 (fak 1))))
(* 4 (* 3 (* 2 (* 1 (fak 0)))))
(* 4 (* 3 (* 2 (* 1 1))))
(* 4 (* 3 (* 2 1)))
(* 4 (* 3 2))
(* 4 6)
24
</syntaxhighlight>

Hier wird während des Ablaufs zum Speichern der Zwischenergebnisse zunehmend mehr (Speicher-)Platz benötigt. Eine endständige (tail-recursive) Variante des obigen Beispieles wäre:
<syntaxhighlight lang="scheme">
(define (fak-iter n a)
(if (= n 0) a
(fak-iter (- n 1) (* n a))))

(define (fak n)
(fak-iter n 1))
</syntaxhighlight>

Der Ablauf würde dann wie folgt aussehen:
<syntaxhighlight lang="scheme">
(fak 4)
(fak-iter 4 1)
(fak-iter 3 4)
(fak-iter 2 12)
(fak-iter 1 24)
(fak-iter 0 24)
24
</syntaxhighlight>

Scheme erkennt, dass das Ergebnis des Prozeduraufrufs nur noch zurückgegeben wird, und kann somit für alle Prozeduraufrufe denselben Speicherplatz verwenden. Die zusätzliche Variable ''a'' in der Prozedur ''fak-iter'' [[Akkumulator (Computer)|akkumuliert]] die Zwischenergebnisse.

== Kommentare ==
Kommentare werden durch ein [[Semikolon]] (;) eingeleitet und reichen bis zum Zeilenende.

== Vergleich zwischen Scheme und Lisp ==
Drei wesentliche Merkmale unterscheiden Scheme von [[Lisp]]:
* In Scheme gibt es die [[Funktion (Programmierung)|Funktion]] ''call-with-current-continuation''. Sie erlaubt, die gegenwärtige [[Continuation]] (d. h. eine Art Ausführungszustand des laufenden [[Computerprogramm|Programms]]) als [[Variable (Programmierung)|Variable]] zu verwenden. Damit ist es möglich, später im Programmablauf zur Stelle dieser Continuation zurück zu springen.
* Der Scheme-Standard schreibt ''proper tail recursion'' vor: Prozeduraufrufe in einer [[endrekursiv]]en Position dürfen keinen Speicherplatz auf dem [[Aufrufstapel]] des Programms verbrauchen. Das bedeutet, dass eine unbegrenzte Anzahl an endrekursiven Aufrufen einer Prozedur möglich ist.
* Im Gegensatz zu Lisp sind [[Makro]]s in Scheme „hygienisch“: Innerhalb eines Makros eingeführte [[Variable (Programmierung)|Bezeichner]] [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|verdecken]] keine anderen Bezeichner der [[Lexikalische Umgebung|lexikalischen Umgebung]] außerhalb des Makros, also des aufrufenden Programms. Umgekehrt werden innerhalb eines Makros verwendete Bezeichner immer innerhalb der lexikalischen Umgebung des Makros aufgelöst, nicht außerhalb. Das bedeutet, dass die Bezeichner eines Makros nur für das Makro selbst [[Sichtbarkeit (Programmierung)|sichtbar]] sind und das Makro nicht auf Bezeichner des übergeordneten Programms zugreifen kann, sowie dass das Programm nicht auf die internen Bezeichner des Makros zugreifen kann.

== Implementierungen und Entwicklungswerkzeuge ==
Es steht eine große Zahl von Implementierungen der Programmiersprache zur Verfügung.<ref>[http://community.schemewiki.org/?scheme-faq-standards#implementations Liste bekannter Implementierungen]</ref> Im Folgenden werden nur einige populäre Implementierungen erwähnt:
* Bigloo<ref>[http://www-sop.inria.fr/mimosa/fp/Bigloo/ Bigloo-Webseite]</ref> übersetzt Scheme-Code in verschiedene andere Sprachen: [[C (Programmiersprache)|C]], [[Java (Programmiersprache)|Java]] und [[.NET (Oberbegriff)|.NET]].
* [[Chicken (Scheme)|Chicken]] ist eine Implementierung, die Scheme nach C übersetzt und deswegen auf praktisch allen Plattformen läuft. Sie stellt sowohl einen Interpreter als auch einen Compiler zur Verfügung und hat wegen der Anbindung zu C eine umfangreiche Bibliothek an Erweiterungen. Die Implementierung ist weitgehend R5RS-konform.
* Gambit C<ref>[http://www.iro.umontreal.ca/~gambit/ Gambit C-Webseite]</ref> verfügt neben einem Scheme-[[Interpreter]] auch über einen der effizientesten Scheme-zu-C-[[Compiler]].
* Gauche<ref>[http://practical-scheme.net/gauche/ Gauche-Webseite]</ref> ist eine R7RS-konforme Implementierung. Sie ist als Skriptinterpreter für Entwickler und Administratoren konzipiert. Einige der Entwicklungsziele sind eine kurze Startzeit, eine eingebaute Systemschnittstelle, native Mehrsprachenunterstützung. Weiterhin können zahlreiche Erweiterungen eingebunden werden, z. B. für [[OpenGL]] und [[GTK+]].
* [[GNU Guile]] ist ein Interpreter, der als Bibliothek eingebunden werden kann. Ziel ist in erster Linie, Programme leicht um Scripting-Fähigkeiten erweitern zu können.
* LispMe<ref>[http://www.lispme.de/lispme/index_de.html LispMe-Webseite]</ref> ist eine Implementierung für PalmOS-kompatible PDAs.
* Racket<ref>[http://www.racket-lang.org/ Racket-Webseite]</ref> (früher PLT Scheme) ist eine verbreitete Implementierung, die neben einer großen Menge von Bibliotheken eine eigene [[Integrierte Entwicklungsumgebung|Entwicklungsumgebung]] mit dem Namen ''[[DrRacket]]'' (früher DrScheme) beinhaltet. ''DrRacket'' ist speziell auf den Einsatz in der Programmieranfängerausbildung zugeschnitten und leicht zu bedienen. Racket enthält mehrere Compiler, die Racket-/Scheme-Code zu  [[Bytecode|Byte-]] oder C-Code umwandeln.
* Scheme 48<ref>[http://www.s48.org/ Scheme-48-Webseite]</ref> ist eine komplett in Scheme geschriebene Scheme-Implementierung. Zum [[Bootstrapping (Programmierung)|Bootstrapping]] wird ein [[Statische Typisierung|statisch typisierter]] Scheme-Dialekt namens ''PreScheme'' verwendet. Scheme 48 übersetzt Scheme-Code in Bytecode, der in einem Speicherimage gesichert werden kann. Scheme 48 zeichnet sich besonders durch seine Möglichkeiten aus, Scheme-Code zu debuggen.
* SIOD.<ref>{{Webarchiv |url=http://www.cs.indiana.edu/scheme-repository/imp/siod.html |text=SIOD-Webseite |wayback=20070406212001}}</ref> Ein kleiner, schneller Scheme-Interpreter, der unter anderem Verwendung in [[GIMP]]s ''[[ScriptFu]]'' bis Version 2.4 fand.

== Literatur ==
* Hal Abelson, Gerald Jay Sussman: ''[[Structure and Interpretation of Computer Programs]]''. McGraw-Hill, ISBN 0-07-000422-6
* Hal Abelson, Gerald Jay Sussman: ''Struktur und Interpretation von Computerprogrammen''. Springer-Verlag, ISBN 3-540-42342-7
* R. Kent Dybvig: ''The Scheme Programming Language''. The MIT Press, ISBN 0-262-54148-3 ([http://www.scheme.com/tspl4/ 4. Ausgabe online])
* Iain Ferguson: ''The Schemer’s Guide''. Schemers Inc., ISBN 0-9628745-2-3
* Daniel P. Friedman, Matthias Felleisen: ''The Little Schemer''. The MIT Press, ISBN 0-262-56099-2
* Daniel P. Friedman, Matthias Felleisen: ''The Seasoned Schemer''. The MIT Press, ISBN 0-262-56100-X
* Daniel P. Friedman, Matthias Felleisen: ''The Reasoned Schemer''. The MIT Press, ISBN 0-262-56214-6
* George Springer, Daniel P. Friedman: ''Scheme and the Art of Programming''. The MIT Press, ISBN 0-262-19288-8
* Herbert Klaeren, Michael Sperber: ''Die Macht der Abstraktion: Einführung in die Programmierung''. Teubner, ISBN 3-8351-0155-2
* Herbert Klaeren, Michael Sperber: ''Vom Problem zum Programm''. Teubner, ISBN 3-519-22242-6
* Jacques Chazarain: ''Programmer avec Scheme''. International Thomson Publishing, France, ISBN 2-84180-131-4
* Chris Hanson, Garald Jay Sussman: ''Software Design for Flexibility''. The MIT Press, ISBN 978-0-262-04549-0

== Weblinks ==
{{Wikisource|Scheme: An Interpreter for Extended Lambda Calculus|lang=en}}
* [http://www.schemers.org/ schemers.org] Materialsammlung zu Scheme
* Guy Steele, Gerald Sussman: [http://library.readscheme.org/page1.html The Original ‚Lambda Papers‘.]
* [http://srfi.schemers.org/ SRFI (Scheme Requests for Implementation)] stellt eine Sammlung von Funktionalitäten bereit, die sich praktisch als Standard-Bibliothek für Scheme-Implementierungen herausgebildet hat.

=== Einführungen ===
* [http://www.htdp.org/ How To Design Programs] (HTDP) – Einsteiger-Scheme-Buch
* [http://mitpress.mit.edu/sicp/ ''Structure and Interpretation of Computer Programs''] (SICP) – Dieses Scheme-Buch wurde jahrelang in den Einsteiger-Programmierkursen am [[Massachusetts Institute of Technology|MIT]] und anderen Universitäten verwendet.
* [https://ds26gte.github.io/tyscheme/index.html ''Teach Yourself Scheme in Fixnum Days''.] – Online-Kurs für Einsteiger.

=== Sprachstandards ===
* [http://www.schemers.org/Documents/Standards/R5RS/ Definition des veralteten Sprachstandards R5RS]
* [http://www.r6rs.org/ Definition des vorherigen Sprachstandards R6RS]
* [https://bitbucket.org/cowan/r7rs/raw/4c27517de187142ad2cf4bcd8cb9199ae1e48c09/rnrs/r7rs.pdf Definition des aktuellen Sprachstandards R7RS] (PDF; 679 kB)

== Einzelnachweise ==
<references />

[[Kategorie:Lisp]]
[[Kategorie:Funktionale Programmiersprache]]

Scheme - Versionsgeschichte

imported>Neubadener: Vereinheitliche Großschreibung vom Namen „Lisp“ (keine Abkürzung im üblichen Sinne)