anchor.diff:    ;;               collect clause-body
     ;;             else collect
     ;;             `((member ,@(ensure-list cases)) ,@clause-body)))
  -  (check-exhaustiveness 'case type body)
  +  (check-exhaustiveness 'case type body env)
     (once-only (x)
       `(case ,x
          ,@body
  
positive.code:                (nand ,@(rest forms))
                 t))))
  
  (defun check-exhaustiveness (style type body)
    ;; 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)
                 (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)
                 (warn "Non-exhaustive match: ~s is not the same as ~s"
                       partition type)))
             (check-subtypes (body)
  
negative.code:                collect `(,type ,@b)
               else collect `((member ,@(ensure-list k)) ,@b))))
  
  (defmacro ctypecase-of (type keyplace &body body &environment env)
    "Like `etypecase-of', but providing a `store-value' restart to correct KEYPLACE and try again."
    (check-exhaustiveness 'typecase type body env)
    `(ctypecase ,keyplace ,@body))
  
  (defmacro ccase-of (type keyplace &body body &environment env)
    "Like `ecase-of', but providing a `store-value' restart to correct KEYPLACE and try again."
    (check-exhaustiveness 'case type body env)
    `(ccase ,keyplace ,@body))
  
  (defmacro case-using (pred keyform &body clauses)
  