A first PR for a standard lib

std-lib/bool/Makefile

@@ -0,0 +1,2 @@
+eval-main :
+	lurkrs bool-test.lurk

std-lib/bool/bool-test.lurk

@@ -0,0 +1,14 @@
+!(:load "bool.lurk")
+
+;; test that (bool-neg nil) evaluates to t
+!(:assert (bool-neg nil))
+!(:assert (bool-neg (bool-neg t)))
+
+;; four test cases for eq-bool
+!(:assert (eq-bool t t))
+!(:assert (eq-bool nil nil))
+!(:assert (bool-neg (eq-bool t nil)))
+!(:assert (bool-neg (eq-bool nil t)))
+
+;; test that (bool-neg t) evaluates to nil
+!(:assert (eq-bool nil (bool-neg t)))

std-lib/bool/bool.lurk

@@ -0,0 +1,9 @@
+;; some boolean operations 
+
+;; negate a boolean
+(let ((bool-neg (lambda (x) (if x nil t)))) (current-env))
+
+;; determine if two bools are equal 
+(let ((eq-bool (lambda (x y)
+    (if x  y (eq y nil)))))
+    (current-env))

std-lib/list/Makefile

@@ -0,0 +1,2 @@
+eval-main :
+	lurkrs list-test.lurk

std-lib/list/list-test.lurk

@@ -0,0 +1,3 @@
+!(:load "list.lurk")
+
+;; some tests for the list module 

std-lib/list/list.lurk

