spaik 0.2.2

A Lisp
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

;;
;; Some tests implementing common functions
;;

(defun fib (n)
  (let ((a 0)
        (b 1)
        (t 0))
    (while (> n 0)
      (println a)
      (set t (+ a b))
      (set b a)
      (set a t)
      (dec n 1))
    b))

(defun fib-rec-0 (n a b)
  (if (> n 0)
      (progn
        (println a)
        (fib-rec-0 (- n 1) b (+ a b)))
    b))

(defun fib-rec (n)
  (fib-rec-0 n 0 1))

(defun fact (n)
  (let ((res 1) (upto 1))
    (while (<= upto n)
      (println res)
      (set res (* upto res))
      (inc upto 1))
    res))

(defun fact-silent (n)
  (let ((res 1))
    (while (> n 0)
           (set res (* n res))
           (dec n 1))
    res))

(defun fact-rec (n)
  (if (> n 0)
      (* n (println (fact-rec (- n 1))))
    1))

(defun sum (xs)
  (let ((x 0)
        (acc 0))
    (while xs
           (set x (car xs))
           (set acc (+ x acc))
           (set xs (cdr xs)))
    acc))

(defun countdown-list (n)
  (if (> n 0)
      (cons n (countdown-list (- n 1)))
    n))


;;; I want this
;; (defun asm-jmp-if (cnd inst label)
;;   (while (= (car cnd) 'not)
;;     (set cnd (cadr cnd))
;;     (set inst (not inst)))
;;   `(inline
;;      ,cnd
;;      (,inst label)))
;; (defun asm-loop (cnd jmp-inst &body body)
;;   (let ((loop-begin (gensym))
;;         (loop-end (gensym)))
;;     `(inline
;;        (#label ,loop-begin)
;;        (asm-jmp-if ,cnd ,jmp-inst ,loop-end)
;;        (progn ,@body)
;;        (#pop 1)
;;        (#jmp ,loop-begin)
;;        (#label ,loop-end))))
;; (defmacro while (cnd &body body)
;;   (asm-loop cnd #'jn body))
;; (defmacro until (cnd &body body)
;;   (asm-loop cnd #'jt body))
;; (println `((fib-max ,fib-max)
;;            (fact-max ,fact-max)
;;            ,@lst))

(defun main ()
  (let ((fib-max 20)
        (fact-max 12)
        (lst '(1 2 3)))
    (println "Fibonacci test:")
    (fib fib-max)
    (println "")

    (println "Recursive fibonacci test:")
    (fib-rec fib-max)
    (println "")

    (println "Factorial test:")
    (fact fact-max)
    (println "")

    (println "Recursive factorial test:")
    (fact-rec fact-max)
    (println "")

    (println "Computing ...")
    (let ((n 1000))
      (while (> n 0)
        (fact-silent 20)
        (dec n 1)))
    (println "Done.")

    (println '(1 2 3))
    (println (list 1 2 3 4))
    (println (list 1 2 3 4 (list 3 2 1) (list 3 2)))
    (println (append (list 1 2) (list 3 4)))
    (println (append (list 1 2) 3))
    (println "Sum of list:")
    (println (sum (list 1 2 3 4 5 6 7 8 9)))
    (println (countdown-list 20))
    1337))