anchor.diff:  
   ;;; Are these worth exporting?
   
  -(defmacro with-boolean (var &body body)
  -  (multiple-value-bind (body decls) (parse-body body)
  -    `(with-read-only-var (,var)
  -       ,@decls
  -       (if ,var
  -           ,@body
  -           ,@body))))
  +(defmacro with-boolean (var &body body
  +                        &environment env)
  +  (if (space-beats-speed? env)
  +      `(locally ,@body)
  +      (multiple-value-bind (body decls) (parse-body body)
  +        `(with-read-only-var (,var)
  +           ,@decls
  +           (if ,var
  +               ,@body
  +               ,@body)))))
   
   (defmacro with-nullable ((var type) &body body)
     `(with-type-dispatch (null ,type) ,var
        ,@body))
   
  -(defmacro with-test-fn ((test) &body body)
  +(defmacro with-test-fn ((test) &body body
  +                        &environment env)
     "Specialize BODY on the most common test functions."
     (check-type test symbol)
  -  `(cond ((eql ,test #'eq)
  -          (macrolet ((,test (x y) `(eq ,x ,y)))
  -            ,@body))
  -         ((eql ,test #'eql)
  -          (macrolet ((,test (x y) `(eql ,x ,y)))
  -            ,@body))
  -         ((eql ,test #'equal)
  -          (macrolet ((,test (x y) `(equal ,x ,y)))
  -            ,@body))
  -         ;; ((eql ,test #'equalp)
  -         ;;  (macrolet ((,test (x y) `(equalp ,x ,y)))
  -         ;;    ,@body))
  -         (t (let ((,test (ensure-function ,test)))
  -              (macrolet ((,test (x y) (list 'funcall ',test x y)))
  -                ,@body)))))
  -
  -(defmacro with-key-fn ((key) &body body)
  +  (if (space-beats-speed? env)
  +      `(locally ,@body)
  +      `(cond ((eql ,test #'eq)
  +              (macrolet ((,test (x y) `(eq ,x ,y)))
  +                ,@body))
  +             ((eql ,test #'eql)
  +              (macrolet ((,test (x y) `(eql ,x ,y)))
  +                ,@body))
  +             ((eql ,test #'equal)
  +              (macrolet ((,test (x y) `(equal ,x ,y)))
  +                ,@body))
  +             ;; ((eql ,test #'equalp)
  +             ;;  (macrolet ((,test (x y) `(equalp ,x ,y)))
  +             ;;    ,@body))
  +             (t (let ((,test (ensure-function ,test)))
  +                  (macrolet ((,test (x y) (list 'funcall ',test x y)))
  +                    ,@body))))))
  +
  +(defmacro with-key-fn ((key) &body body &environment env)
     "Specialize BODY on the most common key functions."
     (check-type key symbol)
     `(let ((,key (canonicalize-key ,key)))
  -     (cond ((eql ,key #'identity)
  -            (macrolet ((,key (x) x))
  -              ,@body))
  -           (t (macrolet ((,key (x) (list 'funcall ',key x)))
  -                ,@body)))))
  +     ,@(if (space-beats-speed? env)
  +           body
  +           `((cond ((eql ,key #'identity)
  +                    (macrolet ((,key (x) x))
  +                      ,@body))
  +                   (t (macrolet ((,key (x) (list 'funcall ',key x)))
  +                        ,@body)))))))
   
   (declaim (ftype (function (t) boolean) true))
   (declaim (inline true))
  
positive.code:         unless (subtypep subtype type env)
            do (error "~s is not a subtype of ~s" subtype type))
    (type= type `(or ,@subtypes)))
  
  (defparameter *vref-by-type*
    (stable-sort
  
negative.code: the `string-dispatch' macro used internally in SBCL. But most of the
  credit should go to the paper \"Fast, Maintable, and Portable Sequence
  Functions\", by Irène Durand and Robert Strandh."
    (declare #+sbcl (sb-ext:muffle-conditions sb-ext:code-deletion-note))
    (let ((types (simplify-subtypes types)))
      (cond ((null types)
             `(progn ,@body))
            ((space-beats-speed? env)
             (simple-style-warning "Not using type dispatch (space>speed).")
             `(progn ,@body))
            ;; The advantage of the CMUCL/SBCL way (I hope) is that the
            ;; compiler can decide /not/ to bother inlining if the type
  