add vector tests

6 files changed, 19 insertions, 203 deletions

diff --git a/Makefile b/Makefile
index 06e4b38..d1c8fbc 100644
--- a/Makefile
+++ b/Makefile
@@ -21,6 +21,8 @@ tests_bin=$(tests:.c=.bin)
 
 all: bamboo-lisp
 
+staticlib: libbamboo-lisp.a
+
 web: web-bamboo-lisp.js
 
 web-bamboo-lisp.js: $(src)
@@ -37,6 +39,9 @@ src/prelude.c: src/prelude.lisp
 bamboo-lisp:  $(obj) src/main.o 3rdparty/algds/build/lib/libalgds.a
 	gcc $(cflags) -o $@ $^ $(ldflags)
 
+libbamboo-lisp.a: $(obj)
+	ar cr $@ $^
+
 3rdparty/algds/build/lib/libalgds.a:
 	cd 3rdparty/algds && \
 		make profile=$(mode)
diff --git a/Readme.md b/Readme.md
index c10512b..189e4e3 100644
--- a/Readme.md
+++ b/Readme.md
@@ -62,13 +62,9 @@ You can use `load` to load a lisp script into the interpreter:
 (load "my-script.lisp")
 ```
 
-## Documents (WIP)
+## Examples
 
-- [Primitives](https://github.com/mistivia/bamboo-lisp/blob/master/docs/primitives.md)
-
-## Example
-
-See `tests/` for more examples.
+See `tests/` for more examples. The tests alse serve as documented.
 
 ### 1. Y Combinator
 
diff --git a/docs/builtins.md b/docs/builtins.md
deleted file mode 100644
index 0399247..0000000
--- a/docs/builtins.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Built-in Functions
-
-## Type Predicate
-
-## Control Flow
-
-## List
-
-## Boolean
-
-## Character
-
-## String
-
-## Symbol
-
-## Number & Math
-
-## Bitwise Operation
-
-## Debug
-
diff --git a/docs/primitives.md b/docs/primitives.md
deleted file mode 100644
index 749b6c0..0000000
--- a/docs/primitives.md
+++ /dev/null
@@ -1,169 +0,0 @@
-# Primitives
-
-**(assert *expression*)**
-
-Evaluates *expression*. If *expression* evaluates to a non-false,
-non-control-flow value, `assert` returns `#t`. Otherwise, it signals an error
-indicating that the assertion failed, including the string representation of
-the original *expression*.
-
-```lisp
-(assert (= 1 1))
-;; -> #t
-
-(assert (> 1 2))
-;; -> Error
-```
-
----
-
-**(assert-exception *form*)**
-
-Evaluates *form*. If *form* evaluates to an exception signal,
-`assert-exception` returns `#t`. Otherwise, it raises an error indicating that
-no exception was thrown by *form*. This primitive is useful for testing code
-that is expected to throw exceptions.
-
-```lisp
-(assert-exception (throw "This is an exception."))
-;; -> #t
-
-(assert-exception (+ 1 2))
-;; -> Error
-```
-
----
-
-**(assert-error *form*)**
-
-Evaluates *form*. If *form* results in an **error signal**, `assert-error` returns `#t`. Otherwise, it throws an error indicating that *form* did not produce an error. This primitive is useful for writing tests that verify if specific code paths correctly raise errors.
-
-```lisp
-(assert-error (error "This is an error."))
-;; -> #t
-
-(assert-error (+ 1 2))
-;; -> Error
-```
-
----
-
-**(try *expression* *catch-function*)**
-
-The `try` primitive evaluates the given ***expression***. If the evaluation of ***expression*** results in an **exception signal**, the ***catch-function*** is then invoked with the exception's return value as its sole argument. If ***expression*** evaluates without an exception, its result is returned directly, and the ***catch-function*** is not called. If the second argument, ***catch-function***, is not a valid function, `try` will signal a syntax error.
-
-```lisp
-(try
-  (throw "Alas!")
-  (lambda (e) (concat "Caught exception: " e)))
-;; -> "Caught exception: Alas!"
-
-(try
-  (+ 1 2)
-  (lambda (e) (concat "Caught exception: " e)))
-;; -> 3
-
-(try
-  (+ 1 2)
-  'not-a-function)
-;; -> Error: try: syntax error, catch is not a function.
-```
-
----
-
-**(load *filename*)**
-
-Evaluates the Lisp expressions contained in the file specified by `filename`. The `filename` argument must be a string. This primitive can only be called from the top-level environment.
-
-```lisp
-(load "my-program.lisp")
-;; -> <Result of the last expression in my-program.lisp>
-```
-
----
-
-**(return *expression*)**
-
-Evaluates `expression` and returns its value from the current **function**. If `expression` is omitted, `return` evaluates to **nil**. It's important to note that `return` only exits functions and does not break out of `let` blocks or other control structures.
-
-```lisp
-(defun my-func (x)
-    (if (> x 10)
-        (return "Value too large!")
-        (+ x 5)))
-;; -> my-func
-
-(my-func 5)
-;; -> 10
-
-(my-func 12)
-;; -> "Value too large!"
-```
-
----
-
-**(break)**
-
-This primitive immediately exits the innermost enclosing loop or iteration construct. It's analogous to the `break` statement in C. The `break` primitive takes no arguments.
-
-```lisp
-(defun count-to-five ()
-    (let ((i 0))
-        (while #t
-            (setq i (+ i 1))
-            (when (> i 5)
-                (break))
-            (print i))))
-;; -> count-to-five
-
-(count-to-five)
-;; 1
-;; 2
-;; 3
-;; 4
-;; 5
-;; -> ()
-```
-
---- 
-
-**(eval *expression*)**
-
-Evaluates *expression* and returns its result. This primitive is typically used to evaluate code that is constructed or obtained at runtime.
-
-```lisp
-(eval '(+ 1 2))
-;; -> 3
-
-(eval '(* 3 4))
-;; -> 12
-
-(defvar my-expression '(+ 10 20))
-(eval my-expression)
-;; -> 30
-```
-
----
-
-**(unwind-protect *protected-form* *cleanup-form* \&rest *more-cleanup-forms*)**
-
-Evaluates *protected-form*. After *protected-form* is evaluated, whether it completes normally or exits via a non-local exit (like an error or a `return`), each *cleanup-form* is evaluated sequentially. The return value of `unwind-protect` is the result of *protected-form*. This primitive is crucial for ensuring that cleanup actions (like closing files or releasing resources) always occur.
-
-```lisp
-(unwind-protect
-    (progn (print "Doing something...")
-           (/ 10 2))
-    (print "Cleaning up!"))
-;; "Doing something..."
-;; "Cleaning up!"
-;; -> 5
-
-(unwind-protect
-    (progn (print "About to error...")
-           (error "error!"))
-    (print "Still cleaning up!"))
-;; "About to error..."
-;; "Still cleaning up!"
-;; -> Error
-```
-
diff --git a/src/main.c b/src/main.c
index 250e3d3..1911873 100644
--- a/src/main.c
+++ b/src/main.c
@@ -31,12 +31,6 @@ int main(int argc, char **argv) {
             interp.stacktrace = interp.nil;
             mainret = -1; goto end;
         }
-        if (Interp_ref(&interp, ret)->type == kBreakSignal
-                || Interp_ref(&interp, ret)->type == kContinueSignal
-                || Interp_ref(&interp, ret)->type == kReturnSignal) {
-            fprintf(stderr, "Error: unexpected control flow signal.\n");
-            mainret = -1; goto end;
-        }
     }
 #ifdef WITHREADLINE
     Parser_set_readline(interp.parser);
diff --git a/tests/vector.lisp b/tests/vector.lisp
index 9146168..d4f7231 100644
--- a/tests/vector.lisp
+++ b/tests/vector.lisp
@@ -18,3 +18,15 @@
 (assert (equal? (vector-ref v 1) 99))
 (assert (equal? (vector-ref v 2) "123"))
 (assert (equal? (vector-ref v 3) 1.2))
+
+(vector-remove v 2)
+
+(assert (equal? (vector-ref v 2) 1.2))
+(assert (equal? (vector-ref v 1) 99))
+
+(defvar x 2)
+(vector-append v x)
+
+(vector-set v 3 3)
+(assert (= x 2))
+(assert (= 3 (vector-ref v 3)))