anchor.diff:                 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) #'string<))
  +  (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))
  
positive.code:                `((defmethod pluralization ((,what (eql ',name)))
                     ,@pluralization))))))
  
  (define-category :function (symbol what)
    (:is (and (fboundp symbol) (not (typep (symbol-function symbol) 'generic-function))))
    (:docs (documentation symbol 'function)))
  
  (define-category :generic-function (symbol what)
    (:is (and (fboundp symbol)
              (typep (symbol-function symbol) 'generic-function)
              (not (is symbol :accessor))))
    (:docs (documentation symbol 'function)))
  
  (define-category :class (symbol what)
  
negative.code:   (:docs (documentation (find-class symbol) t)))
  
  (define-category :variable (symbol what)
    (:is (and (variable-p symbol) (not (is symbol :constant))))
    (:docs   (documentation symbol 'variable)))
  
  (define-category :constant (symbol what)
    (:is (and (variable-p symbol) (constantp symbol)))
    (:docs (documentation symbol 'variable)))
  
  (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)))
  
  
  