; 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))