@@ -0,0 +1,66 @@
+;; a list is of the form (cons a (cons b (cons ... (cons nil)...)))
+
+;; list : make a list out of a (possibly unevaluated) list quote
+(letrec ((list (lambda (q)
+		 (if (car q)
+		     (cons (eval (car q)) (list (cdr q)))
+		     '()))))
+  (current-env))
+
+;; list-eq : determine if two lists are equal
+(letrec ((list-eq (lambda (l1 l2)
+    (if (car l1) 
+        (if (car l2)
+            (if (= (car l1) (car l2))
+                (list-eq (cdr l1) (cdr l2))
+                nil)
+            nil)
+        (if (car l2)
+            nil
+            t)))))
+    (current-env))
+
+;; snoc : appends to the right-hand side of a list (opposite of cons)
+(letrec 
+    ((snoc-iter (lambda (old-list new-list) 
+        (if (car old-list)
+            (snoc-iter (cdr old-list) (cons (car old-list) new-list))
+            new-list)))
+    (snoc (lambda (x lst) (snoc-iter (snoc-iter lst '()) (cons x nil))))) 
+    (current-env))
+
+;; length : determines the length of a list 
+(letrec 
+    ((length-iter (lambda (lst cntr)
+        (if (car lst)
+            (length-iter (cdr lst) (+ 1 cntr))
+            cntr)))
+    (length (lambda (lst) (length-iter lst 0))))
+    (current-env))
+
+;; apply : a preliminary version of apply
+(letrec 
+    ((apply (lambda (f list)
+        (if (car list)
+            (if (eq nil (cdr list))
+                (f (car list))
+                (apply (f (car list)) (cdr list)))))))
+    (current-env))
+
+;; map : a list map function 
+;; TODO : map that can take multiple lists
+(letrec ((map (lambda (f list)
+                    (if (eq list nil)
+                        nil
+                        (cons (f (car list))
+                              (map f (cdr list)))))))
+      (current-env))
+
+
+;; fold : a fold function over lists 
+(letrec 
+    ((fold (lambda (lst op accum)
+        (if (car lst)
+            (fold (cdr lst) op (op (car lst) accum))
+            accum))))
+    (current-env))

std-lib/safe-arith/Makefile

@@ -0,0 +1,2 @@
+eval-main :
+	lurkrs safe-arith-test.lurk

std-lib/safe-arith/safe-arith-test.lurk

@@ -0,0 +1,28 @@
+!(:load "safe-arith.lurk")
+
+;; tests for neg 
+!(:assert-eq 0 (neg 0))
+!(:assert-eq 10 (neg (- 0 10)))
+!(:assert-eq (- 0 10) (neg 10))
+
+;; tests for safe-add 
+!(:assert-eq (+ 10 (neg 43)) (safe-add 10 (neg 43)))
+!(:assert-eq (+ (neg 111) 321) (safe-add (neg 111) 321))
+!(:assert-eq (+ 11 5443225) (safe-add 11 5443225))
+!(:assert-eq (+ (neg 5443225) (neg 43)) (safe-add (neg 5443225) (neg 43)))
+
+;; tests for safe-sub 
+
+
+
+;; tests for safe-mult 
+
+
+
+;; tests for floor-int-div 
+
+
+
+;; tests for ceil-int-div 
+
+

std-lib/safe-arith/safe-arith.lurk

@@ -0,0 +1,113 @@
+;; Arithmetic operations that take into account that arithmetic in Lurk 
+;; is done over a finite field Z mod p.
+;; These functions model arithmetic in Z. 
+
+;; Since Lurk uses a finite field for arithmetic, arithmetic doesn't 
+;; always function as we might expect it to
+;; In particular, it is possible for the product or the sum of two 
+;; positive integers to be negative
+
+;; here we implement "safe" integer arithmetic, which is:
+;; integer arithmetic which evaluates correctly when it behaves like 
+;; normal integer arithmetic, but evaluates to `nil` when it 
+;; behaves oddly due to us using a finite field
+
+;; a simple function to switch from negative to positive and visa versa
+(let ((neg (lambda (n) (- 0 n)))) (current-env))
+
+;; safe-add and safe-subtract make addition behave as in the integers
+(let ((safe-add (lambda (a b)
+    (if (< a 0)
+        (if (< b 0)
+            ;; the sum of two negatives should be negative
+            (if (< (+ a b) 0)
+                ;; the sum of a positive and negative is safe 
+                (+ a b))
+            (+ a b))
+        (if (< b 0)
+            ;; the sum of a positive and negative is safe 
+            (+ a b)
+            ;; the sum of two positives should be positive
+            (if (>= (+ a b) 0)
+                (+ a b)))))))
+    (current-env))
+
+(let ((safe-sub (lambda (a b)
+    (if (< a 0)
+        (if (< b 0)
+            ;; the difference of two negatives is safe
+            (- a b)
+            ;; the difference of `a` negative and `b` nonnegative 
+            ;; should be negative 
+            (if (< (- a b) 0)
+                (- a b)))
+        (if (< b 0)
+            ;; the difference of `a` nonnegative and `b` negative
+            ;; should be nonnegative
+            (if (>= (- a b) 0)
+                (- a b))
+            ;; the difference of `a` nonnegative and `b` nonnegative is safe
+            (- a b))))))
+    (current-env))
+
+;; safe-mult makes multiplication behave as in the integers
+(let ((safe-mult (lambda (a b)
+    (if (< a 0)
+        (if (< b 0)
+            ;; the product of two negatives is positive 
+            (if (> ( * a b) 0)
+                ( * a b))
+            ;; the product of a negative and nonnegative is nonpositive
+            (if (<= ( * a b) 0)
+                ( * a b)))
+        (if (< b 0)
+            ;; the product of a nonnegative and a negative is nonpositive
+            (if (<= ( * a b) 0)
+                ( * a b))
+            ;; the product of two nonnegatives is nonnegative
+            (if (>= ( * a b) 0)
+                ( * a b)))))))
+    (current-env))
+
+;; integer division, where division by 0 results in 0
+;; first an auxiliary function `quot`
+(letrec 
+    ((quot-iter (lambda (a b q) 
+        (if (< a b) 
+            (quot-iter b a 0)
+            (if (< (* b (+ q 1)) 0)
+                q
+                (if (> (* b (+ q 1)) a)
+                    q 
+                    (quot-iter a b (+ q 1)))))))
+    (quot (lambda (a b)
+        (if (< a 0)
+            (quot (- 0 a) b)
+            (if (< b 0)
+                (quot a (- 0 b))
+                (quot-iter a b 0))))))
+    (current-env))
+
+;; integer division that rounds down
+(letrec ((floor-int-div 
+    (lambda (a b) 
+        (if (= b 0) 0
+        (if (< a 0) (- 0 (floor-int-div (- 0 a) b))
+        (if (< b 0) (- 0 (floor-int-div a (- 0 b)))
+            (if (< a b) 0
+            (quot a b))))))))
+    (current-env))
+
+;; integer division that rounds up
+(letrec ((ceil-int-div 
+    (lambda (a b) 
+        (if (= b 0) 0
+        (if (< a 0) (- 0 (ceil-int-div (- 0 a) b))
+        (if (< b 0) (- 0 (ceil-int-div a (- 0 b)))
+            (if (< a b) 1
+            (+ 1 (quot a b)))))))))
+    (current-env))
+
+
+;; safe integer square 
+(let ((safe-square (lambda (x) (safe-mult x x)))) (current-env))