1.1 Ein Schnellkurs in Scheme

Die von Guix benutzte Scheme-Implementierung nennt sich Guile. Um mit der Sprache herumspielen zu können, installieren Sie Guile mit guix install guile und starten eine interaktive Programmierumgebung (englisch Read-Eval-Print-Loop, kurz REPL), indem Sie guile auf der Befehlszeile ausführen.

Alternativ können Sie auch den Befehl guix environment --ad-hoc guile -- guile ausführen, wenn Sie Guile lieber nicht in Ihr Nutzerprofil installieren wollen.

In den folgenden Beispielen stehen die Zeilen dafür, was Sie auf der REPL eintippen; wenn eine Zeile mit „⇒“ beginnt, zeigt sie das Ergebnis einer Auswertung, während Zeilen, die mit „-|“ beginnen, für eine angezeigte Ausgabe stehen. Siehe Using Guile Interactively in das Referenzhandbuch zu GNU Guile für mehr Details zur REPL.

• Die Scheme-Syntax ist an sich ein Baum von Ausdrücken (Lisp-Programmierer nennen sie symbolische Ausdrücke, kurz S-Ausdrücke bzw. englisch s-expression). Ein solcher Ausdruck kann ein Literal sein, wie z.B. Zahlen oder Zeichenketten, oder er kann ein zusammengesetzter Ausdruck sein, d.h. eine geklammerte Liste von zusammengesetzten und literalen Ausdrücken. Dabei stehen #true und #false (abgekürzt auch #t und #f) jeweils für die Booleschen Werte „wahr“ und „falsch“.

  Beispiele für gültige Ausdrücke

  "Hallo Welt!"
  ⇒ "Hallo Welt!"
  
  17
  ⇒ 17
  
  (display (string-append "Hallo " "Guix" "\n"))
  -| Hallo Guix!
  ⇒ #<unspecified>
  

• Das letzte Beispiel eben ist der Aufruf einer Funktion innerhalb eines anderen Funktionsaufrufs. Wenn ein geklammerter Ausdruck ausgewertet wird, ist der erste Term die Funktion und der Rest sind die Argumente, die an die Funktion übergeben werden. Jede Funktion liefert ihren zuletzt ausgewerteten Ausdruck als ihren Rückgabewert.
• Anonyme Funktionen werden mit dem lambda-Term deklariert:

  (lambda (x) (* x x))
  ⇒ #<procedure 120e348 at <unknown port>:24:0 (x)>
  

  Die obige Prozedur liefert das Quadrat ihres Arguments. Weil alles ein Ausdruck ist, liefert der Ausdruck lambda eine anonyme Prozedur, die wiederum auf ein Argument angewandt werden kann:

  ((lambda (x) (* x x)) 3)
  ⇒ 9
  

• Allem kann mit define ein globaler Name zugewiesen werden:

  (define a 3)
  (define quadrat (lambda (x) (* x x)))
  (quadrat a)
  ⇒ 9
  

• Prozeduren können auch kürzer mit der folgenden Syntax definiert werden:

  (define (quadrat x) (* x x))
  

• Eine Listenstruktur kann mit der list-Prozedur erzeugt werden:

  (list 2 a 5 7)
  ⇒ (2 3 5 7)
  

• Mit dem quote-Zeichen wird das Auswerten eines geklammerten Ausdrucks abgeschaltet: Der erste Term wird nicht auf den anderen Termen aufgerufen (siehe quote in Referenzhandbuch zu GNU Guile). Folglich liefert es quasi eine Liste von Termen.

  '(display (string-append "Hello " "Guix" "\n"))
  ⇒ (display (string-append "Hello " "Guix" "\n"))
  
  '(2 a 5 7)
  ⇒ (2 a 5 7)
  

• Mit einem quasiquote-Zeichen wird die Auswertung eines geklammerten Ausdrucks so lange abgeschaltet, bis ein unquote (ein Komma) sie wieder aktiviert. Wir können damit genau steuern, was ausgewertet wird und was nicht.

  `(2 a 5 7 (2 ,a 5 ,(+ a 4)))
  ⇒ (2 a 5 7 (2 3 5 7))
  

  Beachten Sie, dass obiges Ergenis eine Liste verschiedenartiger Elemente ist: Zahlen, Symbole (in diesem Fall a) und als letztes Element selbst wieder eine Liste.

• Mehrere Variable können in einer lokalen Umgebung mit Bezeichnern versehen werden, indem Sie let benutzen (siehe Local Bindings in Referenzhandbuch zu GNU Guile):

  (define x 10)
  (let ((x 2)
        (y 3))
    (list x y))
  ⇒ (2 3)
  
  x
  ⇒ 10
  
  y
  error→ In procedure module-lookup: Unbound variable: y
  

  Benutzen Sie let*, damit spätere Variablendeklarationen auf frühere verweisen können.

  (let* ((x 2)
         (y (* x 3)))
    (list x y))
  ⇒ (2 6)
  

• Mit Schlüsselwörtern bestimmen wir normalerweise diejenigen Parameter einer Prozedur, die einen Namen haben sollen. Ihnen wird #: (Doppelkreuz und Doppelpunkt) vorangestellt, gefolgt von alphanumerischen Zeichen: #:etwa-so. Siehe Keywords in Referenzhandbuch zu GNU Guile.
• Das Prozentzeichen % wird in der Regel für globale Variable auf Erstellungsebene benutzt, auf die nur lesend zugegriffen werden soll. Beachten Sie, dass es sich dabei nur um eine Konvention handelt, ähnlich wie _ in C. Scheme behandelt % genau wie jedes andere Zeichen.
• Module werden mit Hilfe von define-module erzeugt (siehe Creating Guile Modules in Referenzhandbuch zu GNU Guile). Zum Beispiel definiert man mit

  (define-module (guix build-system ruby)
    #:use-module (guix store)
    #:export (ruby-build
              ruby-build-system))
  

  das Modul guix build-system ruby, das sich unter dem Pfad guix/build-system/ruby.scm innerhalb irgendeines Verzeichnisses im Guile-Ladepfad befinden muss. Es hat eine Abhängigkeit auf das Modul (guix store) und exportiert zwei seiner Variablen, ruby-build und ruby-build-system.

Für eine detailliertere Einführung können Sie einen Blick auf Steve Litts Scheme at a Glance werfen.

Eines der Referenzbücher zu Scheme ist das einflussreiche „Structure and Interpretation of Computer Programs“, von Harold Abelson und Gerald Jay Sussman, mit Julie Sussman. Eine deutsche Übersetzung „Struktur und Interpretation von Computerprogrammen“ hat Susanne Daniels-Herold verfasst. Vom englischen Original finden Sie eine kostenlose Ausgabe online zusammen mit Videos der von den Autoren gehaltenen Vorlesungen. Das Buch können Sie im Texinfo-Format über das sicp-Guix-Paket beziehen. Probieren Sie es aus: Führen Sie guix install sicp aus und fangen Sie mit dem Lesen an, indem Sie info sicp eintippen (siehe Structure and Interpretation of Computer Programs). Es gibt auch ein inoffizielles E-Book.

Sie finden noch mehr Bücher, Anleitungen und andere Ressourcen auf https://schemers.org/.