list1.scm

;; Die ersten drei Zeilen dieser Datei wurden von DrRacket eingefügt. Sie enthalten Metadaten
;; über die Sprachebene dieser Datei in einer Form, die DrRacket verarbeiten kann.
#reader(lib "DMdA-beginner-reader.ss" "deinprogramm")((modname list1) (read-case-sensitive #f) (teachpacks ()) (deinprogramm-settings #(#f write repeating-decimal #f #t none explicit #f ())))
; Ein Paar besteht aus:
; - einem beliebigen Element
; - einer Liste
(define-record-procedures pair
  make-pair pair?
  (first rest))
(: make-pair (%a a-list -> pair))
(: pair? (any -> boolean))
(: first (pair -> %a))
(: rest (pair -> a-list))

; Eine Liste ist eins der folgenden:
; - die leere Liste
; - ein Paar
(define a-list
  (signature
   (mixed empty-list
          pair)))

(make-pair "Pumps" empty)
(make-pair "Mike" (make-pair "Herbert" (make-pair "Marcus" empty)))
(make-pair "Brot" (make-pair "Butter" (make-pair "Käse" empty)))

; Liste mit den Zahlen 1 2 3
(define n1 (make-pair 1 (make-pair 2 (make-pair 3 empty))))
; Liste mit den Zahlen e und pi
(define n2 (make-pair 2.7183 (make-pair 3.14159 empty)))
; Liste mit den Zahlen 2 3 5 7
(define n3 (make-pair 2 (make-pair 3 (make-pair 5 (make-pair 7 empty)))))

(first n1)
(first n2)
(first n3)

(rest n1)
(rest n2)
(rest n3)

; Summe der Elemente einer Liste von Zahlen berechnen
(: list-sum (a-list -> number))

(check-expect (list-sum empty) 0)
(check-expect (list-sum n1) 6)
(check-within (list-sum n2) 5.85989 0.001)
(check-expect (list-sum n3) 17)

(define list-sum
  (lambda (lis)
    (cond
      ((empty? lis) 0)
      ((pair? lis)
       (+ (first lis) (list-sum (rest lis)))))))

; sind alle Zahlen aus einer Liste positiv?
(: all-positive? (a-list -> boolean))

(check-expect (all-positive? empty) #t)
(check-expect (all-positive? n1) #t)
(check-expect (all-positive? n2) #t)
(check-expect (all-positive? n3) #t)
(check-expect (all-positive? (make-pair -5 empty)) #f)
(check-expect (all-positive? (make-pair 0 empty)) #f)
(check-expect (all-positive? (make-pair 1 (make-pair -2 empty))) #f)

(define all-positive?
  (lambda (lis)
    (cond
      ((empty? lis) #t)
      ((pair? lis)
       (and (> (first lis) 0)
            (all-positive? (rest lis)))))))

; Liste von Zeichenketten
(define s1 (make-pair "Herbert" (make-pair "Mike" empty)))
 
; Ein Kugelschreiber hat:
; - Farbe
; - noch Tinte oder nicht
(define-record-procedures pen
  make-pen pen?
  (pen-color pen-ink?))
(: make-pen (string boolean -> pen))
(: pen? (any -> boolean))
(: pen-color (pen -> string))
(: pen-ink? (pen -> boolean))

; roter Kugelschreiber, der noch schreibt
(define p1 (make-pen "red" #t))
; schwarzer Kugelschreiber, der nicht mehr schreibt
(define p2 (make-pen "black" #f))
; grüner Kugelschreiber, der noch schreibt
(define p3 (make-pen "green" #t))

; Liste aus den drei obigen Kugelschreibern
(define pl1 (make-pair p1 (make-pair p2 (make-pair p3 empty))))

; AB HIER HALDE:

; Liste bestimmter Länge bauen
(: build-list (natural %a -> a-list))

(check-expect (build-list 0 5) empty)
(check-expect (build-list 1 5) (make-pair 5 empty))
(check-expect (build-list 3 5) 
              (make-pair 5 (make-pair 5 (make-pair 5 empty))))

(define build-list
  (lambda (n el)
    (if (= n 0)
        empty
        (make-pair el (build-list (- n 1) el)))))