test.snap

; vi: filetype=scheme

; args
(println "args:" args)

; tail recursion
(println "tail recursion:")
(def countdown (fn [x]
           (if (> x 0)
             (begin (println x) (recur (- x 1)))
             0)
           ))

(print
  (countdown 1000))


; let
(println "let:")
(println (let [[a 1]
               [b 2]]
           (+ a b)))

; closure
(println "closure:")
(def inc (fn [x]
             (fn []
                 (begin
                   (set! x (+ x 1))
                   x)
                 )
             ))

(def inc1 (inc 0))
(println (inc1))
(println (inc1))
(println (inc1))
(println (inc1))

(def counter (fn [n]
                 (let [[s 0]]
                   (fn []
                       (let [[c s]]
                         (if (< s n)
                           (begin (set! s (+ s 1)) c)
                           nil
                           )
                         )
                       )
                   )
                 ))

(def a (counter 10))
((fn []
     (let [[r (a)]]
           (if (nil? r) nil (begin (println r) (recur)))
           )
     ))

; recursion
(println "recursion:")
(def fact (fn [n]
              (if (= n 1) 1
                (* n (fact (- n 1)))
                )
              ))
(println (fact 20))

; loop
(println "loop:")
(def i 0)
(println
  ((fn [n]
        (println n) (set! i (+ i 10)) (if (< n 9) (recur (+ n 1)) n)
        ) 0)
  )
(println i)

; fibonacci
(println "fibonacci:")
(def fib
     (fn [c p n]
         (println c)
         (if (> n 0)
           (recur p (+ c p) (- n 1))
            nil
           )
         )
     )
(fib 1 1 1000)

; error
(def recerr (fn [n]
             (println n)
             (if (= n 1)
               (begin (println "Going to throw") (raise :err "Inside a recursive func"))
               (recerr (- n 1)))
             )
     )

;; varargs
;(print "varargs:")
;((fn (a b c...)
;    (print a b c)) 1 2 3 4)
;
;