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 shell -- 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 "Hallo " "Guix" "\n"))
  ⇒ (display (string-append "Hallo " "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.

Vertiefung: Die Sprache Scheme wurde oft eingesetzt, um Programmieren beizubringen, daher gibt es ein breites Angebot an Lehrmaterialien, die sie als Transportmittel einsetzen. Hier sehen Sie eine Auswahl solcher Dokumente, mit denen Sie mehr über Scheme erfahren können:

• Ein Scheme-Primer, von Christine Lemmer-Webber und dem Spritely Institute, auf Deutsch übersetzt von Florian Pelz.
• Scheme at a Glance von Steve Litt.
• Structure and Interpretation of Computer Programs, by Harold Abelson and Gerald Jay Sussman, with Julie Sussman. Colloquially known as “SICP”, this book is a reference.

  Das Buch können Sie auch installieren und von Ihrem Rechner aus lesen:

  guix install sicp info-reader
  info sicp
  

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