anchor.diff:               (&key          (entering-&key))
                (&rest         (process-&rest))
                (&optional     (entering-&optional))
  +             (&body         (process-&body))
  +             (&environment  (process-&environment))
                ((&whole &aux &allow-other-keys) (fail))
                (t             (process-required))))
  -         (process-required ()
  -           (unless args
  -             (done))
  +         (process-&body ()
  +           (assert (eq (first args) '&body))
  +           (pop args)
  +           (unless macro
  +             (fail))
  +           (let ((body (pop args)))
  +             (unless (null args)
  +               (fail))
  +             (unless body
  +               (fail))
  +             (funcall visitor '&body body body)))
  +         (process-&environment ()
  +           (assert (eq (first args) '&environment))
  +           (pop args)
  +           (unless macro
  +             (fail))
  +           (let ((env (pop args)))
  +             (unless env
  +               (fail))
  +             (funcall visitor '&environment env env))
              (case (first args)
                (&key          (entering-&key))
                (&rest         (process-&rest))
                (&optional     (entering-&optional))
  +             (&body         (process-&body))
  +             (&aux          (process-&aux))
  +             ((&whole &environment &allow-other-keys) (fail))
  +             (t             (process-required))))
  +         (process-required ()
  +           (unless args
  +             (done))
  +           (case (first args)
  +             (&key          (entering-&key))
  +             (&rest         (process-&rest))
  +             (&optional     (entering-&optional))
  +             (&body         (process-&body))
  +             (&environment  (process-&environment))
                ((&whole &allow-other-keys) (fail))
                (&aux          (entering-&aux))
                (t
  
positive.code:            (case (first args)
               (&key               (entering-&key))
               (&rest              (process-&rest))
               ((&whole &optional &allow-other-keys) (fail))
               (&aux               (entering-&aux))
               (t
                (let ((arg (ensure-list (pop args))))
  
negative.code:              (done))
             (case (first args)
               (&key               (entering-&key))
               (&environment       (process-&environment))
               ((&whole &optional &rest &body &allow-other-keys) (fail))
               (&aux               (entering-&aux))
               (t                  (fail))))
           (entering-&optional ()
  