Scheme: Spickzettel

Minimalistisches Lisp mit eleganter Theorie

Ausführen: Datei hallo.scm speichern und mit guile hallo.scm ausführen (GNU Guile von gnu.org/software/guile; weitere Implementierungen: Chez, Chicken, Gambit, Racket).

guile hallo.scm                 # Skript ausführen
guile                           # interaktive Konsole (REPL)
guile -c '(display (+ 1 2))'    # Einzeiler
guile --no-auto-compile x.scm   # ohne Zwischenübersetzung

(define (zeige x) (display x) (newline))

(define (vorzeichen n)
  (cond ((> n 0) "positiv")
        ((< n 0) "negativ")
        (else "null")))

(zeige (list (vorzeichen 5) (vorzeichen -2) (vorzeichen 0)))
(zeige (if (> 3 2) "ja" "nein"))
(when (even? 4) (zeige "gerade"))
(unless (even? 5) (zeige "ungerade"))
(zeige (and 1 2 3))
(zeige (or #f #f 5))
(zeige (not #t))
(zeige (case 3
         ((1) "eins")
         ((2 3) "zwei oder drei")
         (else "viele")))
(zeige (let loop ((i 0) (akk '()))
         (if (= i 5) (reverse akk) (loop (+ i 1) (cons (* i i) akk)))))
(zeige (eq? 'a 'a))
(zeige (equal? '(1 2) '(1 2)))
(zeige (eqv? 2.5 2.5))

(use-modules (srfi srfi-13))
(define (zeige x) (display x) (newline))
(define s "Hallo Scheme")
(zeige (string-length s))
(zeige (string-upcase s))
(zeige (string-downcase s))
(zeige (substring s 6 12))
(zeige (string-ref s 0))
(zeige (string-append s "!" "!"))
(zeige (string->list "abc"))
(zeige (list->string (list #\x #\y)))
(zeige (string->number "42"))
(zeige (number->string 3.5))
(zeige (string<? "a" "b"))
(zeige (string=? "x" "x"))
(zeige (string-index s #\S))
(zeige (string-contains s "Sch"))
(zeige (string-join '("a" "b" "c") "-"))
(zeige (string-reverse "Scheme"))
(zeige (string-pad "7" 3 #\0))
(zeige (char-upcase #\a))
(zeige (char->integer #\A))
(zeige (integer->char 66))
(zeige (string->symbol "wort"))
(zeige (symbol->string 'wort))
(zeige (char-numeric? #\5))
(zeige (string-split "a,b,c" #\,))
(zeige (string-trim "  x  "))
(zeige (string-map char-upcase "abc"))
(zeige (list-tail (string->list "hallo") 3))
(zeige (string-count "banane" #\a))

(use-modules (srfi srfi-1))
(define (zeige x) (display x) (newline))
(define (zweimal f) (lambda (x) (f (f x))))
(define (kompose f g) (lambda (x) (f (g x))))
(define (addierer n) (lambda (x) (+ x n)))
(define (curry2 f) (lambda (a) (lambda (b) (f a b))))

(zeige ((zweimal 1+) 5))
(zeige ((kompose 1+ (lambda (x) (* x 10))) 4))
(zeige (map (addierer 100) '(1 2 3)))
(zeige (((curry2 +) 3) 4))
(zeige (apply map list '((1 2 3) (4 5 6))))
(zeige (map (lambda (f) (f 10)) (list 1+ 1- (lambda (x) (* x x)))))
(zeige (fold-right cons '() '(1 2 3)))
(zeige (fold cons '() '(1 2 3)))
(zeige (reduce + 0 '(1 2 3 4)))
(zeige (delete 2 '(1 2 3 2)))
(zeige (partition even? '(1 2 3 4 5)))
(zeige (any even? '(1 3 4)))
(zeige (every even? '(2 4)))
(zeige (find (lambda (x) (> x 3)) '(1 5 2 7)))
(zeige (append-map (lambda (x) (list x x)) '(1 2)))
(zeige (delete-duplicates '(1 2 2 3 3 3)))
(zeige (list-index even? '(1 3 4)))
(zeige (take '(1 2 3 4) 2))
(zeige (drop '(1 2 3 4) 2))
(zeige (last '(1 2 3)))

(use-modules (ice-9 format) (srfi srfi-13))
(format #t "Name: ~a, Alter: ~a~%" "Mia" 17)
(format #t "~s und ~a~%" "text" "text")
(format #t "Dezimal ~d, binär ~b, oktal ~o, hex ~x~%" 255 255 255 255)
(format #t "Fließkomma ~,2f~%" 3.14159)
(format #t "Breite |~8d|~8a|~%" 42 "li")
(format #t "~a~%" (format #f "~a-~a" 1 2))
(format #t "Liste: ~{~a ~}~%" '(1 2 3))
(display (list 'a "b" #\c 1.5 1/2))
(newline)
(write (list 'a "b" #\c 1.5 1/2))
(newline)
(display (string-pad (number->string 7) 4))
(newline)
(display (list (exact->inexact 2/3) (round 7/2) (inexact->exact 0.25)))
(newline)

(use-modules (ice-9 match))

(define (auswerten ausdruck umgebung)
  (match ausdruck
    ((? number? n) n)
    ((? symbol? s)
     (let ((paar (assq s umgebung)))
       (if paar (cdr paar) (error "Unbekannte Variable:" s))))
    (('+ a b) (+ (auswerten a umgebung) (auswerten b umgebung)))
    (('- a b) (- (auswerten a umgebung) (auswerten b umgebung)))
    (('* a b) (* (auswerten a umgebung) (auswerten b umgebung)))
    (('/ a b) (/ (auswerten a umgebung) (auswerten b umgebung)))
    (('if c a b) (if (not (zero? (auswerten c umgebung))) (auswerten a umgebung) (auswerten b umgebung)))
    (('let ((x wert)) rumpf)
     (auswerten rumpf (cons (cons x (auswerten wert umgebung)) umgebung)))
    (_ (error "Unbekannter Ausdruck:" ausdruck))))

(define (zeige x) (display x) (newline))
(zeige (auswerten '(+ 1 (* 2 3)) '()))
(zeige (auswerten '(let ((x 5)) (* x x)) '()))
(zeige (auswerten '(if 0 100 200) '()))
(zeige (auswerten '(/ 10 4) '()))
(zeige (auswerten '(+ x 1) '((x . 41))))

(import (scheme base) (scheme write))

(define (quadrat x) (* x x))
(display (quadrat 7))
(newline)

(define (zeile text wert)
  (display text) (display " => ") (write wert) (newline))
(zeile "(quote (a b))" '(a b))
(zeile "(list 'a \"b\")" (list 'a "b"))
(zeile "(vector 1 2)" (vector 1 2))
(zeile "(cons 1 2)" (cons 1 2))
(zeile "(string #\\a #\\b)" (string #\a #\b))
(zeile "(exact->inexact 1/8)" (exact->inexact 1/8))
(zeile "(boolean? #f)" (boolean? #f))
(zeile "(procedure? car)" (procedure? car))
(zeile "(list 'quote 'x)" (list 'quote 'x))
(zeile "(char->integer #\\a)" (char->integer #\a))