+ ; basic list accessors
+
+
+(setq cadr (lambda (l) (car (cdr l))))
+(setq caddr (lambda (l) (car (cdr (cdr l)))))
+(setq list (lexpr (l) l))
+
+ ; evaluate a list of sexprs
+
+;(setq progn (lexpr (l) (last l)))
+
+
+ ;
+ ; Define a variable without returning the value
+ ; Useful when defining functions to avoid
+ ; having lots of output generated
+ ;
+
+(setq def (macro (def-param)
+ (list
+ 'progn
+ (list
+ 'set
+ (list
+ 'quote
+ (car def-param))
+ (cadr def-param)
+ )
+ (list
+ 'quote
+ (car def-param)
+ )
+ )
+ )
+ )
+
+ ; define a set of local
+ ; variables and then evaluate
+ ; a list of sexprs
+ ;
+ ; (let (var-defines) sexprs)
+ ;
+ ; where var-defines are either
+ ;
+ ; (name value)
+ ;
+ ; or
+ ;
+ ; (name)
+ ;
+ ; e.g.
+ ;
+ ; (let ((x 1) (y)) (setq y (+ x 1)) y)
+
+(def let (macro (let-param)
+ ((lambda (vars exprs make-names make-exprs make-nils)
+ (progn
+
+ ;
+ ; make the list of names in the let
+ ;
+
+ (setq make-names (lambda (vars)
+ (cond (vars
+ (cons (car (car vars))
+ (make-names (cdr vars))))
+ )
+ )
+ )
+ ;
+ ; the set of expressions is
+ ; the list of set expressions
+ ; pre-pended to the
+ ; expressions to evaluate
+ ;
+ (setq make-exprs (lambda (vars exprs)
+ (progn
+ (cond (vars (cons
+ (list set
+ (list quote
+ (car (car vars))
+ )
+ (cadr (car vars))
+ )
+ (make-exprs (cdr vars) exprs)
+ )
+ )
+ (exprs)
+ )
+ )
+ )
+ )
+ (setq exprs (make-exprs vars exprs))
+
+ ;
+ ; the parameters to the lambda is a list
+ ; of nils of the right length
+ ;
+ (setq make-nils (lambda (vars)
+ (cond (vars (cons nil (make-nils (cdr vars))))
+ )
+ )
+ )
+ ;
+ ; build the lambda.
+ ;
+ (cons
+ (list
+ 'lambda
+ (make-names vars)
+ (cond ((cdr exprs) (cons 'progn exprs))
+ ((car exprs))
+ )
+ )
+ (make-nils vars)
+ )
+ )
+ )
+ (car let-param)
+ (cdr let-param)
+ ()
+ ()
+ ()
+ )
+ )
+ )
+
+ ;
+ ; A slightly more convenient form
+ ; for defining lambdas.
+ ;
+ ; (defun <name> (<params>) s-exprs)
+ ;
+
+(def defun (macro (defun-param)
+ (let ((name (car defun-param))
+ (args (cadr defun-param))
+ (exprs (cdr (cdr defun-param))))
+ (list
+ def
+ name
+ (list
+ 'lambda
+ args
+ (cond ((cdr exprs)
+ (cons progn exprs))
+ ((car exprs))
+ )
+ )
+ )
+ )
+ )
+ )
+
+ ; simple math operators
+ ;
+ ; Do these last to run defun
+ ; at least once so the let macro
+ ; is resolved
+
+(defun 1+ (x) (+ x 1))
+(defun 1- (x) (- x 1))