Scheme: Implementierungen und Ökosystem

Kurz: Scheme ist ein Standard (R5RS, R6RS, R7RS-small) mit vielen Implementierungen:

Teil des Kurses Scheme

Kapitel 7 von 8 im Kurs Scheme. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Standards und Implementierungen

Scheme ist ein Standard (R5RS, R6RS, R7RS-small) mit vielen Implementierungen:

Implementierung	Besonderheit
GNU Guile	Erweiterungssprache des GNU-Projekts, Basis von GNU Guix
Racket	Eigener Dialekt mit riesiger Bibliothek und DrRacket
Chez Scheme	Sehr schneller Compiler (Basis von Racket CS)
Chicken	Übersetzt nach C, viele Pakete (“Eggs”)
Gambit	Native Programme, leichtgewichtig
MIT Scheme	Referenz aus SICP, Editor Edwin
Gauche	Skripting-Schwerpunkt
Chibi	Kleine R7RS-Implementierung zum Einbetten

Portable Programme (R7RS)

R7RS-Programme beginnen mit einem import:

(import (scheme base) (scheme write))
 
(define (quadrat x) (* x x))
(display (quadrat 7))
(newline)

In Guile gibt es für R7RS einen Schalter: guile --r7rs hallo.scm.

Typische Hilfsfunktionen selbst bauen

Wer portabel bleiben will, schreibt kleine Hilfen selbst:

(define (zeige x) (display x) (newline))
 
(define (bereich von bis)
  (if (> von bis) '() (cons von (bereich (+ von 1) bis))))
 
(define (summe liste) (apply + liste))
 
(define (filtern p liste)
  (cond ((null? liste) '())
        ((p (car liste)) (cons (car liste) (filtern p (cdr liste))))
        (else (filtern p (cdr liste)))))
 
(define (zusammenfassen f start liste)
  (if (null? liste) start (zusammenfassen f (f start (car liste)) (cdr liste))))
 
(define (flach liste)
  (cond ((null? liste) '())
        ((pair? (car liste)) (append (flach (car liste)) (flach (cdr liste))))
        (else (cons (car liste) (flach (cdr liste))))))
 
(zeige (bereich 1 10))
(zeige (summe (bereich 1 100)))
(zeige (filtern even? (bereich 1 10)))
(zeige (zusammenfassen * 1 (bereich 1 10)))
(zeige (flach '(1 (2 (3 4)) 5)))

Ausgabe:

(1 2 3 4 5 6 7 8 9 10)
5050
(2 4 6 8 10)
3628800
(1 2 3 4 5)

Testen ohne Bibliothek

(define bestanden 0)
(define fehler 0)
 
(define-syntax pruefe
  (syntax-rules ()
    ((_ ausdruck erwartet)
     (let ((ist ausdruck))
       (if (equal? ist erwartet)
           (begin (set! bestanden (+ bestanden 1)) (display "ok     ") (write 'ausdruck) (newline))
           (begin (set! fehler (+ fehler 1)) (display "FEHLER ") (write 'ausdruck) (display " => ") (write ist) (newline)))))))
 
(pruefe (+ 1 2) 3)
(pruefe (reverse '(1 2 3)) '(3 2 1))
(pruefe (string-append "a" "b") "ab")
(pruefe (* 2 2) 5)
(display bestanden) (display " bestanden, ") (display fehler) (display " fehlgeschlagen") (newline)

Ausgabe:

ok     (+ 1 2)
ok     (reverse (quote (1 2 3)))
ok     (string-append "a" "b")
FEHLER (* 2 2) => 4
3 bestanden, 1 fehlgeschlagen

Merke

• Scheme ist ein Standard mit vielen Implementierungen (Guile, Racket, Chez, Chicken, …)
• R7RS-small ist der aktuelle portable Standard
• Kleine Hilfsfunktionen und Makros ersetzen oft schwere Bibliotheken
• Guile eignet sich besonders als Skript- und Erweiterungssprache

Übungsaufgabe

Installiere GNU Guix oder Chicken Scheme und führe ein Hello-World aus.

Quiz zur Selbstkontrolle

Was ist R7RS?

• Ein Scheme-Sprachstandard (richtig)
• Ein Compiler
• Ein Betriebssystem
• Ein Texteditor

Wofür steht Guile?

• GNU-Implementierung von Scheme (richtig)
• Ein Texteditor
• Eine Bibliothek für Grafik
• Ein Debugger

Was ist Chez Scheme?

• Ein schneller Scheme-Compiler (richtig)
• Ein Käsehersteller
• Ein Texteditor
• Ein Betriebssystem

Weiter im Kurs

Zurück: Praxis: Ein eigener Interpreter

Weiter: Referenz und Spickzettel

Alle Kapitel: Scheme im Überblick