(load "prekode2b.scm")

;;;;;;;
;; 1 ;;
;;;;;;;

;; A

(define (make-counter)
  (define count 0)
  (lambda ()
    (set! count (+ count 1))
    count))

;; B

;; Se 1.b.pdf

;;;;;;;
;; 2 ;;
;;;;;;;

;; A

(define (make-stack items)
  (define (push-item! item)
    (set! items (cons item items)))

  (define (push! items)
    (if (null? items)
        '()
        (begin (push-item! (car items))
               (push! (cdr items)))))

  (define (pop!)
    (if (null? items)
        '()
        (let ((item (car items)))
          (set! items (cdr items))
          item)))

  (lambda (symbol . args)
    (cond ((eq? symbol 'push!) (push! args))
          ((eq? symbol 'pop!) (pop!))
          ((eq? symbol 'stack) items)
          (else (error "Invalid symbol")))))

;; B

(define (push! s . args)
  (apply s 'push! args))

(define (pop! s)
  (s 'pop!))

(define (stack s)
  (s 'stack))

;;;;;;;
;; 3 ;;
;;;;;;;

;; A

;; Etter define: 3.a-befor.pdf
;; Etter set-cdr!: 3.a-after.pdf

;; bar er en sirkulær liste etter kallet på set-cdr!. Cons-celle 4 peker på
;; cons-celle 2, så (cdr (cdddr bar)) gir celle 2 og (cddr (cdddr bar))
;; gir celle 3.

;; B

;; Etter define: 3.b-before.pdf
;; Etter den første set-car!: 3.b-after.pdf

;; Først setter vi car av bar til cdr av bar, så bar er en cons-celle
;; hvor både car og cdr peker på en liste. ((a towel) a towel) er måten
;; scheme viser det. Etter den andre set-car! erstatter vi a med 42, og siden
;; car og cdr peker på samme cons-celle, endrer det på begge. Resultatet blir
;; dermed ((42 towel) 42 towel).

;; C

;; (list? bar) returnerer #f fordi bar er sirkulær.
;; (list? bah) returnerer #t, fordi den er en gyldig liste, terminert med
;; en tom liste, hvor det første elementet av listen bare tilfeldigvis er en
;; annen liste. Predikatet list? bryr seg ikke om at det første elementet
;; er samme cons-celle som resten av listen.

;;;;;;;
;; 4 ;;
;;;;;;;

;; A/B

(define (mem symbol proc)
  (define (memoize proc)
    (define tbl (make-table))

    ;; Run the procedure and store the result in the table
    (define (run args)
      (let ((val (apply proc args)))
        (insert! args val tbl)
        val))

    ;; Run the procedure if the arguments aren't in the table yet,
    ;; otherwise just return the table entry
    (define (run-memoized args)
      (let ((val (lookup args tbl)))
        (if (eq? val #f)
            (run args)
            val)))

    ;; If the first argument is _get-proc, return the original procedure.
    ;; Otherwise, run the procedure memoized
    (define (fn . args)
      (if (and (not (null? args)) (eq? (car args) '_get-proc))
          proc
          (run-memoized args)))

    fn)

  ;; Calling the procedure with the argument `_get-proc will return the
  ;; original procedure.
  (define (unmemoize proc)
    (proc '_get-proc))

  (cond ((eq? symbol 'memoize) (memoize proc))
        ((eq? symbol 'unmemoize) (unmemoize proc))
        (else (error "Invalid symbol"))))

;; C

;; Fib-funksjonen kaller seg selv. Hvis vi lager en ny funksjon
;; mem-fib, som er memoisert, hvil ikke de rekursive kallene på fib
;; i fib-prosedyren være memoisert. Den eneste måten å få de rekursive
;; kallene til å også bli memoisert er å endre variabelen, slik at `fib`
;; refererer til den memoiserte funksjonen selv når den kalles rekursivt.