anchor.diff:                     ,@clauses))))))
   
   (eval-and-compile
  -  (defun expand-string-case (cases)
  -    (loop for (keys . body) in cases
  -          append (loop for key in keys
  -                       collect (cons key body)))))
  +  (defun expand-string-case (sf default cases)
  +    "Expand a string-case macro with a minimum of duplicated code."
  +    (once-only (sf)
  +      (let ((keys (mapcar #'car cases)))
  +        (flet ((single (l) (null (cdr l))))
  +          (if (every #'single keys)
  +              ;; Simple.
  +              `(string-case:string-case (,sf :default ,default)
  +                 ,@(loop for ((k) . body) in cases
  +                         collect (cons k body)))
  +              (let* ((simple (remove-if-not #'single cases :key #'car))
  +                     (complex (set-difference cases simple)))
  +                (with-gensyms (block)
  +                  `(block ,block
  +                     ,(let ((tags (make-gensym-list (length complex) (string 'body))))
  +                        `(tagbody
  +                            (return-from ,block
  +                              (string-case:string-case (,sf :default ,default)
  +                                ,@(loop for ((key) . body) in simple
  +                                        collect `(,key ,@body))
  +                                ,@(loop for keys in (mapcar #'car complex)
  +                                        for tag in tags
  +                                        append (loop for k in keys
  +                                                     collect `(,k (go ,tag))))))
  +                            ,@(loop for tag in tags
  +                                    for body in (mapcar #'cdr complex)
  +                                    append `(,tag (return-from ,block (progn ,@body)))))))))))))))
   
   (defmacro string-case (stringform &body cases)
     "Efficient `case'-like macro with string keys.
  
positive.code:   (if (not clauses)
        nil
        (destructuring-bind ((key . body) . clauses) clauses
          (if (or (eql key t)
                  (eql key 'otherwise))
              `(progn ,@body)
              `(if (or ,@(mapcar (lambda (key)
                                   `(funcall ,pred ,keyform ',key))
  
negative.code: This uses Paul Khuong's `string-case' macro internally."
    (multiple-value-bind (cases default)
        (normalize-cases cases)
      (expand-string-case stringform `(progn ,@default) cases)))
  
  ;; TODO More informative error.
  (defmacro string-ecase (stringform &body cases)
  