Objects

Cargo.toml

@@ -32,6 +32,7 @@ serde = "1.0.204"
 serde_yml = "0.0.10"
 serde_json = "1.0.120"
 env_logger = "0.11.3"
+prettytable-rs = "0.10.0"
 
 [dev-dependencies]
 criterion = "0.4"

examples/code/args.lisp

@@ -0,0 +1,3 @@
+{
+    (io.println (fmt.show (sys.args)))
+}

examples/code/fact.lisp

@@ -1,12 +1,20 @@
 {
+    (mod.use math)
+    (mod.use io)
+    (mod.use fn)
+    (mod.use env)
+    (mod.use proc)
+    (mod.use list)
+    (mod.use fmt)
+
     (defun fact (n) 
         (if n <= 0
             1
             n * (fact n - 1)))
     (defun stirlings (n)
         (if n <= 0 1
-            (* (sqrt 2 * 3.14159265358979323846 * n)
-               ((n / 2.71828182845904523536) ^ n))))
+            (sqrt 2 * 3.14159265358979323846 * n)
+               * (pow n / 2.71828182845904523536 n)))
 
     (define cbrt   (lambda (x) (^ x (/ 1 3.0))))
     (define qurt   (lambda (x) (^ x (/ 1 4.0))))
@@ -28,8 +36,8 @@
     (defun is-even (n) (= (% n 2) 0))
     (defun is-odd (n) (= (% n 2) 1))
 
-    (println (map (\ (k v) (list k (square v))) #[x 5 y 10]))
-    (println (filter (\ (k v) (is-even v)) #[x 5 y 10]))
+    (println (map (\ (k v) (list k (square v))) [x 5 y 10]))
+    (println (filter (\ (k v) (is-even v)) [x 5 y 10]))
 
     (define l (range 1 10))
     (defun fastfact (n) (apply (eval '*) (range 1 n)))

examples/code/hello-world.lisp

@@ -0,0 +1,5 @@
+{
+    (mod.use io)
+
+    (println "Hello, World!")
+}

examples/code/method.lisp

@@ -0,0 +1,9 @@
+{
+    (define x (new #[]))
+
+    x.method <- (lambda (self test) (println "Hello, World! " self.a " " test))
+
+    (x.method ())
+    x.a <- 100
+    (x.method ())
+}

examples/code/sort.lisp

@@ -1,5 +1,13 @@
 
-(do
+{
+    (mod.use math)
+    (mod.use io)
+    (mod.use fn)
+    (mod.use env)
+    (mod.use proc)
+    (mod.use list)
+    (mod.use fmt)
+
     (defun fact (n) 
         (if (<= n 0) 1 
             (* n (fact (- n 1)))))
@@ -15,13 +23,14 @@
     (println "Stirling's approx. for 5! = " (stirlings 5))
 
     (defun quicksort (lst)
-        (if (<= (len lst) 1) lst {
-            (define pivot (get lst (/ (len lst) 2)))
+        (if (<= (length lst) 1) lst {
+            (define pivot (get lst (/ (length lst) 2)))
             (define less (filter (\(x) (< x pivot)) lst))
             (define equal (filter (\(x) (= x pivot)) lst))
             (define greater (filter (\(x) (> x pivot)) lst))
             (+ (quicksort less) equal (quicksort greater))}))
 
     (define test-list (list 5 3 7 2 8 1 9 4 6))
     (println "Unsorted list: " test-list)
-    (println "Sorted list: " (quicksort test-list)))
+    (println "Sorted list: " (quicksort test-list))
+}

examples/code/struct.lisp

@@ -0,0 +1,35 @@
+{
+    (oop.struct Point
+        (new (self a b) {
+            self.x <- a
+            self.y <- b
+        })
+
+        (defun move (self dx dy) {
+            self.x <- (math.sum $self.x dx)
+            self.y <- (math.sum $self.y dy)
+        })
+
+        (defun print (self) {
+            (io.println (self.show))
+        })
+
+        (defun debug (self) {
+            (io.println (self.repr))
+        })
+
+        (defun show (self) {
+            (fmt.format "Point({}, {})" $self.x $self.y)
+        })
+
+        (defun repr (self) {
+            (fmt.show self)
+        }))
+
+    (env.define p (Point 10 20))
+
+    (p.debug)
+    (p.print)
+    (p.move 5 5)
+    (p.print)
+}

examples/expected-good/fact.txt

@@ -1,7 +1,7 @@
 36
 testing 3628800 15!
-#[x 25 y 100]
-#[y 10]
+[x 25 y 100]
+[y 10]
 Factorial of 4: 24
 even: (2 4 6 8 10) odd: (1 3 5 7 9)
-Stirling's approximation for 5! = 118.0191679575901
+Stirling's approximation for 5! = 118.0191679575901

examples/expected-good/sort.txt

@@ -1,4 +1,4 @@
 5! = 120
 Stirling's approx. for 5! = 118.019297959714
 Unsorted list: (5 3 7 2 8 1 9 4 6)
-Sorted list: (1 2 3 4 5 6 7 8 9)
+Sorted list: (1 2 3 4 5 6 7 8 9)