anchor.diff:                 (nand ,@(rest forms))
                  t))))
   
  -(defun check-exhaustiveness (style type body)
  +(defun check-exhaustiveness (style type body env)
     ;; Should we do redundancy checking? Is there any Lisp that doesn't
     ;; already warn about that?
     (check-type style (member case typecase))
  -  (labels ((check-subtypep (subtype)
  -             (unless (subtypep subtype type)
  +  (labels ((subtype? (subtype type) (subtypep subtype type env))
  +           (same-type? (type1 type2) (and (subtype? type1 type2) (subtype? type2 type1)))
  +           (check-subtypep (subtype)
  +             (unless (subtype? subtype type)
                  (warn "~s is not a subtype of ~s" subtype type)))
              (check-exhaustive (partition)
                ;; TODO It would be nice if we could list the types that
                ;; are not matched, or (per OCaml) given an example of a
                ;; value.
  -             (unless (type= partition type)
  +             (unless (same-type? partition type)
                  (warn "Non-exhaustive match: ~s is not the same as ~s"
                        partition type)))
              (check-subtypes (body)
  
positive.code:   ;;               collect clause-body
    ;;             else collect
    ;;             `((member ,@(ensure-list cases)) ,@clause-body)))
    (check-exhaustiveness 'case type body)
    (once-only (x)
      `(case ,x
         ,@body
  
negative.code:                :datum ,x
                 :expected-type ',type)))))
  
  (defmacro ecase-of (type x &body body &environment env)
    "Like `ecase' but, given a TYPE (which should be defined as `(member
  ...)'), warn, at compile time, unless the keys in BODY are all of TYPE
  and, taken together, they form an exhaustive partition of TYPE."
  