Add more features to stdlib

Author: 0xhenrique

lisp/stdlib.lisp

@@ -0,0 +1,28 @@
+; Standard Library for Lisp VM
+; Higher-order functions that can't be efficiently implemented in native code
+
+; Map: apply function to each element of a list
+(def map (fn (f lst)
+    (if (nil? lst)
+        nil
+        (cons (f (car lst)) (map f (cdr lst))))))
+
+; Filter: keep only elements that satisfy the predicate
+(def filter (fn (pred lst)
+    (if (nil? lst)
+        nil
+        (if (pred (car lst))
+            (cons (car lst) (filter pred (cdr lst)))
+            (filter pred (cdr lst))))))
+
+; Fold (reduce): combine elements from left to right
+(def fold (fn (f init lst)
+    (if (nil? lst)
+        init
+        (fold f (f init (car lst)) (cdr lst)))))
+
+; Fold-right: combine elements from right to left
+(def fold-right (fn (f init lst)
+    (if (nil? lst)
+        init
+        (f (car lst) (fold-right f init (cdr lst))))))

lisp/test_basics.lisp

@@ -1,3 +1,5 @@
+; Test basic functionality
+
 ; Arithmetic
 (println "Testing arithmetic...")
 (def result (+ 1 2 3))

lisp/test_macros.lisp

@@ -1,22 +1,24 @@
+; Test macro functionality
+
 (println "Testing macros...")
 
