Question 1:

(i 2)  --> 6
((i 2) (lambda (x) x))  --> error


Question 3:

No!  Look at the common path 001001.  
It leads to an arrow and Int.


Question 4:

(define sum
  (lambda (l)
    (if (null? l)
        0
        (+ (car l) (sum (cdr l))))))

(define f
  (lambda (l)
    (if (= (sum l) 5)
        5
        (if (null? l)
            1
            (+ (sum l) (f (cdr l)))))))

(define sum-cps
  (lambda (l k)
    (if (null? l)
        (k 0)
        (sum-cps (cdr l) (lambda (v1) (k (+ (car l) v1)))))))

(define f-cps
  (lambda (l k)
    (sum-cps l (lambda (v2)
      (if (= v2 5)
          (k 5)
          (if (null? l)
              (k 1)
              (sum-cps l (lambda (v3)
                (f-cps (cdr l) (lambda (v4)
                  (k (+ v3 v4))))))))))))

(define f2
  (lambda (l)
    (f-cps l (lambda (x) x))))

;; (1 l ...)
;; (2 l ...)
;; (3 l ...)
;; (4 v3 ...)

(define sum-fo
  (lambda (l k)
    (if (null? l)
        (apply-cont k 0)
        (sum-fo (cdr l) (cons 1 (cons l k))))))

(define f-fo
  (lambda (l k)
    (sum-fo l (cons 2 (cons l k)))))

(define f3
  (lambda (l)
    (f-fo l '())))

(define apply-cont
  (lambda (k x)
    (if (null? k)
        x
        (case (car k)
              ((1) (apply-cont (cddr k) (+ (car (cadr k)) x)))
              ((2) (if (= x 5) (apply-cont (cddr k) 5)
                               (if (null? (cadr k)) 
                                   (apply-cont (cddr k) 1)
                                   (sum-fo (cadr k) (cons 3 (cdr k))))))
              ((3) (f-fo (cdr (cadr k)) (cons 4 (cons x (cddr k)))))
              ((4) (apply-cont (cddr k) (+ (cadr k) x)))))))


(define l 'dummy)
(define k '())
(define x 'dummy)

(define sum-no
  (lambda ()
    (if (null? l)
        (begin (set! x 0) (apply-cont-fo))
        (begin (set! k (cons 1 (cons l k))) (set! l (cdr l)) (sum-no)))))

(define f-no
  (lambda ()
    (set! k (cons 2 (cons l k))) (sum-no)))

(define f4
  (lambda (l1)
    (set! l l1)
    (f-no)))

(define apply-cont-fo
  (lambda ()
    (if (null? k)
        x
        (case (car k)
              ((1) (set! x (+ (car (cadr k)) x))
                   (set! k (cddr k))
                   (apply-cont-fo))
              ((2) (if (= x 5) (begin 
                                 (set! k (cddr k))
                                 (set! x 5)
                                 (apply-cont-fo))
                               (if (null? (cadr k))
                                   (begin
                                     (set! k (cddr k))
                                     (set! x 1)
                                     (apply-cont-fo))
                                   (begin
                                     (set! l (cadr k))
                                     (set! k (cons 3 (cdr k)))
                                     (sum-no)))))
              ((3) (set! l (cdr (cadr k)))
                   (set! k (cons 4 (cons x (cddr k))))
                   (f-no))
              ((4) (set! x (+ (cadr k) x))
                   (set! k (cddr k))
                   (apply-cont-fo))))))