use bash to do run examples

Author: xieyuheng

examples/bool.test.lisp.out

@@ -1,20 +1,10 @@
-(import zero? add mul sub1 "nat-church.lisp")
-(import zero one two three four "nat-church.lisp")
-(import if true false "bool.lisp")
+(import zero? mul sub1 "nat-church.lisp")
+(import one "nat-church.lisp")
+(import if "bool.lisp")
+
+(define factorial (factorial-half factorial-half))
 
 (define (factorial-half self n)
   (if (zero? n)
     one
     (mul n (self self (sub1 n)))))
-
-;; test readback of functions
-
-factorial-half
-
-(define factorial (factorial-half factorial-half))
-
-(assert-equal (factorial zero) one)
-(assert-equal (factorial one) one)
-(assert-equal (factorial two) two)
-(assert-equal (factorial three) (mul three two))
-(assert-equal (factorial four) (mul four (mul three two)))

examples/cons.test.lisp.out

@@ -0,0 +1,13 @@
+(import zero? add mul sub1 "nat-church.lisp")
+(import zero one two three four "nat-church.lisp")
+(import if true false "bool.lisp")
+
+(import factorial-half factorial "factorial-half.lisp")
+
+factorial-half
+
+(assert-equal (factorial zero) one)
+(assert-equal (factorial one) one)
+(assert-equal (factorial two) two)
+(assert-equal (factorial three) (mul three two))
+(assert-equal (factorial four) (mul four (mul three two)))

examples/factorial-half.lisp

@@ -1,64 +1,13 @@
-(import zero? add mul sub1 "nat-church.lisp")
-(import zero one two three four "nat-church.lisp")
-(import if true false "bool.lisp")
-(import Y turing "fixpoint.lisp")
+(import zero? mul sub1 "nat-church.lisp")
+(import one "nat-church.lisp")
+(import if "bool.lisp")
+(import Y "fixpoint.lisp")
+
+(define factorial (Y factorial-wrap))
 
 (define factorial-wrap
   (lambda (factorial)
     (lambda (n)
       (if (zero? n)
         one
         (mul n (factorial (sub1 n)))))))
-
-;; test readback of functions
-
-factorial-wrap
-
-;; test equivalence of functions
-
-(assert-equal
-  (lambda (factorial)
-    (factorial-wrap
-     (factorial-wrap
-      (factorial-wrap
-       factorial))))
-  (lambda (factorial)
-    (lambda (n)
-      (if (zero? n)
-        one
-        (mul
-         n
-         ((lambda (n)
-            (if (zero? n)
-              one
-              (mul
-               n
-               ((lambda (n)
-                  (if (zero? n)
-                    one
-                    (mul
-                     n
-                     (factorial
-                      (sub1 n)))))
-                (sub1 n)))))
-          (sub1 n)))))))
-
-(assert-equal ((Y factorial-wrap) zero) one)
-(assert-equal ((Y factorial-wrap) one) one)
-(assert-equal ((Y factorial-wrap) two) two)
-(assert-equal ((Y factorial-wrap) three) (mul three two))
-(assert-equal ((Y factorial-wrap) four) (mul four (mul three two)))
-
-(assert-equal ((turing factorial-wrap) zero) one)
-(assert-equal ((turing factorial-wrap) one) one)
-(assert-equal ((turing factorial-wrap) two) two)
-(assert-equal ((turing factorial-wrap) three) (mul three two))
-(assert-equal ((turing factorial-wrap) four) (mul four (mul three two)))
-
-(define factorial (Y factorial-wrap))
-
-(assert-equal (factorial zero) one)
-(assert-equal (factorial one) one)
-(assert-equal (factorial two) two)
-(assert-equal (factorial three) (mul three two))
-(assert-equal (factorial four) (mul four (mul three two)))

examples/factorial-half.test.lisp

@@ -0,0 +1,57 @@
+(import zero? add mul sub1 "nat-church.lisp")
+(import zero one two three four "nat-church.lisp")
+(import if true false "bool.lisp")
+(import Y turing "fixpoint.lisp")
+
+(import factorial-wrap factorial "factorial-wrap.lisp")
+
+;; test readback of functions
+
+factorial-wrap
+
+;; test equivalence of functions
+
+(assert-equal
+  (lambda (factorial)
+    (factorial-wrap
+     (factorial-wrap
+      (factorial-wrap
+       factorial))))
+  (lambda (factorial)
+    (lambda (n)
+      (if (zero? n)
+        one
+        (mul
+         n
+         ((lambda (n)
+            (if (zero? n)
+              one
+              (mul
+               n
+               ((lambda (n)
+                  (if (zero? n)
+                    one
+                    (mul
+                     n
+                     (factorial
+                      (sub1 n)))))
+                (sub1 n)))))
+          (sub1 n)))))))
+
+(assert-equal ((Y factorial-wrap) zero) one)
+(assert-equal ((Y factorial-wrap) one) one)
+(assert-equal ((Y factorial-wrap) two) two)
+(assert-equal ((Y factorial-wrap) three) (mul three two))
+(assert-equal ((Y factorial-wrap) four) (mul four (mul three two)))
+
+(assert-equal ((turing factorial-wrap) zero) one)
+(assert-equal ((turing factorial-wrap) one) one)
+(assert-equal ((turing factorial-wrap) two) two)
+(assert-equal ((turing factorial-wrap) three) (mul three two))
+(assert-equal ((turing factorial-wrap) four) (mul four (mul three two)))
+
+(assert-equal (factorial zero) one)
+(assert-equal (factorial one) one)
+(assert-equal (factorial two) two)
+(assert-equal (factorial three) (mul three two))
+(assert-equal (factorial four) (mul four (mul three two)))

examples/factorial-half.lisp.out renamed to examples/factorial-half.test.lisp.out

@@ -1,28 +1,8 @@
-(import zero? add mul sub1 "nat-church.lisp")
-(import zero one two three four "nat-church.lisp")
-(import if true false "bool.lisp")
+(import zero? mul sub1 "nat-church.lisp")
+(import one "nat-church.lisp")
+(import if "bool.lisp")
 
 (define (factorial n)
   (if (zero? n)
     one
     (mul n (factorial (sub1 n)))))
-
-(assert-equal (factorial zero) one)
-(assert-equal (factorial one) one)
-(assert-equal (factorial two) two)
-(assert-equal (factorial three) (mul three two))
-(assert-equal (factorial four) (mul four (mul three two)))
-
-;; test equivalence between recursive functions
-
-(assert-same factorial factorial)
-(assert-equal factorial factorial)
-
-(assert-not-same factorial (lambda (x) (factorial x)))
-(assert-equal factorial (lambda (y) (factorial y)))
-(assert-equal factorial (lambda (x) (factorial x)))
-(assert-equal (lambda (x) (factorial x)) (lambda (y) (factorial y)))
-
-;; test readback of recursive functions
-
-factorial