anchor.diff:        ;; 1. Hoisting variable definitions with constant initforms. We
         ;; do this so SBCL (and CMUCL) can infer types better.
   
  -      ;; 2. Descending into binding forms. This is so we can support
  -      ;; macros that expand into the let-over-defun style.
  -
  -      ;; 3. Supporting for non-initial macros. In particular, local
  -      ;; macro definitions should only take effect *after* they are
  -      ;; declared, and, after they are declared, they must be
  -      ;; available to `expand-partially'.
  -
  -      ;; TODO Would it better to use augment-environment in Lisps that
  -      ;; support it?
  +      ;; 2. Descending into binding forms. One of the reasons for
  +      ;; `local' to exist in the first place is so macros that expand
  +      ;; into top-level definitions can be used to create local
  +      ;; definitions. That means we need to support, at least, the
  +      ;; let-over-defun style.
  +
  +      ;; 3. Supporting macros. Support for macros that precede other
  +      ;; defintions is trivial: we just move them out of the `local'
  +      ;; form. Support for macros in other positions is hard. We need
  +      ;; to make sure they only take effect *after* they are declared,
  +      ;; and that, after they are declared, they are available to
  +      ;; `expand-partially' -- all without resorting to
  +      ;; augment-environment.
         (labels ((in-env? ()
  +                 "Are we within a binding form, or are there symbol
  +macros or macros in effect?"
                    (or in-let? symbol-macros macros))
  +               (at-beginning? ()
  +                 "Return non-nil if this is the first form in the `local'."
  +                 (nor vars hoisted-vars labels macros symbol-macros exprs in-let?))
                  (wrap-symbol-macros (body)
                    (if symbol-macros
                        `((symbol-macrolet ,symbol-macros
  
positive.code:                          ,@body))
                       body))
                 (wrap-macro-env (body)
                   (wrap-symbol-macros
                    (wrap-macros
                     body)))
  
negative.code:                    ((list* (and name (type symbol)) _)
                      (if (assoc name macros)
                          (progn
                            (warn "Within a `local' form, a macro that ~
                            follows other expressions cannot be used in ~
                            partial expansions.
  
  You can fix this by moving the definition of ~a to the top of the ~
                                  `local' form." name)
                            (macroexpand-1 form env))
                          (macroexpand-1 form env)))
                     (otherwise
                      (macroexpand-1 form env))))
                 (expand (form env)
                   "Like `macroexpand', but using `expand-1'."
                   (multiple-value-bind (exp exp?)
                       (expand-1 form env)
                     (if exp?
                         (expand exp env)
                         exp)))
                 (expand-body (body)
                   "Shorthand for recursing on an implicit `progn'."
                   (expand-partially `(progn ,@body)))
                 (expand-partially (form)
                   "Macro-expand FORM until it becomes a definition form or macro expansion stops."
                   (if (consp form)
  