Add Lisp example files

Author: 0xhenrique

lisp/test_basics.lisp

@@ -0,0 +1,51 @@
+; Arithmetic
+(println "Testing arithmetic...")
+(def result (+ 1 2 3))
+(if (= result 6)
+    (println "  + works: passed")
+    (println "  + works: FAILED"))
+
+(if (= (* 4 5) 20)
+    (println "  * works: passed")
+    (println "  * works: FAILED"))
+
+(if (= (- 10 3) 7)
+    (println "  - works: passed")
+    (println "  - works: FAILED"))
+
+; Comparison
+(println "Testing comparison...")
+(if (< 1 2)
+    (println "  < works: passed")
+    (println "  < works: FAILED"))
+
+(if (>= 5 5)
+    (println "  >= works: passed")
+    (println "  >= works: FAILED"))
+
+; Functions
+(println "Testing functions...")
+(def square (fn (n) (* n n)))
+(if (= (square 5) 25)
+    (println "  fn works: passed")
+    (println "  fn works: FAILED"))
+
+; Let bindings
+(println "Testing let...")
+(def let-result (let (x 10 y 20) (+ x y)))
+(if (= let-result 30)
+    (println "  let works: passed")
+    (println "  let works: FAILED"))
+
+; Recursion
+(println "Testing recursion...")
+(def factorial (fn (n)
+    (if (<= n 1)
+        1
+        (* n (factorial (- n 1))))))
+(if (= (factorial 5) 120)
+    (println "  recursion works: passed")
+    (println "  recursion works: FAILED"))
+
+(println "")
+(println "All basic tests completed!")

lisp/test_macros.lisp

@@ -0,0 +1,36 @@
+(println "Testing macros...")
+
+; Defining 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
+(defmacro inc (x)
+    (list '+ x 1))
+
+(if (= (inc 5) 6)
+    (println "  inc macro: passed")
+    (println "  inc macro: FAILED"))
+
+; Defining a 'double' macro
+(defmacro double (x)
+    (list '* x 2))
+
+(if (= (double 10) 20)
+    (println "  double macro: passed")
+    (println "  double macro: FAILED"))
+
+; Nested macro expansion
+(defmacro inc-twice (x)
+    (list 'inc (list 'inc x)))
+
+(if (= (inc-twice 5) 7)
+    (println "  nested macros: passed")
+    (println "  nested macros: FAILED"))
+
+(println "")
+(println "All macro tests completed!")

lisp/test_pure_functions.lisp

@@ -0,0 +1,41 @@
+(println "Testing pure function detection...")
+
+; Defining a pure function
+(def square (fn (n) (* n n)))
+
+; This should work (pure function with constant arg could be folded)
+(if (= (square 5) 25)
+    (println "  square(5) = 25: passed")
+    (println "  square(5) = 25: FAILED"))
+
+; Nested pure functions
+(def double (fn (x) (* x 2)))
+(def quad (fn (x) (double (double x))))
+
+(if (= (quad 3) 12)
+    (println "  quad(3) = 12: passed")
+    (println "  quad(3) = 12: FAILED"))
+
+; Pure function with conditional
+(def abs (fn (n) (if (< n 0) (- n) n)))
+
+(if (= (abs -5) 5)
+    (println "  abs(-5) = 5: passed")
+    (println "  abs(-5) = 5: FAILED"))
+
+(if (= (abs 5) 5)
+    (println "  abs(5) = 5: passed")
+    (println "  abs(5) = 5: FAILED"))
+
+; Pure function with let
+(def sum-squares (fn (a b)
+    (let (a2 (* a a)
+          b2 (* b b))
+        (+ a2 b2))))
+
+(if (= (sum-squares 3 4) 25)
+    (println "  sum-squares(3,4) = 25: passed")
+    (println "  sum-squares(3,4) = 25: FAILED"))
+
+(println "")
+(println "All pure function tests completed!")

lisp/test_tco.lisp

@@ -0,0 +1,35 @@
+(println "Testing tail call optimization...")
+
+; Sum function with accumulator (tail recursive)
+(def sum (fn (n acc)
+    (if (<= n 0)
+        acc
+        (sum (- n 1) (+ acc n)))))
+
+; This would stack overflow without TCO
+(def result (sum 10000 0))
+(if (= result 50005000)
+    (println "  tail call sum(10000): passed")
+    (println "  tail call sum(10000): FAILED"))
+
+; Even/odd mutual recursion
+(def even? (fn (n)
+    (if (= n 0)
+        true
+        (odd? (- n 1)))))
+
+(def odd? (fn (n)
+    (if (= n 0)
+        false
+        (even? (- n 1)))))
+
+(if (even? 100)
+    (println "  mutual recursion even?(100): passed")
+    (println "  mutual recursion even?(100): FAILED"))
+
+(if (odd? 101)
+    (println "  mutual recursion odd?(101): passed")
+    (println "  mutual recursion odd?(101): FAILED"))
+
+(println "")
+(println "All TCO tests completed!")