-; Defining an 'unless' macro
+; Define an 'unless' macro
 (defmacro unless (cond body)
     (list 'if cond nil body))
 
 (if (= (unless false 42) 42)
     (println "  unless macro: passed")
     (println "  unless macro: FAILED"))
 
-; Defining an 'inc' macro
+; Define an 'inc' macro
 (defmacro inc (x)
     (list '+ x 1))
 
 (if (= (inc 5) 6)
     (println "  inc macro: passed")
     (println "  inc macro: FAILED"))
 
-; Defining a 'double' macro
+; Define a 'double' macro
 (defmacro double (x)
     (list '* x 2))
 

lisp/test_pure_functions.lisp

@@ -1,6 +1,8 @@
+; Test pure function detection and compile-time evaluation
+
 (println "Testing pure function detection...")
 
-; Defining a pure function
+; Define a pure function
 (def square (fn (n) (* n n)))
 
 ; This should work (pure function with constant arg could be folded)

lisp/test_stdlib.lisp

@@ -0,0 +1,157 @@
+; Test Standard Library Functions
+; Tests for logic operators, list functions, string functions, and I/O
+
+; ============================================
+; Test short-circuiting logic operators
+; ============================================
+
+(println "Testing logic operators...")
+
+; Test: and with no arguments
+(def test1 (and))
+(if (= test1 true)
+    (println "✓ (and) => true")
+    (println "✗ (and) failed"))
+
+; Test: and with one argument
+(def test2 (and 42))
+(if (= test2 42)
+    (println "✓ (and 42) => 42")
+    (println "✗ (and 42) failed"))
+
+; Test: and short-circuits on false
+(def test3 (and true false (/ 1 0)))  ; Should not divide by zero
+(if (= test3 false)
+    (println "✓ (and true false ...) short-circuits")
+    (println "✗ (and) short-circuit failed"))
+
+; Test: and returns last value when all true
+(def test4 (and 1 2 3))
+(if (= test4 3)
+    (println "✓ (and 1 2 3) => 3")
+    (println "✗ (and 1 2 3) failed"))
+
+; Test: or with no arguments
+(def test5 (or))
+(if (= test5 false)
+    (println "✓ (or) => false")
+    (println "✗ (or) failed"))
+
+; Test: or with one argument
+(def test6 (or 42))
+(if (= test6 42)
+    (println "✓ (or 42) => 42")
+    (println "✗ (or 42) failed"))
+
+; Test: or short-circuits on true
+(def test7 (or false true (/ 1 0)))  ; Should not divide by zero
+(if (= test7 true)
+    (println "✓ (or false true ...) short-circuits")
+    (println "✗ (or) short-circuit failed"))
+
+; Test: or returns last value when all false
+(def test8 (or false nil false))
+(if (= test8 false)
+    (println "✓ (or false nil false) => false")
+    (println "✗ (or false nil false) failed"))
+
+; ============================================
+; Test list functions
+; ============================================
+
+(println "\nTesting list functions...")
+
+; Test: nth on list
+(def lst (list 10 20 30 40 50))
+(def test9 (nth lst 0))
+(if (= test9 10)
+    (println "✓ (nth lst 0) => 10")
+    (println "✗ (nth lst 0) failed"))
+
+(def test10 (nth lst 2))
+(if (= test10 30)
+    (println "✓ (nth lst 2) => 30")
+    (println "✗ (nth lst 2) failed"))
+
+; Test: append
+(def test11 (append (list 1 2) (list 3 4) (list 5 6)))
+(def test11-len (length test11))
+(if (= test11-len 6)
+    (println "✓ (append ...) => list of length 6")
+    (println "✗ (append) failed"))
+
+; Test: reverse
+(def test12 (reverse (list 1 2 3 4 5)))
+(def test12-first (nth test12 0))
+(if (= test12-first 5)
+    (println "✓ (reverse (list 1 2 3 4 5)) => (5 4 3 2 1)")
+    (println "✗ (reverse) failed"))
+
+; ============================================
+; Test string functions
+; ============================================
+
+(println "\nTesting string functions...")
+
+; Test: string-length
+(def test13 (string-length "hello"))
+(if (= test13 5)
+    (println "✓ (string-length \"hello\") => 5")
+    (println "✗ (string-length) failed"))
+
+; Test: string-append
+(def test14 (string-append "hello" " " "world"))
+(if (= test14 "hello world")
+    (println "✓ (string-append ...) => \"hello world\"")
+    (println "✗ (string-append) failed"))
+
+; Test: substring
+(def test15 (substring "hello world" 0 5))
+(if (= test15 "hello")
+    (println "✓ (substring \"hello world\" 0 5) => \"hello\"")
+    (println "✗ (substring) failed"))
+
+(def test16 (substring "hello world" 6 11))
+(if (= test16 "world")
+    (println "✓ (substring \"hello world\" 6 11) => \"world\"")
+    (println "✗ (substring) failed"))
+
+; Test: string->list
+(def test17 (string->list "abc"))
+(def test17-len (length test17))
+(if (= test17-len 3)
+    (println "✓ (string->list \"abc\") => list of length 3")
+    (println "✗ (string->list) failed"))
+
+; Test: list->string
+(def test18 (list->string (list "h" "e" "l" "l" "o")))
+(if (= test18 "hello")
+    (println "✓ (list->string ...) => \"hello\"")
+    (println "✗ (list->string) failed"))
+
+; Test: format
+(def test19 (format "Hello, ~a!" "world"))
+(if (= test19 "Hello, world!")
+    (println "✓ (format \"Hello, ~a!\" \"world\") => \"Hello, world!\"")
+    (println "✗ (format) failed"))
+
+(def test20 (format "The answer is ~a" 42))
+(if (= test20 "The answer is 42")
+    (println "✓ (format \"The answer is ~a\" 42) => \"The answer is 42\"")
+    (println "✗ (format) failed"))
+
+; ============================================
+; Test I/O functions
+; ============================================
+
+(println "\nTesting I/O functions...")
+
+; Test: write-file and read-file
+(def test-content "Hello from Lisp VM!\nLine 2\nLine 3")
+(write-file "/tmp/lisp-test.txt" test-content)
+(def read-content (read-file "/tmp/lisp-test.txt"))
+(if (= read-content test-content)
+    (println "✓ write-file and read-file work correctly")
+    (println "✗ write-file or read-file failed"))
+
+(println "\nAll standard library tests completed!")

lisp/test_tco.lisp

@@ -1,3 +1,5 @@
+; Test tail call optimization
+
 (println "Testing tail call optimization...")
 
 ; Sum function with accumulator (tail recursive)

src/compiler.rs

@@ -690,6 +690,8 @@ impl Compiler {
                 match sym {
                     "quote" => return self.compile_quote(&items[1..], dest),
                     "if" => return self.compile_if(&items[1..], dest, tail_pos),
+                    "and" => return self.compile_and(&items[1..], dest),
+                    "or" => return self.compile_or(&items[1..], dest),
                     "def" => return self.compile_def(&items[1..], dest),
                     "let" => return self.compile_let(&items[1..], dest, tail_pos),
                     "fn" => return self.compile_fn(&items[1..], dest),
@@ -774,6 +776,76 @@ impl Compiler {
         Ok(())
     }
 
+    fn compile_and(&mut self, args: &[Value], dest: Reg) -> Result<(), String> {
+        // (and) => true
+        if args.is_empty() {
+            self.emit(Op::load_true(dest));
+            return Ok(());
+        }
+
+        // (and x) => x
+        if args.len() == 1 {
+            return self.compile_expr(&args[0], dest, false);
+        }
+
+        // (and x y z ...) => short-circuit evaluation
+        // Evaluate each expression, if any is false, jump to end with false
+        let mut jump_to_end = Vec::new();
+
+        for (i, arg) in args.iter().enumerate() {
+            self.compile_expr(arg, dest, false)?;
+
+            // For all but the last, check if false and jump to end
+            if i < args.len() - 1 {
+                let jump = self.emit(Op::jump_if_false(dest, 0));
+                jump_to_end.push(jump);
+            }
+        }
+
+        // Patch all jumps to end (dest already has the last value or the false value)
+        let end = self.chunk.current_pos();
+        for jump in jump_to_end {
+            self.chunk.patch_jump(jump, end);
+        }
+
+        Ok(())
+    }
+
+    fn compile_or(&mut self, args: &[Value], dest: Reg) -> Result<(), String> {
+        // (or) => false
+        if args.is_empty() {
+            self.emit(Op::load_false(dest));
+            return Ok(());
+        }
+
+        // (or x) => x
+        if args.len() == 1 {
+            return self.compile_expr(&args[0], dest, false);
+        }
+
+        // (or x y z ...) => short-circuit evaluation
+        // Evaluate each expression, if any is true, jump to end with that value
+        let mut jump_to_end = Vec::new();
+
+        for (i, arg) in args.iter().enumerate() {
+            self.compile_expr(arg, dest, false)?;
+
+            // For all but the last, check if true and jump to end
+            if i < args.len() - 1 {
+                let jump = self.emit(Op::jump_if_true(dest, 0));
+                jump_to_end.push(jump);
+            }
+        }
+
+        // Patch all jumps to end (dest already has the last value or the true value)
+        let end = self.chunk.current_pos();
+        for jump in jump_to_end {
+            self.chunk.patch_jump(jump, end);
+        }
+
+        Ok(())
+    }
+
     /// Try to compile a comparison condition as a combined compare-and-jump opcode
     /// Returns Some(jump_pos) if successful, None if condition is not a simple comparison
     ///