Ein-/Ausgabe, Zeit und Nebenläufigkeit

#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))

(eins zwei drei)
eins
zwei
drei

4
1: eins
2: zwei
3: drei
4: vier
(a b 3)
#t
#f

#lang racket

(define ausgabe (open-output-string))
(fprintf ausgabe "Zahl: ~a~n" 42)
(write 'symbol ausgabe)
(displayln (get-output-string ausgabe))

(define eingabe (open-input-string "10 20 30 abc"))
(let loop ([summe 0])
  (define x (read eingabe))
  (cond [(number? x) (loop (+ summe x))]
        [else (displayln summe)]))

(displayln (with-output-to-string (lambda () (display "eingefangen"))))
(displayln (read (open-input-string "(1 (2 3))")))
(displayln (port->lines (open-input-string "a\nb\nc")))
(printf "~s ~a ~v~n" "text" "text" "text")

Zahl: 42
symbol
60
eingefangen
(1 (2 3))
(a b c)
"text" text "text"

#lang racket
(require racket/date)

(define d (seconds->date 0 #f))
(displayln (list (date-year d) (date-month d) (date-day d)))
(displayln (date->string (seconds->date 86400 #f)))
(displayln (> (current-seconds) 1700000000))
(displayln (> (current-inexact-milliseconds) 0))
(random-seed 42)
(displayln (< -1 (random 100) 100))
(displayln (length (shuffle '(1 2 3 4 5))))
(displayln (sort (shuffle '(3 1 2)) <))
(displayln (> (vector-length (current-command-line-arguments)) -1))
(displayln (string? (path->string (current-directory))))
(displayln (getenv "NICHT_GESETZT_XYZ"))

(1970 1 1)
Friday, January 2nd, 1970
#t
#t
#t
5
(1 2 3)
#t
#t
#f

#lang racket

(define ch (make-channel))
(void (thread (lambda ()
                (for ([i 3]) (channel-put ch (* i i)))
                (channel-put ch 'ende))))
(let loop ()
  (define x (channel-get ch))
  (unless (eq? x 'ende)
    (printf "empfangen: ~a~n" x)
    (loop)))

(define ergebnisse
  (for/list ([i 4])
    (define t (thread (lambda () (sleep 0.01) (* i i))))
    t))
(for-each thread-wait ergebnisse)
(displayln "alle Threads fertig")

(define sem (make-semaphore 1))
(define zaehler 0)
(define arbeiter
  (for/list ([i 4])
    (thread (lambda ()
              (for ([j 100])
                (semaphore-wait sem)
                (set! zaehler (add1 zaehler))
                (semaphore-post sem))))))
(for-each thread-wait arbeiter)
(displayln zaehler)

(define fut (future (lambda () (for/sum ([i 100000]) i))))
(displayln (touch fut))

empfangen: 0
empfangen: 1
empfangen: 4
alle Threads fertig
400
4999950000