anchor.diff:  							((equal 'lambda (car expr)) (lambda-eval expr))
   							(t 
   								(multiple-value-setq (op flag) (get-function (car expr)))
  +								(print "last...")
   								(if (eql flag t)
  -								(apply op (mapcar #'evall (rest expr))))))))))
  +									(apply op (mapcar #'evall (rest expr))))))))))
   
   ;;; Creates a closure object given a lambda expression
   ;;; Doesn't run the function because it has no actual arguments only defines the function to be called later
  
positive.code: ;;; (set! var 2)
  ;;; (set! var (lambda (x) (* x x))) for example
  ;;; TODO remove the seperate case for functions there shouldn't be a need for a seperate case
  (defun set-eval (expr)
  	(print "set-eval")
  	(print (caddr expr))
  	(set-variable (cadr expr) (evall (caddr expr))))
  	
  ;;; Hash table for holding user defined functions and variables 
  (defvar *sym-table* (make-hash-table :test #'equal))
  
  (defun set-variable (sym val)
  	(setf (gethash sym *sym-table*) val))
  
  (defun get-variable (sym)
  	(gethash sym *sym-table*))
  
  (defvar *func-table* (make-hash-table :test #'equal))
  
  
negative.code: 	(make-closure (cadr expr) (cddr expr)))
  
  ;;; Runs a closure object as a function by matching formal parameters with actual parameters
  (defun lambda-run (closure args)
  	(print "lambda-run")
  	(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)
  				(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)))
  
  ;;; 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))))
  
  (defun closure-p (expr)
  	(if (equal 'closure (car expr))
  