glisp/tests/closure.glisp

(defn foldl [lst fun acc]
    (cond
        (empty? lst) acc
        (foldl (cdr lst) fun (fun (car lst) acc))
		))
        
(defn filter [lst fun]
    (foldl lst
            (fn [x l]
                (cond
                    (fun x) (append l x)
                    l))
            [])
)

(defn g-map [fun lst]
	(foldl lst (fn [x l] (fun x)) []))

(defn even? [x]
    (cond
        (number? x)
            (cond
                (float? x) false
                (= (bit-and x 1) 0))
            false
            ))

(defn newStore [items]
	(let* [
		idx [-1]
		fun (fn []
				(cond
					(< (+ (aget idx 0) 1) (len items))
						(begin
							(aset! idx 0 (+ (aget idx 0) 1))
							(aget items (aget idx 0))
						)
					()))
			] fun))


(def evens (newStore [2 4 6 8 10]))

(map (fn [x]
		(assert (= x (evens))))
    (filter [1 2 3 4 5 6 7 8 9 10] even?)
)

(def s (newStore [10 9 8 7 6 5 4 3 2 1]))
(g-map (fn [x] (assert (= x (s)))) [10 9 8 7 6 5 4 3 2 1])
(def s (newStore [10 9 8 7 6 5 4 3 2 1]))
(map (fn [x] (assert (= x (s)))) [10 9 8 7 6 5 4 3 2 1])

(def decending (newStore [10 9 8 7 6 5 4 3 2 1]))


(def s (newStore [10 9 8 7 6 5 4 3 2 1]))

(defn drainStore []
	(let [ v (s) ]
		(cond
			(empty? v) (assert (= (decending) ()))
			((begin
				(assert (= (decending) v))
				(drainStore)))))
	)
		

(drainStore)

(def a 1)
(defn enclosure []
  (let [func1 (fn [thunk] (let [a 2] (thunk)))
         func2 (fn [] (assert (= a 1)))]
    (func1 func2)))

(enclosure)