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

;; A: 30
;; (4 + 2) * 5 er 30.

;; B: application: not a procedure;
;; Her prøver vi å kalle på 5 som en prosedyre med (5),
;; men 5 er ikke en prosedyre.

;; C: application: not a procedure;
;; Her prøver vi å kalle på 4 som en prosedyre med (4 + 5),
;; men 4 er ikke en prosedyre.

;; D: 21
;; Vi definerer et symbol kalt bar på linje 1, og gir den verdien
;; (/ 42 2), som er 21. Linje 2 sin bar evalueres til verdien til bar,
;; altså 21.

;; E: 10
;; bar er allerede definert som 21. 21 - 11 = 10.

;; F: 12
;; (21 * 3 * 4 * 1) / 21 er 12.

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

;; A

;; "or" evaluerer bare frem til den første verdien som ikke er #f.
;; Siden "piff!" ikke er #f, evalueres hverken "paff!" eller (zero? (1 - 1)),
;; så det spiller ingen rolle at (zero? (1 - 1)) ikke kan evalueres.

;; "and" evaluerer bare frem til den første verdien som er #f.
;; Siden (= 1 2) er #f, evalueres hverken "piff!", "paff!" eller
;; (zero? (1 - 1)), så det spiller ingen rolle at (zero? (1 - 1)) ikke
;; kan evalueres.

;; "if" evaluerer bare det andre uttrykket hvis det første ikke er #f,
;; og evaluerer bare det tredje uttrykket hvis det første er #f.
;; Siden (positive? 42) er #t, evalueres bare "poff!", ikke
;; (i-am-undefined).

;; B

;; Med if:

(define (sign x)
  (if (negative? x) -1
    (if (positive? x) 1 0)))

;; Med cond:

(define (sign x)
  (cond ((> x 0) 1)
        ((< x 0) -1)
        ((= x 0) 0)))

;; C

;; Med and og or:

(define (sign x)
  (or (and (> x 0) 1)
      (and (< x 0) -1)
           0))

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

;; A

(define (add1 x) (+ x 1))
(define (sub1 x) (- x 1))

;; B

(define (plus a b)
  (if (zero? b) a
    (plus (add1 a) (sub1 b))))

;; C

;; Prosedyren gir opphav til en iterativ prosess. Dette er fordi
;; det siste som skjer i prosedyren er at den kaller på seg selv.
;; Prosedyren hadde vært rekursiv hvis prosedyren hadde brukt resultatet
;; av å kalle seg selv til noe.

;; Her har vi en rekursiv definisjon av plus:

(define (plus-rekursiv a b)
  (if (zero? b) a
    (add1 (plus-rekursiv a (sub1 b)))))

;; D

;; Dette er forenklet ved å la power-iter bruke variablene b og n fra
;; power-close-to, istedenfor å ta variablene som argumenter.
;; Jeg har også kalt iteratorfunksjonen iter, siden den er lokal.

(define (power-close-to b n)
  (define (iter e)
    (if (> (expt b e) n)
      e
      (iter b n (+ 1 e))))
  (iter 1))

;; E

;; Det er ikke mulig å forenkle fib-iter. Selv om fib-iter kalles med
;; fib sin n, kan vi ikke bruke den i fib-iter, fordi vi trekker fra 1
;; for hver iterasjon, noe som krever at vi gir det som et argument.