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,13 @@
+!(:load "bool.lurk")
+
+;; test that (bool_neg nil) evaluates to t
+!(:assert (bool_neg nil))
+
+;; 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,20 @@
+;; some boolean operations 
+
+;; determine if two bools are equal 
+(let ((eq_bool (lambda (x y)
+    (if x
+        (if y
+            t
+            nil)
+        (if y
+            nil
+            t )))))
+    (current-env))
+
+;; negate a boolean
+(let ((bool_neg (lambda (x) 
+    (if (eq_bool x nil)
+        t
+        (if (eq_bool x t)
+            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,62 @@
+;; a list is of the form (cons a (cons b (cons ... (cons nil)...)))
+;; some definitions for lists 
+
+;; empty_list : the empty list
+(let ((empty_list '())) (current-env))
+
+;; some functions for lists 
+
+;; 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))
+
+;; list_length : determines the length of a list 
+(letrec 
+    ((length_iter (lambda (lst cntr)
+        (if (car lst)
+            (length_iter (cdr lst) (+ 1 cntr))
+            cntr)))
+    (list_length (lambda (lst) (length_iter lst 0))))
+    (current-env))
+
+;; list_map : a list map function 
+(letrec 
+    ((map_iter (lambda (lst fun accum)
+        (if (car lst)
+            (map_iter (cdr lst) fun (snoc (fun (car lst)) accum))
+            accum)))
+    (list_map (lambda (lst fun) (map_iter lst fun (cons nil nil)))))
+    (current-env))
+
+;; list_fold : a fold function over lists 
+(letrec 
+    ((list_fold (lambda (lst op accum)
+        (if (car lst)
+            (list_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))