Nachdem im vorherigen Teil die Basiselemente der Scheme-Programmierung vorgestellt wurden, soll in diesem Artikel ein essentieller Vorteil von Scheme die Hauptrolle spielen, nämlich die funktionale Programmierung.

Lokale Variablen

Wie in anderen Sprachen kann man auch in Scheme lokale Variablen deklarieren und nutzen. Im Gegensatz zu den meisten anderen Sprachen ist es unerheblich, ob es sich bei den Werten der lokalen Variablen um Daten oder Funktionen handelt. Lokale Variablen werden in einem mit let oder let* eingeleiteten Block deklariert und initialisiert. Der Unterschied zwischen let und let* besteht darin, dass man sich in let* auf vorher auftretende Deklarationen beziehen kann. Bemerkenswert an den beiden lets ist, dass sie nur Makros um das schon bekannte lambda sind. Im Prinzip sind die beiden folgenden Zeilen äquivalent:

(let ((i 1)) (display i) (newline))
((lambda (i) (display i) (newline)) 1)

Die erste Art ist meiner Meinung nach besser lesbar und verständlicher. Beachten Sie aber bitte, dass Sie nicht das "named-let" aus dem ersten Teil mit dieser lokalen Variablendeklaration vertauschen. Die hier gültige Form lautet: (let ((variable init)) . Auf die Initialisierung kann in Scheme nicht verzichtet werden.

Am folgenden Beispiel erkennen Sie, dass man in Scheme auch Funktionen an lokale Variablen binden kann.

(let ((d (lambda (n) (* n 2))))
    (display (d 1)) (newline))

Let kann man nicht nur innerhalb anderer Funktionen oder weiterer let-Blöcken finden, sondern auch auf dem Top-Level. In jedem Fall sind die deklarierten Variablen nur bis zum Ende des Blockes sichtbar, in dem sie definiert wurden.

Die Verschachtelung gilt nicht nur für lets, sondern auch für Kombinationen von let und define. Ob Sie also (let ((i 1) (j 10)) (+ i j)) benutzen oder (let ((i 1)) (let ((j 10)) (+ i j))), richtet sich nach der Situation oder Ihren Vorstellungen. Scheme legt Ihnen auch keine Restriktionen bezüglich der Position von weiteren Funktionen oder der Einführung von lokalen Variablen auf.

Lexikalische Bindung

Scheme spielte in diesem Bereich eine Vorreiterrolle in der Lisp-Familie. Die lexikalische Bindung veranschaulicht wiederum ein Beispiel am besten.

(define counter 50)
(define (inc-counter)
  (set! counter (+ 1 counter))
  counter)
(let ((counter 100))
  (display (inc-counter)) (newline)
  (display (inc-counter)) (newline))

Da in Scheme die lexikalische Bindung gilt, erhalten Sie als Ausgabe 51 52. Zwar überlagert der counter im let-Block die globale Variable mit dem gleichen Namen, jedoch nicht in der Funktion inc-counter. Als diese Funktion definiert wurde, war nur die globale Variable bekannt, und nur auf diese hat inc-counter Zugriff. Innerhalb des Blockes definierte Funktionen oder Variablen hätten hingegen nur Zugriff auf die überlagerte Variable.

Eine andere Art der Bindung wird dynamische genannt, sie war Standard in den ersten Lisps Versionen, bei Emacs Lisp handelt es sich noch um ein Lisp mit dynamischer Bindung. Dr. Scheme stellt diese Bindung mit fluid-let zur Verfügung:

(fluid-let ((counter 100))
  (display (inc-counter) (newline))
  (display (inc-counter) (newline)))

Ausgabe hier: 100 101. Da das Verhalten sich bei der lexikalischen und dynamischen Bindung unterscheidet, sollten Sie sich der jeweils gültigen Bindung bewusst sein. Scheme unterstützt normalerweise nur die lexikalische Bindung, Common Lisp bietet beide Arten und Emacs Lisp standardmäßig die dynamische Bindung (mit Möglichkeiten, die lexikalische Bindung zu emulieren).

Nachdem im vorherigen Teil die Basiselemente der Scheme-Programmierung vorgestellt wurden, soll in diesem Artikel ein essentieller Vorteil von Scheme die Hauptrolle spielen, nämlich die funktionale Programmierung.