anchor.diff:                 (mapcar #'expand-binding)
                  (mapply #'var))))
       (copy-subenv subenv
  -                 :vars (append vars (.vars subenv)))))
  +                 :vars (append vars (subenv-vars subenv)))))
   
   (defun augment/symbol-macros (symbol-macros &optional (subenv *subenv*))
     (copy-subenv subenv
                  :vars (append (mapply #'symbol-macro symbol-macros)
  -                             (.vars subenv))))
  +                             (subenv-vars subenv))))
   
   (defun augment/block (block &optional (subenv *subenv*))
     (copy-subenv subenv
  -               :blocks (cons block (.blocks subenv))))
  +               :blocks (cons block (subenv-blocks subenv))))
   
   (defun augment/tags (tags &optional (subenv *subenv*))
     (copy-subenv subenv
  -               :tags (append tags (.tags subenv))))
  +               :tags (append tags (subenv-tags subenv))))
   
   (defun tagbody-tag? (form)
     (typep form '(or symbol integer)))
  
positive.code:           ((progn &body body)
             (if (single body)
                 (expand-partially self (first body))
                 (if *subenv*
                     `(progn ,@(mapcar (op (expand-partially self _)) body))
                     (splice-forms self body))))
  
            (((prog1 multiple-value-prog1) f &body body)
             ;; We could simply expand `prog1' and
             ;; `multiple-value-prog1' in terms of `let', but we don't
             ;; want to do that, because they can be compiled more
             ;; efficiently (especially `multiple-value-prog1').
             (let ((*subenv* (ensure-subenv)))
               `(,(car form) ,(expand-partially self f)
                 ;; Force a subenv, since progns can't be spliced.
                 ,(expand-body self body))))
  
            ((prog2 first second &body body)
             `(progn ,first
  
negative.code:                :funs (append (mapcar (lambda (spec)
                                         (fun (first spec) (rest spec)))
                                       funs)
                               (subenv-funs subenv))))
  
  ;;; Of course this isn't used at the moment.
  (defun augment/macros (macros &optional (subenv *subenv*))
    (copy-subenv subenv
                 :funs (append (mapply #'macro macros)
                               (subenv-funs subenv))))
  
  (defun visible-of-type (type subenv)
    (let* ((vars (subenv-vars subenv))
           (visible (remove-duplicates vars :from-end t :key #'binding-name))
           (of-type (remove-if-not (of-type type) visible)))
      of-type))
  