;; 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 numlist) (read-case-sensitive #f) (teachpacks ()) (deinprogramm-settings #(#f write repeating-decimal #f #t none explicit #f ())))
; Zahlenlisten (numlist)

; Eine nicht-leere Zahlenliste nonempty-numlist) besteht aus
; - einem ersten Element (number)
; - einer Restliste (numlist)
(define-record-procedures nonempty-numlist
  cons ;statt make-nonempty-numlist
  cons?
  (first rest))

; Eine Zahlenlist ist eins der folgenden:
; - eine leere Liste (empty-list)
; - eine nicht-leere Zahlenliste (nonempty-numlist)
(define numlist
  (signature (mixed empty-list
                    nonempty-numlist)))

(: cons (number numlist -> nonempty-numlist))
(: cons? (any -> boolean))
(: first (nonempty-numlist -> number))
(: rest  (nonempty-numlist -> numlist))

(define list2 (cons 1 (cons 2 empty)))
(define list3 (cons 1 (cons 2 (cons 3 empty))))
(define prim4 (cons 2 (cons 3 (cons 5 (cons 7 empty)))))


;;;;;;; Operationen auf Listen

; Bestimme die Summe aller Elemente einer Zahlenlist
(: list-sum (numlist -> number))

(check-expect (list-sum empty) 0)
(check-expect (list-sum list2) 3)
(check-expect (list-sum list3) 6)
(check-expect (list-sum prim4) 17)

#;(define list-sum
  (lambda (xs)
    ...))

; Konstruktionsschablone: gemischte Daten als Eingabe
#;(define list-sum
  (lambda (xs)
    (cond ((empty? xs) ...)
          ((cons?  xs) ...))))

; einzelnen Teile ausfüllen: Testfall + Konstruktionsschablone
#;(define list-sum
  (lambda (xs)
    (cond ((empty? xs) 0)
          ((cons?  xs) ...(first xs)...(rest xs)...))))

; Von der Resliste wird die Summe benötigt:
#;(define list-sum
  (lambda (xs)
    (cond ((empty? xs) 0)
          ((cons?  xs) ...(first xs)...(list-sum (rest xs))...))))

; Zusammenkombinieren
#;(define list-sum
  (lambda (xs)
    (cond ((empty? xs) 0)
          ((cons?  xs) (+ (first xs)
                          (list-sum (rest xs)))))))

; Vereinfache, da zwei Zweige:
(define list-sum
  (lambda (xs)
    (if (empty? xs)
        0
        (+ (first xs)
           (list-sum (rest xs))))))