;; Testing cons function
(cons 1 (list))
;=>(1)
(cons 1 (list 2))
;=>(1 2)
(cons 1 (list 2 3))
;=>(1 2 3)
(cons (list 1) (list 2 3))
;=>((1) 2 3)

(def! a (list 2 3))
(cons 1 a)
;=>(1 2 3)
a
;=>(2 3)

;; Testing concat function
(concat)
;=>()
(concat (list 1 2))
;=>(1 2)
(concat (list 1 2) (list 3 4))
;=>(1 2 3 4)
(concat (list 1 2) (list 3 4) (list 5 6))
;=>(1 2 3 4 5 6)
(concat (concat))
;=>()
(concat (list) (list))
;=>()

(def! a (list 1 2))
(def! b (list 3 4))
(concat a b (list 5 6))
;=>(1 2 3 4 5 6)
a
;=>(1 2)
b
;=>(3 4)

;; Testing regular quote
(quote 7)
;=>7
(quote (1 2 3))
;=>(1 2 3)
(quote (1 2 (3 4)))
;=>(1 2 (3 4))

;; Testing simple quasiquote
(quasiquote nil)
;=>nil
(quasiquote 7)
;=>7
(quasiquote a)
;=>a
(quasiquote {"a" b})
;=>{"a" b}

;; Testing quasiquote with lists
(quasiquote ())
;=>()
(quasiquote (1 2 3))
;=>(1 2 3)
(quasiquote (a))
;=>(a)
(quasiquote (1 2 (3 4)))
;=>(1 2 (3 4))
(quasiquote (nil))
;=>(nil)
(quasiquote (1 ()))
;=>(1 ())
(quasiquote (() 1))
;=>(() 1)
(quasiquote (1 () 2))
;=>(1 () 2)
(quasiquote (()))
;=>(())
;; (quasiquote (f () g (h) i (j k) l))
;; =>(f () g (h) i (j k) l)

;; Testing unquote
(quasiquote (unquote 7))
;=>7
(def! a 8)
;=>8
(quasiquote a)
;=>a
(quasiquote (unquote a))
;=>8
(quasiquote (1 a 3))
;=>(1 a 3)
(quasiquote (1 (unquote a) 3))
;=>(1 8 3)
(def! b (quote (1 "b" "d")))
;=>(1 "b" "d")
(quasiquote (1 b 3))
;=>(1 b 3)
(quasiquote (1 (unquote b) 3))
;=>(1 (1 "b" "d") 3)
(quasiquote ((unquote 1) (unquote 2)))
;=>(1 2)

;; Quasiquote and environments
(let* (x 0) (quasiquote (unquote x)))
;=>0

;; Testing splice-unquote
(def! c (quote (1 "b" "d")))
;=>(1 "b" "d")
(quasiquote (1 c 3))
;=>(1 c 3)
(quasiquote (1 (splice-unquote c) 3))
;=>(1 1 "b" "d" 3)
(quasiquote (1 (splice-unquote c)))
;=>(1 1 "b" "d")
(quasiquote ((splice-unquote c) 2))
;=>(1 "b" "d" 2)
(quasiquote ((splice-unquote c) (splice-unquote c)))
;=>(1 "b" "d" 1 "b" "d")

;; Testing symbol equality
(= (quote abc) (quote abc))
;=>true
(= (quote abc) (quote abcd))
;=>false
(= (quote abc) "abc")
;=>false
(= "abc" (quote abc))
;=>false
(= "abc" (str (quote abc)))
;=>true
(= (quote abc) nil)
;=>false
(= nil (quote abc))
;=>false

;>>> deferrable=True
;;
;; -------- Deferrable Functionality --------

;; Testing ' (quote) reader macro
'7
;=>7
'(1 2 3)
;=>(1 2 3)
'(1 2 (3 4))
;=>(1 2 (3 4))

;; Testing cons and concat with vectors

(cons 1 [])
;=>(1)
(cons [1] [2 3])
;=>([1] 2 3)
(cons 1 [2 3])
;=>(1 2 3)
(concat [1 2] (list 3 4) [5 6])
;=>(1 2 3 4 5 6)
(concat [1 2])
;=>(1 2)

;>>> optional=True
;;
;; -------- Optional Functionality --------

;; Testing ` (quasiquote) reader macro
`7
;=>7
`(1 2 3)
;=>(1 2 3)
`(1 2 (3 4))
;=>(1 2 (3 4))
`(nil)
;=>(nil)

;; Testing ~ (unquote) reader macro
`~7
;=>7
(def! a 8)
;=>8
`(1 ~a 3)
;=>(1 8 3)
(def! b '(1 "b" "d"))
;=>(1 "b" "d")
`(1 b 3)
;=>(1 b 3)
`(1 ~b 3)
;=>(1 (1 "b" "d") 3)

;; Testing ~@ (splice-unquote) reader macro
(def! c '(1 "b" "d"))
;=>(1 "b" "d")
`(1 c 3)
;=>(1 c 3)
`(1 ~@c 3)
;=>(1 1 "b" "d" 3)

;>>> soft=True

;; Testing vec function

(vec (list))
;=>[]
(vec (list 1))
;=>[1]
(vec (list 1 2))
;=>[1 2]
(vec [])
;=>[]
(vec [1 2])
;=>[1 2]

;; Testing that vec does not mutate the original list
(def! a (list 1 2))
(vec a)
;=>[1 2]
a
;=>(1 2)

;; Test quine
((fn* (q) (quasiquote ((unquote q) (quote (unquote q))))) (quote (fn* (q) (quasiquote ((unquote q) (quote (unquote q)))))))
;=>((fn* (q) (quasiquote ((unquote q) (quote (unquote q))))) (quote (fn* (q) (quasiquote ((unquote q) (quote (unquote q)))))))

;; Testing quasiquote with vectors
(quasiquote [])
;=>[]
(quasiquote [[]])
;=>[[]]
(quasiquote [()])
;=>[()]
(quasiquote ([]))
;=>([])
(def! a 8)
;=>8
`[1 a 3]
;=>[1 a 3]
(quasiquote [a [] b [c] d [e f] g])
;=>[a [] b [c] d [e f] g]

