Examples now load library.lisp

Author: NJdevPro

examples/hanoi.lisp

@@ -1,4 +1,4 @@
-(defun list (x . y) (cons x y))
+(load "examples/library.lisp")
 
 (defun hanoi-print (disk from to)
   (println (string-concat "Move disk " disk 

examples/life.lisp

@@ -2,100 +2,7 @@
 ;;; Conway's game of life
 ;;;
 
-;; (progn expr ...)
-;; => ((lambda () expr ...))
-;(defmacro progn (expr . rest)
-;  (list (cons 'lambda (cons () (cons expr rest)))))
-
-(defun list (x . y)
-  (cons x y))
-
-
-;(defun not (x)
-;  (if x () t))
-
-;; (let var val body ...)
-;; => ((lambda (var) body ...) val)
-(defmacro let (var val . body)
-  (cons (cons 'lambda (cons (list var) body))
-	(list val)))
-
-;; (and e1 e2 ...)
-;; => (if e1 (and e2 ...))
-;; (and e1)
-;; => e1
-(defmacro and (expr . rest)
-  (if rest
-      (list 'if expr (cons 'and rest))
-    expr))
-
-;; (or e1 e2 ...)
-;; => (let <tmp> e1
-;;      (if <tmp> <tmp> (or e2 ...)))
-;; (or e1)
-;; => e1
-;;
-;; The reason to use the temporary variables is to avoid evaluating the
-;; arguments more than once.
-(defmacro or (expr . rest)
-  (if rest
-      (let var (gensym)
-           (list 'let var expr
-                 (list 'if var var (cons 'or rest))))
-    expr))
-
-;; (when expr body ...)
-;; => (if expr (progn body ...))
-(defmacro when (expr . body)
-  (cons 'if (cons expr (list (cons 'progn body)))))
-
-;; (unless expr body ...)
-;; => (if expr () body ...)
-(defmacro unless (expr . body)
-  (cons 'if (cons expr (cons () body))))
-
-;;;
-;;; Numeric operators
-;;;
-
-;(defun <= (e1 e2)
-;  (or (< e1 e2)
-;      (= e1 e2)))
-
-;;;
-;;; List operators
-;;;
-
-;;; Applies each element of lis to fn, and returns their return values as a list.
-(defun map (lis fn)
-  (when lis
-    (cons (fn (car lis))
-	  (map (cdr lis) fn))))
-
-;; Returns nth element of lis.
-(defun nth (lis n)
-  (if (= n 0)
-      (car lis)
-    (nth (cdr lis) (- n 1))))
-
-;; Returns the nth tail of lis.
-(defun nth-tail (lis n)
-  (if (= n 0)
-      lis
-    (nth-tail (cdr lis) (- n 1))))
-
-;; Returns a list consists of m .. n-1 integers.
-(defun %iota (m n)
-  (unless (<= n m)
-    (cons m (%iota (+ m 1) n))))
-
-;; Returns a list consists of 0 ... n-1 integers.
-(defun iota (n)
-  (%iota 0 n))
-
-;;;
-;;; Main
-;;;
+(load "examples/library.lisp")
 
 (define width 10)
 (define height 10)

examples/nqueens.lisp

@@ -15,112 +15,7 @@
 ;;; expanded form using cons and list.
 ;;;
 
-;; (progn expr ...)
-;; => ((lambda () expr ...))
-;(defmacro progn (expr . rest)
-;  (list (cons 'lambda (cons () (cons expr rest)))))
-
-(defun list (x . y) (cons x y))
-
-;(defun not (x) (if x () t))
-
-;; (let1 var val body ...)
-;; => ((lambda (var) body ...) val)
-(defmacro let1 (var val . body)
-  (cons (cons 'lambda (cons (list var) body))
-	(list val)))
-
-;; (and e1 e2 ...)
-;; => (if e1 (and e2 ...))
-;; (and e1)
-;; => e1
-(defmacro and (expr . rest)
-  (if rest
-      (list 'if expr (cons 'and rest)) 
-      expr))
-
-;; (or e1 e2 ...)
-;; => (let1 <tmp> e1
-;;      (if <tmp> <tmp> (or e2 ...)))
-;; (or e1)
-;; => e1
-;;
-;; The reason to use the temporary variables is to avoid evaluating the
-;; arguments more than once.
-(defmacro or (expr . rest)
-  (if rest
-      (let1 var (gensym)
-	    (list 'let1 var expr
-		  (list 'if var var (cons 'or rest))))
-    expr))
-
-;; (when expr body ...)
-;; => (if expr (progn body ...))
-(defmacro when (expr . body)
-  (cons 'if (cons expr (list (cons 'progn body)))))
-
-;; (unless expr body ...)
-;; => (if expr () body ...)
-(defmacro unless (expr . body)
-  (cons 'if (cons expr (cons () body))))
-
-;;;
-;;; Numeric operators
-;;;
-
-;(defun <= (e1 e2)
-;  (or (< e1 e2)
-;      (= e1 e2)))
-
-;;;
-;;; List operators
-;;;
-
-;; Applies each element of lis to pred. If pred returns a true value, terminate
-;; the evaluation and returns pred's return value. If all of them return (),
-;; returns ().
-(defun any (lis pred)
-  (when lis
-    (or (pred (car lis))
-	(any (cdr lis) pred))))
-
-;;; Applies each element of lis to fn, and returns their return values as a list.
-(defun map (lis fn)
-  (when lis
-    (cons (fn (car lis))
-	  (map (cdr lis) fn))))
-
-;; Returns nth element of lis.
-(defun nth (lis n)
-  (if (= n 0)
-      (car lis)
-    (nth (cdr lis) (- n 1))))
-
-;; Returns the nth tail of lis.
-(defun nth-tail (lis n)
-  (if (= n 0)
-      lis
-    (nth-tail (cdr lis) (- n 1))))
-
-;; Returns a list consists of m .. n-1 integers.
-(defun %iota (m n)
-  (unless (<= n m)
-    (cons m (%iota (+ m 1) n))))
-
-;; Returns a list consists of 0 ... n-1 integers.
-(defun iota (n)
-  (%iota 0 n))
-
-;; Returns a new list whose length is len and all members are init.
-(defun make-list (len init)
-  (unless (= len 0)
-    (cons init (make-list (- len 1) init))))
-
-;; Applies fn to each element of lis.
-(defun for-each (lis fn)
-  (or (not lis)
-      (progn (fn (car lis))
-	     (for-each (cdr lis) fn))))
+(load "examples/library.lisp")
 
 ;;;
 ;;; N-queens solver
@@ -164,11 +59,11 @@
 	  ;; Check if there's no conflicting queen upward
 	  (set? board n y)
 	  ;; Upper left
-	  (let1 z (+ y (- n x))
+	  (let z (+ y (- n x))
 		(and (<= 0 z)
 		     (set? board n z)))
 	  ;; Upper right
-	  (let1 z (+ y (- x n))
+	  (let z (+ y (- x n))
 		(and (< z board-size)
 		     (set? board n z)))))))