resource-bundle

(define fmt
    (lambda (x . rest)
        (if (and (not (null? rest)) (number? (head rest)) (= (head rest) 0))
            (display x)
            (begin
                (display x)
                (display "\n")
            )
        )
    )
)
(define flatten
    (lambda (l)
        (flatMap l (lambda (x) x))
    )
)
; Def.:
; procedure flatmap(L,f)
;   if isList(L.head) then
;       return flatmap(L.head)
;   else
;   if length(L)>1 then
;       return f(L.head)::flatmap(L.tail)
;   else
;       return f(L.head)


;       Monadischer Typ "Liste"
; unit: T -> List[T]                        "tau": natürliche Transf.* der Liste
; map: (T->U),List[T] -> List[U]            map gehört zum Funktor* der Liste
; flatten: List[List[T]] -> List[T]         "mu": natürliche Transf. der Liste
;
; flatmap: (T->List[U]),List[T] -> List[U]
;
; * Funktor F: Struktur mit Abbildung von F[T] auf F[U] mittels einer Funktion T->U
; * natürliche Transformation: Abbildung von Funktor auf Funktor
;
;
;       Map, Flatten, FlatMap:
;           (Implementierung)
; flatMap(l: List[T],f: (T->U)) = flatMap(l,(t:T=>f(t)));
; map(l: List[T],f: (T->U)) = flatMap(l,(t:T=>unit(f(t))));
; flatten(l: List[List[T]]) = flatMap(l,(x:List[T]=>x));
;
(define flatMap
    (lambda (l f)
        (if (and (list? l) (not (null? l)) (procedure? f))
            (if (list? (car l))
                (flatMap (car l) f)
                (if (> (length l) 1)
                    (cons (f (car l)) (flatMap (cdr l) f))
                    (cons (f (car l)) ()) ;make a proper list
                )
            )
        )
    )
)
(define reduce
    (lambda (l f e)
        (if (and (list? l) (not (null? l)) (procedure? f))
            (if (list? (car l))
                (reduce (car l) f e)
                (if (> (length l) 1)
                    (f (car l) (reduce (cdr l) f e))
                    (f (car l) e)
                )
            )
        )
    )
)
(define contains
    ;;; get the index, if any, of an object in a list
    (lambda (l0 x . i0)
        (let (  (l (flatten l0)) (i (if (null? i0) 0 (car i0)))  )
            (if (and (list? l) (not (null? l)) (or (number? x) (string? x) (symbol? x)))
                (begin
                    ;(fmt i)
                    (if (equal? (car l) x) ;equal? used (to enable string comparison)
                        (+ i 1) ; 1-based
                        (contains (cdr l) x (+ i 1))
                    )
                )
                #f
            )
        )
    )
)
; elem: own implementation of list-ref
(define elem
    (lambda (l i)
        (if (and (list? l) (>= (length l) 1))
            (if (= i 1) ; makes the function 1-based
                (car l)
                (elem (cdr l) (- i 1))
            )
        )
    )
)
(define id (lambda (x) x) )
(define (make-list length value)
    (if (< length 1)
        '()
        (cons value (make-list (- length 1) value))
    )
)
(define write-out
    (lambda (filename data)
        (let ((out (open-output-file filename)) )
            (write data out)
            (close-output-port out)
        )
    )
)
(define read-in
    (lambda (filename)
        (let ((in (open-input-file filename)) )
            (let cont ((d (read in))) ;cont is a 'named let'
                (if (eof-object? d)
                    (begin
                        (close-input-port in)
                        '()
                    )
                    (cons d (cont (read in)))
                )
            )
        )
    )
)
;           Named let
;   (let NAME ((VAR1 VAL1)...)
;       (EXP1)...
;   )
;
; - wie im unbenannten let, werden alle VARs an VALs gebunden (gültig im folgenden Block)
; - zusätzlich wird NAME im Block an eine Prozedur gebunden,
;       deren Argumente dann an die jeweilige VAR gebunden werden
; -> das ermöglicht eine innere Rekursion in einem Lambda