; evaluate a list of sexprs
-(setq progn (lexpr (l) (last l)))
+;(setq progn (lexpr (l) (last l)))
- ; simple math operators
-
-(setq 1+ (lambda (x) (+ x 1)))
-(setq 1- (lambda (x) (- x 1)))
- ; define a variable without returning the value
+ ;
+ ; Define a variable without returning the value
+ ; Useful when defining functions to avoid
+ ; having lots of output generated
+ ;
-(set 'def (macro (def-param)
+(setq def (macro (def-param)
(list
'progn
(list
; make the list of names in the let
;
- (set 'make-names (lambda (vars)
+ (setq make-names (lambda (vars)
(cond (vars
(cons (car (car vars))
(make-names (cdr vars))))
; pre-pended to the
; expressions to evaluate
;
- (set 'make-exprs (lambda (vars exprs)
+ (setq make-exprs (lambda (vars exprs)
(progn
(cond (vars (cons
(list set
)
)
)
- (set 'exprs (make-exprs vars exprs))
+ (setq exprs (make-exprs vars exprs))
;
; the parameters to the lambda is a list
; of nils of the right length
;
- (set 'make-nils (lambda (vars)
+ (setq make-nils (lambda (vars)
(cond (vars (cons nil (make-nils (cdr vars))))
)
)
;
; build the lambda.
;
- (set 'last-let-value
(cons
(list
'lambda
(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))