anchor.diff:      ;; issue.
       (t `(progn ,@body))))
   
  -(defmacro with-type-dispatch ((&rest types) var &body body)
  +(defmacro with-type-dispatch ((&rest types) var &body body
  +                              &environment env)
     "A macro for writing fast sequence functions (among other things).
   
   In the simplest case, this macro produces one copy of BODY for each
  
positive.code: 
  ;;; 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-nullable ((var type) &body body)
    `(with-type-dispatch (null ,type) ,var
       ,@body))
  
  (defmacro with-test-fn ((test) &body body)
    "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)
    "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)))))
  
  (declaim (ftype (function (t) boolean) true))
  (declaim (inline true))
  
negative.code:         unless (subtypep subtype type env)
            do (error "~s is not a subtype of ~s" subtype type))
    (type= type `(or ,@subtypes)))
  
  (defun space-beats-speed? (env)
    (> (policy-quality 'space env)
       (policy-quality 'speed env)))
  
  (defparameter *vref-by-type*
    (stable-sort
  