#|
TESTS:

; int objects evaluate to themselves, not the Scheme ints they contain
> (eval-prog (I 0))
#<int>
> (int-num (eval-prog (I 0)))
0
; non-nested add evaluation
> (int-num (eval-prog (add (I 1) (I 2))))
3
; nested adds
> (int-num (eval-prog (add (add (I 0)
                                (I 1))
                           (I 2))))
3

; function creation and application
> (int-num (eval-prog (make-app (make-fun #f "n"
                                          (add (I 1) (V "n")))
                                (I 2))))
3

; testing mlet and list creation:
> (int-num (eval-prog (make-mlet "lst" (make-apair (I 0) (make-apair (I 1) (make-aunit)))
                                 (make-fst (make-snd (V "lst"))))))
1

; Testing support for recursion with a silly recursive adder function:
> (define (recadd n)
    (if (> n 10)
        n
        (+ (recadd (+ n 1)) (recadd (+ n 2)))))
> (recadd 4)
387
> (define recadd-MUPL (make-fun "recadd-MUPL" "n"
                                (make-ifgreater (V "n") (I 10)
                                                (V "n")
                                                (make-add (make-app (V "recadd-MUPL") (make-add (V "n") (I 1)))
                                                          (make-app (V "recadd-MUPL") (make-add (V "n") (I 2)))))))
> (int-num (eval-prog (app recadd-MUPL (I 4))))
387

; testing mlet* over an add expression, with bindings that have to be made sequentially
> (define bindings (make-apair (make-apair "a" (I 1))
                               (make-apair (make-apair "b" (make-add (V "a") (I 1)))
                                           (make-aunit))))
> (int-num (eval-prog (mlet*2 bindings
                              (make-add (V "a") (V "b")))))
3

; list length function
> (int-num (eval-prog (make-app (make-fun "len" "lst"
                                          (make-ifaunit (V "lst")
                                                        (I 0)
                                                        (make-add (I 1)
                                                                  (make-app (V "len") (make-snd (V "lst"))))))
                                (make-apair (I 1) (make-apair (I 2) (make-aunit))))))
2

; currying -- equivalent to (((lambda (n) (lambda (m) (+ n m))) 1) 2)
> (int-num (eval-prog (make-app (make-app (make-fun #f "n"
                                                    (make-fun #f "m"
                                                              (make-add (V "n") (V "m"))))
                                          (I 1))
                                (I 2))))
3

; using mupl-map
> (muplintlist-to-list (eval-prog (make-app (make-app mupl-map (fun #f "n"
                                                                    (make-add (V "n") (I 1))))
                                            (make-apair (I 1) (make-apair (I 2) (make-aunit))))))
(2 3)

; equivalent to the above, using mupl-mapAddN
> (muplintlist-to-list (eval-prog (make-app (make-app mupl-mapAddN (I 1))
                                            (make-apair (I 1) (make-apair (I 2) (make-aunit))))))
(2 3)

|#