anchor.diff:  ;;;; * Utils
   
   (defun lisp1s (forms)
  +  "Convert a list of forms to Lisp-1 style."
     (mapcar #'lisp1 forms))
   
   (defun lisp1b (binds)
  +  "Convert an alist of (VAR . FORM) to Lisp-1 style."
     (mapcar (lambda (bind)
   	    (cons (car bind)
   		  (lisp1 (cdr bind))))
  
positive.code: 
  (deflisp1-walker multiple-value-call-form (func arguments)
    (new 'multiple-value-call-form
         :func      (lisp1 func)
         :arguments (lisp1s arguments)))
  
  (deflisp1-walker multiple-value-prog1-form (first-form other-forms)
    (new 'multiple-value-prog1-form
         :first-form  (lisp1 first-form)
         :other-forms (lisp1s other-forms)))
  
  (deflisp1-walker symbol-macrolet-form (binds body)
  
negative.code: 	 :body      (lisp1s body))))
  
  (deflisp1-walker free-variable-reference (name)
    ;; If a free variable is bound in the toplevel, *and* not bound by
    ;; an enclosing lambda, then we'll return that function.  We take
    ;; advantage of the fact that the `name' slot is shared.
    (if (and (fboundp name) (not (member name *bound-vars*)))
        (change-class form 'free-function-object-form)
        form))
  
  (deflisp1-walker application-form (operator arguments)
    ;; We transform all applications so they use explicit funcall.  We
    ;; also must take into account ((a b) c ...) which must also
    ;; transform the operator accordingly.
    (new 'free-application-form
         :operator  'funcall
         :arguments (cons (if (not (typep operator 'form))
  