anchor.diff:      rules))
   
   (defmethod serialize-object ((rule auto-mode-rule) stream)
  -  (flet ((write-if-present (slot)
  +  (flet ((write-if-present (slot &key modes-p)
              (when (funcall slot rule)
                (format t " :~a ~s"
                        slot
  -                     (funcall slot rule)))))
  +                     (let ((value (funcall slot rule)))
  +                       (if modes-p
  +                           (mapcar #'maybe-mode-name value)
  +                           value))))))
       (let ((*standard-output* stream)
             (*print-case* :downcase))
         (write-string "(" stream)
  
positive.code:                   mode)))
      (if (symbolp mode) mode (mode-name mode))))
  
  (declaim (ftype (function ((or symbol root-mode list) (or symbol root-mode)) boolean)
                  mode-equal))
  (defun mode-equal (mode1 mode2)
    (string-equal (symbol-name (maybe-mode-name mode1))
                  (symbol-name (maybe-mode-name mode2))))
  
  (defun rememberable-of (modes auto-mode)
    (if auto-mode
        (set-difference modes (non-rememberable-modes auto-mode)
                        :test #'mode-equal)
  
negative.code:                (= 2 (length (test rule))))
            (format t "~s " (second (test rule)))
            (format t "~s " (test rule)))
        (write-if-present 'included :modes-p t)
        (write-if-present 'excluded :modes-p t)
        (write-if-present 'exact-p)
        (write-string ")" stream))))
  
  