;; Testing unquote with vectors
`[~a]
;=>[8]
`[(~a)]
;=>[(8)]
`([~a])
;=>([8])
`[a ~a a]
;=>[a 8 a]
`([a ~a a])
;=>([a 8 a])
`[(a ~a a)]
;=>[(a 8 a)]

;; Testing splice-unquote with vectors
(def! c '(1 "b" "d"))
;=>(1 "b" "d")
`[~@c]
;=>[1 "b" "d"]
`[(~@c)]
;=>[(1 "b" "d")]
`([~@c])
;=>([1 "b" "d"])
`[1 ~@c 3]
;=>[1 1 "b" "d" 3]
`([1 ~@c 3])
;=>([1 1 "b" "d" 3])
`[(1 ~@c 3)]
;=>[(1 1 "b" "d" 3)]

;; Misplaced unquote or splice-unquote
`(0 unquote)
;=>(0 unquote)
`(0 splice-unquote)
;=>(0 splice-unquote)
`[unquote 0]
;=>[unquote 0]
`[splice-unquote 0]
;=>[splice-unquote 0]

;; Debugging quasiquote
(quasiquoteexpand nil)
;=>nil
(quasiquoteexpand 7)
;=>7
(quasiquoteexpand a)
;=>(quote a)
(quasiquoteexpand {"a" b})
;=>(quote {"a" b})
(quasiquoteexpand ())
;=>()
(quasiquoteexpand (1 2 3))
;=>(cons 1 (cons 2 (cons 3 ())))
(quasiquoteexpand (a))
;=>(cons (quote a) ())
(quasiquoteexpand (1 2 (3 4)))
;=>(cons 1 (cons 2 (cons (cons 3 (cons 4 ())) ())))
(quasiquoteexpand (nil))
;=>(cons nil ())
(quasiquoteexpand (1 ()))
;=>(cons 1 (cons () ()))
(quasiquoteexpand (() 1))
;=>(cons () (cons 1 ()))
(quasiquoteexpand (1 () 2))
;=>(cons 1 (cons () (cons 2 ())))
(quasiquoteexpand (()))
;=>(cons () ())
(quasiquoteexpand (f () g (h) i (j k) l))
;=>(cons (quote f) (cons () (cons (quote g) (cons (cons (quote h) ()) (cons (quote i) (cons (cons (quote j) (cons (quote k) ())) (cons (quote l) ())))))))
(quasiquoteexpand (unquote 7))
;=>7
(quasiquoteexpand a)
;=>(quote a)
(quasiquoteexpand (unquote a))
;=>a
(quasiquoteexpand (1 a 3))
;=>(cons 1 (cons (quote a) (cons 3 ())))
(quasiquoteexpand (1 (unquote a) 3))
;=>(cons 1 (cons a (cons 3 ())))
(quasiquoteexpand (1 b 3))
;=>(cons 1 (cons (quote b) (cons 3 ())))
(quasiquoteexpand (1 (unquote b) 3))
;=>(cons 1 (cons b (cons 3 ())))
(quasiquoteexpand ((unquote 1) (unquote 2)))
;=>(cons 1 (cons 2 ()))
(quasiquoteexpand (a (splice-unquote (b c)) d))
;=>(cons (quote a) (concat (b c) (cons (quote d) ())))
(quasiquoteexpand (1 c 3))
;=>(cons 1 (cons (quote c) (cons 3 ())))
(quasiquoteexpand (1 (splice-unquote c) 3))
;=>(cons 1 (concat c (cons 3 ())))
(quasiquoteexpand (1 (splice-unquote c)))
;=>(cons 1 (concat c ()))
(quasiquoteexpand ((splice-unquote c) 2))
;=>(concat c (cons 2 ()))
(quasiquoteexpand ((splice-unquote c) (splice-unquote c)))
;=>(concat c (concat c ()))
(quasiquoteexpand [])
;=>(vec ())
(quasiquoteexpand [[]])
;=>(vec (cons (vec ()) ()))
(quasiquoteexpand [()])
;=>(vec (cons () ()))
(quasiquoteexpand ([]))
;=>(cons (vec ()) ())
(quasiquoteexpand [1 a 3])
;=>(vec (cons 1 (cons (quote a) (cons 3 ()))))
(quasiquoteexpand [a [] b [c] d [e f] g])
;=>(vec (cons (quote a) (cons (vec ()) (cons (quote b) (cons (vec (cons (quote c) ())) (cons (quote d) (cons (vec (cons (quote e) (cons (quote f) ()))) (cons (quote g) ()))))))))