Es gibt mehrere verschiedene Methoden, um Variablen zu deklarieren, aber die bevorzugte Methode ist das let*-Konstrukt. Wenn Sie mit anderen Programmiersprachen vertraut sind: Dieses Konstrukt ist äquivalent dazu, eine Liste lokaler Variablen mit zugehörigem Gültigkeitsbereich zu definieren. Um beispielsweise zwei Variablen a und b zu deklarieren und mit den Werten 1 beziehungsweise 2 zu initialisieren, würden Sie folgendes schreiben:

        (let*
           (
              (a 1)
              (b 2)
           )
           (+ a b)
        )
      

oder, als Einzeiler:

(let* ( (a 1) (b 2) ) (+ a b) )

Das deklariert zwei lokale Variablen a und b, initialisiert sie, und gibt dann die Summe der beiden Variablen aus.

Sie werden bemerkt haben, dass wir die Summe (+ a b) innerhalb der Klammern des let*-Ausdrucks und nicht außerhalb geschrieben haben.

Das kommt daher, weil die let*-Anweisung einen Bereich in Ihrem Skript definiert, in dem die deklarierten Variablen verwendet werden können. Wenn Sie die Anweisung (+ a b) nach dem Ausdruck (let* …) schreiben, erhalten Sie eine Fehlermeldung, da die deklarierten Variablen nur innerhalb des Kontexts der let*-Anweisung gültig sind. Sie sind das, was Programmierer »lokale Variablen« nennen.

Die allgemeine Form der let*-Anweisung ist:

        (let* ( variablen )
          ausdrücke )
      

wobei Variablen innerhalb von Klammern deklariert werden, z.B. (a 2), und Ausdrücke beliebige gültige Scheme-Ausdrücke sind. Denken Sie daran, dass die hier deklarierten Variablen nur innerhalb der let*-Anweisung gültig sind – sie sind lokale Variablen.

Wir haben bereits vorher erwähnt, dass Sie Ihre Skripte mit Einrückungen lesbarer gestalten sollten. Das ist eine gute Vorgehensweise und überhaupt kein Problem in Scheme – Leerzeichen (A.d.Ü.: Gemeint sind Leerzeichen im erweiterten Sinne (»Freizeichen«), also auch Zeilenvorschub und -umbruch, Seitenvorschub, horizontaler und vertikaler Tabulator) werden vom Scheme-Interpreter ignoriert und können daher großzügig eingesetzt werden, um den Code in Ihrem Skript zu organisieren und zu verdeutlichen. Wenn Sie allerdings im Skript-Fu-Konsolenfenster arbeiten, müssen Sie jeden Ausdruck in eine Zeile schreiben, d.h. alles zwischen der öffnenden und der korrespondierenden schließenden Klammer eines Ausdrucks.

Wenn Sie eine Variable initialisiert haben, müssen Sie ihren Wert vielleicht später im Skript verändern. Verwenden Sie dafür die set!-Anweisung:

        (let* ( (theNum 10) ) (set! theNum (+ theNum theNum)) )
      

Überlegen Sie sich, was die obige Anweisung tun wird, und dann probieren Sie es aus und geben Sie sie in der Skript-Fu-Konsole ein.

Nachdem Sie nun den Dreh mit den Variablen raushaben, lassen Sie uns ein wenig mit Funktionen arbeiten. Sie deklarieren eine Funktion gemäß der folgenden Syntax:

        (define
           (
              name
              param-list
           )
           ausdrücke
        )
      

wobei name der der Funktion zugewiesene Name ist, param-list eine durch Leerzeichen getrennte Liste von Parameternamen und ausdrücke eine Folge von Ausdrücken, die die Funktion bei ihrem Aufruf ausführt. Zum Beispiel:

(define (AddXY inX inY) (+ inX inY) )

AddXY ist der Funktionsname, und inX und inY sind die Variablen. Die Funktion erwartet zwei Parameter und addiert sie.

Wenn Sie bereits in anderen imperativen Sprachen programmiert haben (z.B. in C/C++, Java, Pascal, etc.), dann werden Sie vielleicht bemerkt haben, dass im Vergleich zu anderen Programmiersprachen einige Dinge in dieser Funktionsdefinition fehlen.