anchor.diff:  (defparameter *slot-writers-ink*  +black+)
   (defparameter *slot-documentation-ink* +turquoise4+)
   
  -
   (defun present-slot (slot class &key (stream *standard-output*))
     "Formats a slot definition into a table row."
     (let* ((name (clim-mop:slot-definition-name slot))
  
positive.code:       (setf gfs (append gfs (x-specializer-direct-generic-functions x))))
      (remove-duplicates gfs)))
  
  (defun not-really-symbol< (a b)
    (when (and (consp a)
               (second a)
               (symbolp (second a)))
      (setf a (second a)))
    (when (and (consp b)
               (second b)
               (symbolp (second b)))
      (setf b (second b)))
    (unless (and (symbolp a) (symbolp b))
      (return-from not-really-symbol< (string< (princ-to-string a)
                                               (princ-to-string b))))
    (cond ((not (eq (symbol-package a)
                    (symbol-package b)))
           (string< (package-name (symbol-package a))
                    (package-name (symbol-package b))))
          (T (string< (symbol-name a) (symbol-name b)))))
  
  (define-command (com-show-class-generic-functions
                   :name "Show Class Generic Functions"
  
negative.code:     (if (null class)
          (note "~A is not a defined class." class-spec)
        (let ((funcs (sort (class-funcs class) (lambda (a b)
                                                 (slot-name-sortp (clim-mop:generic-function-name a)
                                                                  (clim-mop:generic-function-name b))))))
          (with-text-size (T :small)
            (format-items funcs :printer (lambda (item stream)
                                           (present item 'generic-function :stream stream))
  