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.

Datenkapselung in Scheme

Der kontrollierte Zugriff auf Daten ist in Scheme eines der interessanten Anwendungsgebiet für eine Kombination aus lexikalischen Bindung und dem Gebrauch von Funktionen höherer Ordnung.

In Listing 3 erkennt man im Methodenkopf folgende Neuerung : . args. Dieser durch Punkt abgetrennte Parameter steht für eine Liste in der weitere optionale Elemente zusammengefasst werden, vergleichbar der Ellipsis (den drei Punkten) in C.

Die Initialisierung der ersten Variablen balance erfolgt durch (if (not (null? args)) (car args) 1000)). Falls die args-Liste existiert, wird das erste Element der Liste als Anfangsbestand aufgefasst, andernfalls setzt man ihn auf 1000. Ähnlich wird auch der Zinssatz mit einem Wert initialisiert. Auf lokale Variablen hat man von außen keine Zugriffsmöglichkeit, man kann sie aber wie folgt "exportieren":

(lambda (message)
      (case message
        ((name) (lambda () name))
        ((balance) (lambda () 
                     balance))
        ...

Es handelt sich um eine anonyme Funktion mit einem Parameter, die gleichzeitig Rückgabewert der Methode wird. Mit dem Parameter wird auf eine in der Fallunterscheidung definierte Methode zugegriffen. Lautet message beispielsweise \'name, dann wird folgende Funktion zurückgegeben: (lambda () name))). Da es sich um eine Funktion handelt, muss man sie aufrufen, um das eigentlich interessierende Ergebnis zu erhalten. Der Aufruf kann dabei auf verschiedene Weise erfolgen, entweder durch eine objektorientierte oder eine funktionale Vorgehensweise. Auf OOP-Art könnte das so aussehen:

(define (send fun message . args)
           (apply (fun message) args))

Die Funktion apply erwartet eine Funktion und eine Liste von Elementen, auf die diese Funktion angewandt wird. Wenn Sie etwa eine Addition ausführen wollen, können Sie entweder (+ 1 2 3) benutzen oder aber (apply + \'(1 2 3)). Senden wir die Nachricht \'name an account, erhalten wir die oben erwähnte parameterlose Funktion. Gehen wir von folgender Definition aus: (define acc1 (account "someone")), lautet die Ersetzung für den Aufruf (send acc1 \'name); (apply (acc1 \'name) \'()). Bevorzugen Sie die funktionale Art des Aufrufs benutzen Sie: ((acc1 \'name)) (Bitte beachten Sie die Klammerung!)

Diese Art der Vorgehensweise kann die Basis für ein OO-System bilden. Wenn dieses System den Vorstellungen von objektorientierter Programmierung entsprechen soll, sind Makros, ein weiteres Scheme-Programmierwerkzeug sicher hilfreich.

(define (account name . args)
  (let ((name name)
        (balance (if (not (null? args)) (car args) 1000))
        (interest-rate 
         (if (and
              (not (null? args))
              (not (null? (cdr args)))) 
             (cadr args) 
             0.06)))
    (lambda (message)
      (case message
        ((name) (lambda () name))
        ((balance) (lambda () 
                     balance))
        ((deposit) (lambda (amount) 
                     (set! balance (+ balance amount))
                     balance))
        ((withdraw) (lambda (amount)
                      (set! balance (- balance amount))
                      balance))
        ((interest-rate) (lambda () 
                           interest-rate))
        ((add-interest) (lambda () 
                          (set! balance 
                               (* balance 
                                  (+ 1 interest-rate)))
                          balance))
        (else (lambda () "Method unknown"))))))
(define (send fun message . args)
  (apply (fun message) args))

Makros

Alle Lisps bieten Möglichkeiten, neue Daten- und Kontrollstrukturen (wie eine neue Fallunterscheidung, eine neue Schleife) zu definieren. In den meisten Schemes gibt es verschiedene Wege, Makros zu definieren. Sie werden hier die "alte" und die "R5RS" Art genannt. Im Beispiel handelt es sich um eine einseitige Fallunterscheidung.

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.