anchor.diff:  
   ;;; Collect a list of all the keys for ecase or ccase 
   ;;; to be used as the `exptected type' in error reporting.
  -(defun collect-e/ccase-keys (clauses)
  +(defun collect-e/ccase-keys (clauses name)
     (if (null clauses)
         nil
         (append 
  
positive.code: 		       (not (null keys)))
  		  `(if (eql ,variable ,keys)
  		       (progn ,@forms)
  		       ,(expand-e/ccase-clauses (cdr clauses) variable final))
  		  `(if (or ,@(eql-ify keys variable))
  		       (progn ,@forms)
  		       ,(expand-e/ccase-clauses (cdr clauses) variable final))))))))
  
  ;;; For ECASE, the default is to signal a type error. 
  (defmacro ecase (keyform &rest clauses)
    (let* ((variable (gensym))
  	 (keys (collect-e/ccase-keys clauses))
  	 (final `(error 'ecase-type-error
  			:datum ,variable
  			:expected-type '(member ,@keys))))
      `(let ((,variable ,keyform))
         ,(expand-e/ccase-clauses clauses variable final))))
  
  ;;; This function is does the same thing as
  ;;; (mapcar #'list vars vals), but since we are not
  
negative.code:       'nil
        (if (not (consp clauses))
  	  (error 'malformed-case-clauses
  		 :name 'case
  		 :clauses clauses)
  	  (let ((clause (car clauses)))
  	    (unless (and (proper-list-p clause)
  			 (not (null clause)))
  	      (error 'malformed-case-clause
  		     :name 'case
  		     :clause clause))
  	    (if (or (eq (car clause) 'otherwise)
  		    (eq (car clause) t))
  		(if (null (cdr clauses))
  		    `(progn ,@(cdr clause))
  		    (error 'otherwise-clause-not-last
  			   :name 'case
  			   :clauses (cdr clauses)))
  		;; it is a normal clause
  		(let ((keys (car clause))
  