anchor.diff:  (defun evall (expr)
   	(if (atomp expr)
   		expr
  -		(cond ((equal 'if (car expr)) (if-eval expr))
  -					(t 
  -						(multiple-value-setq (op flag) (get-function (car expr)))
  -						(if (eql flag t)
  -						(apply op (mapcar #'evall (rest expr))))))))
  +		(progn
  +			(multiple-value-setq (sym fl) (get-variable expr))
  +			(if (eql t fl)
  +				sym ;; what the expr evaluates to
  +				(cond ((equal 'if (car expr)) (if-eval expr))
  +							((equal 'set! (car expr)) (set-eval expr))
  +							(t 
  +								(multiple-value-setq (op flag) (get-function (car expr)))
  +								(if (eql flag t)
  +								(apply op (mapcar #'evall (rest expr))))))))))
   
   ;;; Evaluates an IF expression
   ;;; (if-eval (if (= 1 1) 1 2)
  
positive.code: 	(if (eql t (evall (cadr expr)))
  		(evall (caddr expr))
  		(evall (cadddr expr))))
  
  (defvar *func-table* (make-hash-table :test #'equal))
  
  
negative.code: 	(setf (gethash 'list *func-table*) #'list)
  	(setf (gethash 'car *func-table*) #'car)
  	(setf (gethash 'cdr *func-table*) #'cdr)
  	(setf (gethash 'cons *func-table*) #'cons)
  	(setf (gethash 'and *func-table*) #'scheme-and)
  	(setf (gethash 'or *func-table*) #'scheme-or)
  	(setf (gethash 'not *func-table*) #'scheme-not))
  
  ;;; TODO add &rest to handle arbitrary number of arguments
  (defun scheme-and (expr1 expr2)
  	(if (and (eql t expr1) (eql t expr2))
  		t 
  		nil))
  
  (defun scheme-or (expr1 expr2)
  	(if (or (eql t expr1) (eql t expr2))
  		t 
  		nil))
  
  (defun scheme-not (expr)
  	(if (eql t expr)
  		nil
  		t))
  
  (defun get-function (op)
  	(gethash op *func-table*))
  