anchor.diff:        ;; dispatch?
         (cond ((consp argument)
   	     (case kind
  -	       (macro
  +	       (:macro
   		(format *output-stream* "(")
   		(display-arguments argument :kind kind)
   		(format *output-stream* ")"))
  
positive.code: 	 (call-next-method))))
  
  (defparameter *symbol-identities*
    '((symbol-names-class-p class type)
      (symbol-names-condition-p condition nil)
      (symbol-names-constant-p constant variable)
      (symbol-names-function-p function nil)
      ;; FIXME - for now, we don't separate 'em
      (symbol-names-generic-function-p function function)
      (symbol-names-macro-p macro function)
      (symbol-names-variable-p variable nil)
      (symbol-names-slot-accessor-p function function)))
  
  (defun add-documentation-strategy (test thing strategy)
    (pushnew (list test thing strategy) *symbol-identities* 
  
negative.code:   (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-documentation-holder expected-kind))
  		   (symbol-identities symbol))) 
  	      for mappings = (kind-mappings kind)
  	      for docs = nil
  	    when
  	      (or (and (atom mappings)
  		       (find-documentation symbol (form-keyword mappings))
  		       (setf docs mappings))
  		  (and (consp mappings)
  		       (some (lambda (doc-kind)
  			       (and (find-documentation
  				     symbol (form-keyword doc-kind))
  				    (setf docs doc-kind)))
  			     mappings))) collect
  	    (cons kind docs))))
  