anchor.diff:    (case (form-keyword kind)
       ((:macro :generic-function) '(function))
       (:class '(type))
  +    (:condition '(type))
  +    (:structure '(structure))
       (:constant '(variable))
  +    (:type '(type))
       (t kind)))
   
   ;; FIXME - fully reconcile list of docstring with list of identities
   (defun symbol-identities-with-docstring (symbol &optional expected-kind)
     (let ((kinds 
  -	 (loop for kind in (ensure-list
  -			    (or (and expected-kind
  -				     (ensure-symbol expected-kind))
  -				(symbol-identities symbol))) 
  +	 (loop for kind in 
  +	      (ensure-list
  +	       (or (and expected-kind
  +			(ensure-documentation-holder expected-kind))
  +		   (symbol-identities symbol))) 
   	      for mappings = (kind-mappings kind)
   	      for docs = nil
   	    when
   	      (or (and (atom mappings)
  -		       (find-documentation symbol mappings)
  +		       (find-documentation symbol (form-keyword mappings))
   		       (setf docs mappings))
   		  (and (consp mappings)
   		       (some (lambda (doc-kind)
  -			       (and (find-documentation symbol doc-kind)
  +			       (and (find-documentation
  +				     symbol (form-keyword doc-kind))
   				    (setf docs doc-kind)))
   			     mappings))) collect
   	    (cons kind docs))))
  
positive.code:   (:documentation "Return the documentation for thing using strategy. The default is to call the Common Lisp documentation method with strategy being used as the type."))
  
  (defmethod find-documentation (thing strategy)
    (documentation thing strategy))
  
  (defmethod find-documentation (thing (strategy (eql 'function)))
    (cond ((and (fboundp thing)
  	      (typep (symbol-function thing) 'standard-generic-function))
  	 (let ((docstring (call-next-method))
  
negative.code:       ;; dispatch?
        (cond ((consp argument)
  	     (case kind
  	       (:macro
  		(format *output-stream* "(")
  		(display-arguments argument :kind kind)
  		(format *output-stream* ")"))
  