Racket: Spickzettel

Eine Programmiersprache zum Programmieren von Programmiersprachen

Ausführen: Datei hallo.rkt speichern (erste Zeile #lang racket) und mit racket hallo.rkt ausführen (Racket von racket-lang.org, Editor DrRacket).

racket hallo.rkt          # Datei ausführen
racket                    # interaktive Konsole (REPL)
raco make hallo.rkt       # zu Bytecode übersetzen
raco test hallo.rkt       # Tests ausführen
raco pkg install <paket>  # Paket installieren
drracket                  # Entwicklungsumgebung

#lang racket

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

(displayln (list (vorzeichen 5) (vorzeichen -2) (vorzeichen 0)))
(displayln (if (> 3 2) "ja" "nein"))
(when (even? 4) (displayln "gerade"))
(unless (even? 5) (displayln "ungerade"))
(displayln (and 1 2 3))
(displayln (or #f #f 5))
(displayln (not #t))

(define (note n)
  (case n
    [(1) "sehr gut"]
    [(2 3) "gut bis befriedigend"]
    [else "sonst"]))
(displayln (list (note 1) (note 3) (note 9)))

(displayln (match 5
             [0 "null"]
             [(? even?) "gerade"]
             [_ "ungerade"]))

#lang racket

(define s "Hallo Racket")
(displayln (string-length s))
(displayln (string-upcase s))
(displayln (substring s 6 12))
(displayln (string-ref s 0))
(displayln (string-append s "!" "!"))
(displayln (string-split "a,b,,c" ","))
(displayln (string-join '("x" "y" "z") "-"))
(displayln (string-replace "aXbXc" "X" "+"))
(displayln (string-trim "  mitte  "))
(displayln (string-contains? s "Rack"))
(displayln (string-prefix? s "Hallo"))
(displayln (string->list "abc"))
(displayln (list->string (list #\x #\y)))
(displayln (string->number "42"))
(displayln (number->string 3.5))
(displayln (string<? "a" "b"))
(displayln (string=? "x" "x"))
(displayln (char-upcase #\a))
(displayln (char->integer #\A))
(displayln (integer->char 66))
(displayln (regexp-match #rx"[0-9]+" "ab123cd"))
(displayln (regexp-match* #px"\\d+" "a1b22c333"))
(displayln (regexp-replace* #rx"[aeiou]" "Racket" "*"))
(displayln (string-titlecase "hallo welt"))
(displayln (~a "Wert: " 42 " " 'sym))
(displayln (~r 3.14159 #:precision 2))
(displayln (~a 7 #:min-width 4 #:align 'right #:pad-string "0"))

#lang racket

(define (anwenden f x) (f x))
(define (zweimal f) (lambda (x) (f (f x))))
(define (kompose . fs)
  (if (null? fs) identity (lambda (x) ((car fs) ((apply kompose (cdr fs)) x)))))
(define (addierer n) (lambda (x) (+ x n)))

(displayln (anwenden add1 5))
(displayln ((zweimal add1) 5))
(displayln ((kompose add1 (lambda (x) (* x 10))) 4))
(displayln (map (addierer 100) '(1 2 3)))
(displayln ((curry + 5) 10))
(displayln ((curryr - 1) 10))
(displayln ((compose add1 sqr) 5))
(displayln (map + '(1 2 3) '(10 20 30)))
(displayln (apply map list '((1 2 3) (4 5 6))))
(displayln (sort '("ccc" "a" "bb") < #:key string-length))
(displayln (foldr cons '() '(1 2 3)))
(displayln (foldl cons '() '(1 2 3)))
(displayln (filter-not even? '(1 2 3 4)))
(displayln (let loop ([n 5] [acc '()]) (if (zero? n) acc (loop (sub1 n) (cons n acc)))))

#lang racket

(define tier%
  (class object%
    (init-field name)
    (super-new)
    (define/public (laut) "...")
    (define/public (vorstellen) (format "~a sagt ~a" name (laut)))))

(define hund%
  (class tier%
    (super-new)
    (define/override (laut) "Wau")
    (define/public (apportiere) (format "~a holt den Stock" (get-field name this)))))

(define katze%
  (class tier%
    (super-new)
    (define/override (laut) "Miau")))

(define tiere (list (new hund% [name "Rex"]) (new katze% [name "Mimi"])))
(for ([t tiere]) (displayln (send t vorstellen)))
(displayln (send (first tiere) apportiere))
(displayln (is-a? (first tiere) tier%))
(displayln (is-a? (second tiere) hund%))
(displayln (map (lambda (t) (send t laut)) tiere))

#lang racket

(define pfad (make-temporary-file "racket~a.txt"))
(display-lines-to-file '("eins" "zwei" "drei") pfad #:exists 'truncate)
(displayln (file->lines pfad))
(displayln (file->string pfad))
(with-output-to-file pfad #:exists 'append (lambda () (displayln "vier")))
(displayln (length (file->lines pfad)))
(call-with-input-file pfad
  (lambda (in)
    (let loop ([n 1])
      (define zeile (read-line in))
      (unless (eof-object? zeile)
        (printf "~a: ~a~n" n zeile)
        (loop (add1 n))))))
(with-output-to-file pfad #:exists 'truncate (lambda () (write '(a "b" 3))))
(displayln (file->value pfad))
(displayln (file-exists? pfad))
(delete-file pfad)
(displayln (file-exists? pfad))

#lang racket

(define (auswerten ausdruck umgebung)
  (match ausdruck
    [(? number? n) n]
    [(? symbol? s) (hash-ref umgebung s (lambda () (error 'auswerten "unbekannte Variable ~a" s)))]
    [(list '+ a b) (+ (auswerten a umgebung) (auswerten b umgebung))]
    [(list '- a b) (- (auswerten a umgebung) (auswerten b umgebung))]
    [(list '* a b) (* (auswerten a umgebung) (auswerten b umgebung))]
    [(list '/ a b) (/ (auswerten a umgebung) (auswerten b umgebung))]
    [(list 'let (list x wert) rumpf)
     (auswerten rumpf (hash-set umgebung x (auswerten wert umgebung)))]
    [(list 'if bedingung dann sonst)
     (if (zero? (auswerten bedingung umgebung)) (auswerten sonst umgebung) (auswerten dann umgebung))]
    [_ (error 'auswerten "unbekannter Ausdruck ~a" ausdruck)]))

(displayln (auswerten '(+ 1 (* 2 3)) (hash)))
(displayln (auswerten '(let (x 5) (* x x)) (hash)))
(displayln (auswerten '(if 0 100 200) (hash)))
(displayln (auswerten '(/ 10 4) (hash)))
(with-handlers ([exn:fail? (lambda (e) (displayln (exn-message e)))])
  (auswerten '(+ y 1) (hash)))

#lang racket

(define (zeige name wert) (printf "~a ~a~n" (~a name #:min-width 22) wert))
(zeige "(string? \"a\")" (string? "a"))
(zeige "(symbol? 'a)" (symbol? 'a))
(zeige "(list? '())" (list? '()))
(zeige "(pair? '(1))" (pair? '(1)))
(zeige "(equal? '(1) '(1))" (equal? '(1) '(1)))
(zeige "(eq? 'a 'a)" (eq? 'a 'a))
(zeige "(eqv? 2.0 2.0)" (eqv? 2.0 2.0))
(zeige "(= 1 1.0)" (= 1 1.0))
(zeige "(void)" (void))
(zeige "(length '())" (length '()))
(zeige "(string->symbol \"x\")" (string->symbol "x"))
(zeige "(procedure? car)" (procedure? car))
(zeige "(exact->inexact 22/7)" (exact->inexact 22/7))
(zeige "(string<? \"b\" \"a\")" (string<? "b" "a"))