anchor.diff:        (adder 2))
       => 4
   
  +\(At the moment this does *not* work for macros.\)
  +
   The value returned by the `local` form is that of the last form in
   BODY. Note that definitions have return values in `local' just like
   they do at the top level. For example:
  
positive.code:                             `((,macro? (,def) ,@(expand-top (rest forms)))))
                             ((nil)
                              (cons exp (expand-top (rest forms)))))))))
                 (compile-macro-function (args body)
                   "Compile a macro function into a form acceptable to `augment-environment.'"
                   (multiple-value-bind (env-var args)
                       (if-let (tail (member '&environment args))
                         (values (cadr tail)
                                 (append (ldiff args tail) (cdr tail)))
                         (values (gensym (string 'env))
                                 args))
                     (with-gensyms (f)
                       (compile nil (eval `(lambda (,f ,env-var)
                                             (declare (ignorable ,env-var))
                                             (destructuring-bind ,args (rest ,f)
                                               ,@body)))))))
                 (expand-1 (form env)
                   "Like macroexpand-1 with local macro and symbol macro definitions."
  
negative.code:       ;; 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'.
        (labels ((expand-top (forms)
                   "Expand FORMS recursively, wrapping with macros as they are defined."
                   (if (null forms)
  