anchor.diff:    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)))
  
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:   (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)))))
  