;;
;; 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))))
    (eval expr)
    (assert (= a 1))
    (assert (= b 2))))