anchor.diff:  		thing
   		(intern (symbol-name thing) package)))
       (string (intern thing package))))
  -
  -(defun kind-mappings (kind)
  -  (case (form-keyword kind)
  -    (:macro '(macro function))
  -    (t kind)))
        
   (defextension (docs :arguments ((name) (kind)))
     (bind ((*package* (or (docs-package) *package*))
   	 (thing (ensure-symbol name *package*))
  -	 (kind-or-kinds 
  -	  (loop for kind in (ensure-list
  -			     (or (kind-mappings (and kind (ensure-symbol kind)))
  -				 '(function variable package setf
  -				   type structure compiler-macro
  -				   method-combination t)))
  -	     when (documentation thing kind) collect
  -	     kind))
  -	 (kind (when (consp kind-or-kinds) (first kind-or-kinds))))
  +	 ((values kinds nil)
  +	  (aif (symbol-identities-with-docstring thing kind)
  +	       (values it t)
  +	       (values (mapcar (lambda (x) (cons x nil))
  +			       (symbol-identities thing)) nil)))
  +	 (kind (first kinds)))
       (ecase phase 
         (:parse
  -       ;;?? could memoize this
  -       (when (consp kind-or-kinds)
  -	 (when (> (length kind-or-kinds) 1)
  -	   (warn "Multiple docstrings found for ~s; specify type (using ~a)" 
  -		 name (first kind-or-kinds)))
  -	 (setf kind-or-kinds (first kind-or-kinds)))
  -       (when (and (consp kind-or-kinds) (> (length kind-or-kinds) 1))
  -	 (setf kind-or-kinds (first kind-or-kinds))
  -	 (warn "Multiple docstrings found for ~s; specify type (using ~a)" 
  -	       name kind-or-kinds))
  -       (unless kind-or-kinds
  +       ;;?? could memoize this (where is it stored? in add-docs-item?)
  +       (when (> (length kinds) 1)
  +	 (warn "Multiple interpretations found for ~s; specify type (using ~a)" 
  +	       name (car (first kinds))))
  +       (unless kinds
   	 (warn "No docstring found for ~s" name))
  -       (add-docs-item thing kind-or-kinds))
  +       (add-docs-item thing (car kind)))
         (:render
  -       (let ((docs (documentation thing kind)))
  -	 (format *output-stream* 
  -		 "~&<a name=\"~a-~a\" id=\"~a-~a\"></a>" name kind name kind)
  -	 (format *output-stream* 
  -		 "<div class=\"documentation ~(~a~)\">" kind)
  +       (let ((docs (and (cdr kind) (documentation thing (cdr kind))))
  +	     (identity (car kind)))
  +	 (format *output-stream* 
  +		 "~&<a name=\"~a-~a\" id=\"~a-~a\"></a>" 
  +		 name identity name identity)
  +	 (format *output-stream* 
  +		 "~&<a name=\"~a\" id=\"~a\"></a>" 
  +		 name name)
  +	 (format *output-stream* 
  +		 "<div class=\"documentation ~(~a~)\">" identity)
   	 (format *output-stream* 
   		 "<div class=\"documentation header\">")
   	 (format *output-stream* "<span class=\"hidden\">X</span>")
  
positive.code:           (t
             (format *output-stream* "~( ~a~)" argument)))))
  
  (defun symbol-identities (symbol)
    (loop for (predicate . kind) in 
         '((symbol-names-class-p . class)
  	 (symbol-names-condition-p . condition)
  	 (symbol-names-constant-p . constant)
  	 (symbol-names-function-p . function)
  	 (symbol-names-generic-function-p . generic-function)
  	 (symbol-names-macro-p . macro)
  	 (symbol-names-variable-p . variable)) 
         when (funcall predicate symbol) collect kind))
  
negative.code: 	   (format *output-stream*
  		   "</span>"))
  	 (format *output-stream* 
  		 "~&<span class=\"documentation-kind\">~a</span>" identity)
  	 (format *output-stream* "~&</div>")
  	 (format *output-stream* 
  		 "<div class=\"documentation contents\">")	   
  