anchor.diff:    (format stream "}~%"))
   
   (defun shcl-package-p (package)
  +  "Returns non-nil iff the provided package belongs to SHCL."
     (let ((shcl-prefix "SHCL/"))
       (when (> (length (package-name package)) (length shcl-prefix))
         (string= (package-name package) shcl-prefix :end1 (length shcl-prefix)))))
   
   (defun symbol-documentation-types ()
  +  "Return an array of types of documentation a symbol can have.
  +
  +Strictly speaking, there may be more forms of documentation than this.
  +However, this is a good enough approximation for our purposes: finding
  +undocumented symbols."
     (let* ((methods (list-iterator (closer-mop:generic-function-methods #'documentation)))
            (specializers (map-iterator methods 'closer-mop:method-specializers))
            (symbol-methods (filter-iterator specializers (lambda (x) (eq (find-class 'symbol) (first x)))))
  
positive.code:          (values (map-iterator eql-specializers 'closer-mop:eql-specializer-object)))
      (iterator-values values)))
  
  (defparameter *symbol-documentation-types* (symbol-documentation-types))
  
  (defun documented-p (symbol)
    (loop :for documentation-type :across *symbol-documentation-types* :do
       (progn
         (when (documentation symbol documentation-type)
  
negative.code:   nil)
  
  (defun undocumented-symbols ()
    "Returns an array of all shcl symbols that are undocumented."
    (let* ((all-packages (list-iterator (list-all-packages)))
           (shcl-packages (filter-iterator all-packages 'shcl-package-p))
           (syms (make-extensible-vector)))
  