anchor.diff:  	(make-closure (cadr expr) (cddr expr)))
   
   ;;; Runs a closure object as a function by matching formal parameters with actual parameters
  -(defun lambda-run (name args)
  +(defun lambda-run (closure args)
   	(print "lambda-run")
  -	(let ((formal-args (get-formal name)) 
  -				(body-exprs (get-body name)))
  +	(push (make-envt) *envts*) ;;; make a local environment
  +	(let ((formal-args (get-formal closure)) 
  +				(body-exprs (get-body closure)))
   		(if (not (eql (length args) (length formal-args)))
   			(print "Error args not matching.")
   			(progn
   				(mapcar #'set-variable formal-args args)
  -				(car (mapcar #'evall body-exprs))))))
  +				(let ((result (last (mapcar #'evall body-exprs))))
  +					(print *envts*)
  +					(pop *envts*)
  +					(car result))))))
   
  +;;; Creates a new closure with the envts being a deep copy of the list of current environments do a copy tree or something
  +;;; needs to be a deep copy for lexical scope preservation
   (defun make-closure (formal body)
   	(list 'closure formal body))
   
  -;(defun get-envt (closure)
  -;	(car (cdr closure)))
  +(defun get-envt (closure)
  +	(car (cdr closure)))
  +
  +;;; Makes an environment for when the lambda function is running
  +;;; All parameters matched to formal arguments will be placed in this environment
  +(defun make-envt ()
  +	(make-hash-table :test #'equal))
   
   (defun get-formal (closure)
   	(car (cdr closure)))
   
   (defun get-body (closure)
  -	(car (cdr (cdr closure))))
  +	(car (cdr (cdr  closure))))
   
   (defun closure-p (expr)
   	(if (equal 'closure (car expr))
  
positive.code: ;;; Read-eval-print
  (defun revalp ()
  	(set-functions)
  	(format t "~% -->")
  	(print (evall (read)))
  	(revalp))
  
negative.code: 		expr
  		(progn
  			(if (consp expr) ;; change which one is running depending on if a function call or variable
  				(multiple-value-setq (sym fl) (get-variable (car expr) *envts*)) ;; to handle (f 3) for example 
  				(multiple-value-setq (sym fl) (get-variable expr *envts*)))
  			(if (eql t fl)
  				(if (not (consp sym))
  					sym ;; what the expr evaluates to
  