anchor.diff:                  (values (nreverse keywords) body)))))
       (rec nil body)))
   
  +(defun speed>space (env)
  +  (> (policy-quality 'speed env)
  +     (policy-quality 'space env)))
  +
  +(defun space>speed (env)
  +  (> (policy-quality 'space env)
  +     (policy-quality 'speed env)))
  +
   (defmacro with-templated-body (&environment env (var expr)
                                               (&key ((:type overtype) (required-argument :type))
                                                     (subtypes (required-argument :subtypes))
  -                                                  in-subtypes)
  +                                                  in-subtypes
  +                                                  (inline t inline-supplied?))
                                  &body body)
     "Macro to instantiate fast paths for subtypes of a given type."
  +  (unless inline-supplied?
  +    (setf inline (not (space>speed env))))
     (let* ((subtypes
              (sort (remove-duplicates subtypes :test #'type=)
                    #'subtypep))
  
positive.code:                `(flet (,@(loop for fn in fns
                                 for type in subtypes
                                 collect `(,fn (,var)
                                               (declare (type ,type ,var))
                                               ,in-subtypes
                                               ,@body))
                         ,@(unsplice
                               (and default?
                                `(,default (,var)
  
negative.code:                    (unless (type= `(or ,@subtypes) overtype)
                       `(,overtype ,@body))))))
        `(let ((,var ,expr))
           ,(if inline
                (for-speed)
                (for-space))))))
  