anchor.diff:    (:docs (documentation (find-class symbol) t)))
   
   (define-category :variable (symbol what)
  -  (:is (and (boundp symbol) (not (constantp symbol))))
  +  (:is (and (variable-p symbol) (not (is symbol :constant))))
     (:docs   (documentation symbol 'variable)))
   
   (define-category :constant (symbol what)
  -  (:is (and (boundp symbol) (constantp symbol)))
  +  (:is (and (variable-p symbol) (constantp symbol)))
     (:docs (documentation symbol 'variable)))
   
  -(define-category :accessor (symbol what)
  -  (:is (and (fboundp symbol)
  -            (fboundp `(setf ,symbol))
  -            (typep (fdefinition symbol) 'generic-function)
  -            (typep (fdefinition `(setf ,symbol)) 'generic-function)))
  -  (:docs (documentation symbol 'function)))
  -
  -
  -
  -
  +(define-category :slot-accessor (symbol what)
  +  (:is (and (generic-function-p symbol)
  +            (some (lambda (m)
  +                    (or (eql (class-of m) (find-class 'standard-reader-method))
  +                        (eql (class-of m) (find-class 'standard-writer-method))))
  +                  (generic-function-methods (fdefinition symbol)))))
  +  (:docs (gf-docs symbol)))
  +
  +
  
positive.code:                  (setf some-docs-p t)
                   (format s "~&<h2>~:(~a~)</h2>~&<table>" (pluralization what))
                   (loop for sym in names do
                        (format s "~&<tr><td class='symbol'>~a</td>
  <td class='docs'>~a</td></tr>"
                                (escape-for-html (string-downcase sym))
                                (escape-for-html (or (docs-for sym what) "NO DOCS!"))))
                   (format s "~&</table>"))
  
  
negative.code:                while line do (write-line line s))))))))
  
  (defun names (package what)
    (sort
     (loop for sym being the external-symbols of package
        when (is sym what) collect sym
        when (is `(setf ,sym) what) collect `(setf ,sym))
     #'name<))
  
  (defun name< (n1 n2)
    (cond
      ((and (symbolp n1) (symbolp n2))
       (string< n1 n2))
      ((and (symbolp n1) (listp n2))
       (cond
         ((string< n1 (second n2)) t)
         ((string< (second n2) n1) nil)
         (t t)))
      ((and (listp n1) (symbolp n2))
       (cond
         ((string< (second n1) n2) t)
         ((string< n2 (second n1)) nil)
         (t nil)))
      ((and (listp n1) (listp n2))
       (string< (second n1) (second n2)))))
  
  
  (defgeneric is (symbol what))
  (defgeneric docs-for (symbol what))
  