anchor.diff:                                    decls
                                     (cons var binds-out))
                          (let* ((init (initialization-value var decls))
  -                              (bind (if init `(,var ,init) var)))
  +                              (bind `(,var ,init)))
                            (binds-out binds-in
                                       decls
                                       (cons bind binds-out))))))))
       ;; Shortcut: no declarations, just return the bindings.
  -    (if (null decls)
  -        binds-in
  -        (binds-out binds-in decls '()))))
  +    (binds-out binds-in decls '())))
   
   (defmacro let-initialized (bindings &body body &environment env)
     "Like LET, but if any of BINDINGS are uninitialized, try to give
  
positive.code:            (initialization-value (var decls)
               (let ((type (var-decls-type var decls)))
                 (cond
                   ;; Needless; this is the default behavior.
                   #+ () ((type=? type 'boolean) nil)
                   ((or (type=? type 'bit)
                        (type=? type 'fixnum)
                        (type=? type 'array-index)
  
negative.code: (in-package :serapeum/internal-definitions)
  
  (defvar *subenv*)
  
  (defstruct-read-only (unbound
                        (:constructor unbound (var)))
    "Placeholder for an unbound variable."
    (var :type symbol))
  
  (defmacro without-internal-definitions (&body body)
    `(progn ,@body))
  