;; Prozedurfabrik für Inkrementier-Prozeduren

(define make-add
  (lambda (a)
    (lambda (b)
      (+ a b))))

;; Komposition zweier Prozeduren

(define compose
  (lambda (f g)
    (lambda (x)
      (f (g x)))))

;; Wiederholte Prozeduranwendung

(define repeat
  (lambda (n proc)
    (if (= n 0)
        (lambda (x) x)
        (compose proc (repeat (- n 1) proc)))))

;; Prozedur auf Elemente einer Liste anwenden

(define map
  (lambda (proc l)
    (if (null? l)
        '()
        (cons (proc (car l))
              (map proc (cdr l))))))

;; Prozedur zwischen Listenelementen anwenden

(define fold-right
  (lambda (proc unit l)
    (if (null? l)
	unit
	(proc (car l)
	      (fold-right proc unit (cdr l))))))

;; Elemente zurückgeben, die ein Prädikat erfüllen

(define filter
  (lambda (proc? l)
    (fold-right (lambda (first result)
		  (if (proc? first)
		      (cons first result)
		      result))
		'()
		l)))

;; Testen, ob alle Listenelemente ein Prädikat erfüllen

(define every?
  (lambda (proc? l)
    (fold-right (lambda (first result)
		  (if result
		      (proc? first)
		      #f))
		#t
		l)))

;; EVERY? mit AND

(define every?
  (lambda (proc? l)
    (fold-right (lambda (first result)
		  (and result (proc? first)))
		#t
		l)))
;; Prozedur von links zwischen Listenelementen anwenden

(define fold-left
  (lambda (proc unit l)
    (fold-left-1 proc unit l unit)))

(define fold-left-1
  (lambda (proc unit l result)
    (if (null? l)
	result
	(fold-left-1 proc unit (cdr l) (proc result (car l))))))

;; Erstes Element zurückliefern, das ein Prädikat erfüllt

(define first
  (lambda (proc? l)
    (fold-left (lambda (result first)
		 (if result
		     result
		     (if (proc? first)
			 first
			 #f)))
	       #f
	       l)))

;; FIRST mit AND und OR

(define first
  (lambda (proc? l)
    (fold-left (lambda (result first)
		 (or result
		     (and (proc? first)
			  first)))
	       #f
	       l)))