anchor.diff:    #+sb-package-locks (:implement :serapeum :serapeum/internal-definitions))
   
   (in-package :serapeum/internal-definitions)
  -
  -(defvar *subenv*)
   
   (defstruct-read-only (unbound
                         (:constructor unbound (var)))
  
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: 
  The `local' macro is loosely based on Racket's support for internal
  definitions."
    (multiple-value-bind (body decls) (parse-body orig-body)
      (catch 'local
        (generate-internal-definitions
         (make 'internal-definitions-env
               :decls decls
               :env env)
         body))))
  
  (defmacro block-compile ((&key entry-points
                                 (block-compile t))
  