;;
;; let testing
;;
;; (assert (not (bound? var1)))
;; (assert (not (bound? var2)))
;; (assert (not (bound? var3)))
;; (let ((var1 1)
;;       (var2 [1 2 3])
;;       (var3 {1 2 3 4}))
;;   (assert (bound? var1))
;;   (assert (bound? var2))
;;   (assert (bound? var3))
;;   (assert (= var1 1))
;;   (assert (= var2 [1 2 3]))
;;   (assert (= var3 {1 2 3 4})))

;; (assert (not (bound? var1)))
;; (assert (not (bound? var2)))
;; (assert (not (bound? var3)))

;; (assert (= (let ((val 'sym))
;;              val)
;;            'sym))

;; (assert (= (let ()
;;              'sym)
;;            'sym))
;; ;;
;; ;; Quasiquote testing
;; ;;
;; (assert (= '() `()))

;; (assert (= '(1 1 2)
;;            `(1 1 2)))

;; (assert (= '(1  1 2)
;;            `(1 ,1 2)))

;; (assert (= '(1  1        2)
;;            `(1 ,(- 10 9) 2)))

;; (assert (= '(1 1 2)
;;            `(1 ,@(list 1 2))))

;; (let ((body '(2 3)))
;;   (assert (= '(1 2 3)
;;              `(1 ,@body))))

(let ((body    '((define a 1)
                 (define b 2)))
      (imports '()))
  (let ((expr `(begin ,@(map (lambda (x) `(import ,x)) imports) ,@body)))
    (assert (= '(begin (define a 1) (define b 2)) expr))
    (eval expr)
    (assert (= a 1))
    (assert (= b 2))
    ))