anchor.diff:  
   (defgeneric markdown-entry (symbol type arguments docstring &optional types other))
   
  +(defun md-entry-key (symbol type)
  +  (with-output-to-string (out)
  +    (let ((str (rope-string (rope *md-key* "_" *md-package* "_" type "_" symbol))))
  +      (loop for c across str
  +         do
  +           (case c
  +             (#\* (write-string "_STAR_" out))
  +             (#\+ (write-string "_PLUS_" out))
  +             (#\> (write-string "_GT_" out))
  +             (#\< (write-string "_LT_" out))
  +             (#\/ (write-string "_DIV_" out))
  +             (#\( (write-string "_LP_" out))
  +             (#\) (write-string "_RP_" out))
  +             (#\Space (write-string "_SP_" out))
  +             (#\_ (write-string "__" out))
  +             (otherwise (write-char c out)))))))
  +
  +
   (defun md-entry-header (symbol type)
  -  (md-header 2 symbol (rope *md-key* "_" *md-package* "_" type "_" symbol))
  -  (md-format "~&<i>[~A]</i>~%~%" (string-downcase type)))
  -
  -
  -
  +  (let ((symbol (format nil "~A" symbol)))
  +    (md-header 2 symbol (md-entry-key symbol type))
  +    (md-format "~&<i>[~A]</i>~%~%" (string-downcase type))))
  +
  +
  +(defun check-docstring (symbol type docstring)
  +  (unless docstring
  +    (format *error-output* "~&~A ~A is not documented.~%"
  +            type symbol)))
  +
  +(defun index-markdown-entry (symbol type arguments docstring &optional types other)
  +  (declare (ignore arguments types other))
  +  (setf (md-docstring-hash symbol type) docstring))
   
   (defmethod markdown-entry (symbol (type (eql :constant)) arguments docstring &optional types other)
  +  (check-docstring symbol type docstring)
     (md-entry-header symbol type)
     (md-docstring docstring))
   
   (defmethod markdown-entry (symbol (type (eql :special-var)) arguments docstring &optional types other)
  +  (check-docstring symbol type docstring)
     (md-entry-header symbol type)
     (md-docstring docstring))
   
   (defmethod markdown-entry (symbol (type (eql :macro)) arguments docstring &optional types other)
  +  (check-docstring symbol type docstring)
     (md-entry-header symbol type)
     (md-docstring docstring))
   
   (defmethod markdown-entry (symbol (type (eql :function)) arguments docstring &optional types other)
  +  (check-docstring symbol type docstring)
     (md-entry-header symbol type)
     (md-format "    ~A: " symbol)
     (md-lambda-list arguments)
     (md-docstring docstring))
   
   (defmethod markdown-entry (symbol (type (eql :generic-function)) arguments docstring &optional types other)
  +  (check-docstring symbol type docstring)
     (md-entry-header symbol type)
     (md-format "    ~A: " symbol)
     (md-lambda-list arguments)
  
positive.code: (defvar *md-key*)
  (defvar *md-package*)
  
  
  
  (defun md-format (control-string &rest args)
    (apply #'format *output* control-string args))
  
negative.code:                    ((or string symbol)
                      (asdf:find-system system))))
           (key (or key (car packages)))
           (*md-docstring-hash* (make-hash-table :test #'equal))
           (*md-key* key))
      (labels ((helper ()
                 (md-header 1 title key)
                 (when toc
                   (md-format "~&[TOC]~%~%"))
                 (map nil #'output-package packages))
               (map-entries (function entries)
                 (map nil (lambda (entry) (apply function entry)) entries))
               (output-package (package)
                 (let ((entries (collect-all-doc-entries package))
                       (*md-package* package))
                   (md-header 1 (rope "The " package " dictionary")
                              (rope key "_" package))
  
                   (map-entries #'index-markdown-entry entries)
                   (map-entries #'markdown-entry entries))))
        (etypecase target
          (null
           (with-output-to-string (*output*)
  