anchor.diff:                (when readme
                   (format s "~a" readme)))
   
  -            (loop for what in '(:class :function :generic-function :accessor :variable :constant) do
  -                 (format s "~&<h2>~:(~a~a~)</h2>~&<table>" what (pluralization what))
  +            (loop for what in *categories* do
  +                 (format s "~&<h2>~:(~a~)</h2>~&<table>" (pluralization what))
                    (loop for sym in (names package what) do
                         (format s "~&<tr><td class='symbol'>~(~a~)</td><td class='docs'>~a</td></tr>" sym (docs-for sym what)))
                    (format s "~&</table>"))
  
positive.code: (in-package :manifest)
  
  (defvar *manifest-server* nil)
  
  (defun start (&key (port 0))
    "Start the manifest server and return the URL to browse. By default
  
negative.code: (defgeneric docs-for (symbol what))
  (defgeneric pluralization (what))
  
  (defmethod pluralization (what) (format nil "~as" what))
  
  (defmacro define-category (name (symbol what) &body body)
    (let ((is-test (cdr (assoc :is body)))
          (get-docs (cdr (assoc :docs body)))
          (pluralization (cdr (assoc :pluralization body))))
      `(progn
         (defmethod is (,symbol (,what (eql ',name))) ,@is-test)
         (defmethod docs-for (,symbol (,what (eql ',name))) ,@get-docs)
         ,@(when pluralization
                 `((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)
    (:is (and (find-class symbol nil) (not (is symbol :condition))))
    (:docs (documentation (find-class symbol) t))
    (:pluralization (format nil "~aes" what)))
  
  (define-category :condition (symbol what)
    (:is (and (find-class symbol nil) (subtypep (find-class symbol nil) 'condition)))
    (:docs (documentation (find-class symbol) t)))
  
  (define-category :variable (symbol what)
    (:is (and (boundp symbol) (not (constantp symbol))))
    (:docs   (documentation symbol 'variable)))
  
  (define-category :constant (symbol what)
    (:is (and (boundp 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)))
  
  
  
  
  