anchor.diff:    (dolist (form forms)
       (evaluate form env fenv)))
   
  -(defun eval-list (list env fenv)
  -  (mapcar (lambda (exp) (evaluate exp env fenv)) list))
  -
   (defun invoke (function args)
     (if (functionp function)
         (funcall function args)
  
positive.code:     (symbol (lookup form env))
  
      ;; Compound form
      (cons (case (car form)
              (|quote| (cadr form))
              (|if| (if (not (eq (evaluate (cadr form) env fenv) *false*))
                        (evaluate (caddr form) env fenv)
                        (evaluate (cadddr form) env fenv)))
              (|do| (eval-do (cdr form) env fenv))
              (|set!| (setf (lookup (cadr form) env)
                            (evaluate (caddr form) env fenv)))
              (|lambda| (make-function (cadr form) (cddr form) env fenv))
              (|function| (if (symbolp (cadr form))
                              (lookup (cadr form) fenv)
                              (error "No such function: ~A" (cadr form))))
              (|flet| (eval-do (cddr form) env (extend fenv (mapcar #'car (cadr form))
                                                       (mapcar (lambda (def)
                                                                 (make-function (cadr def)
                                                                                (cddr def)
                                                                                env fenv))
                                                               (cadr form)))))
              (otherwise (evaluate-application (car form)
                                               (eval-list (cdr form) env fenv)
                                               fenv))))
  
      ;; Self-evaluating object
      (t form)))
  
negative.code:   (lambda (values)
      (eval-do body (extend env variables values) fenv)))
  
  (defun evaluate (form env fenv)
    (typecase form
  
  