anchor.diff:      (or (and file-name (not (stringp file-name)))
           (find-if-not 'stringp directories))))
   
  -(defun split-fragments-into-segments (fragments)
  +(defun split-fragments-into-directory-segments (fragments)
  +  "Given a sequence of fragments, produce a sequence of sequences of
  +fragments which contain no #\/ characters.
  +
  +The sequences of fragments are known as segments.  Each segment
  +represents a directory component.  The final segment always represents
  +the file name at the end of the path.  If the file name segment is
  +empty, then the fragments ended in a #\
  +
  +Ignoring the final segment, empty segments indicate the presence of
  +consecutive slashes.  Empty segments at the start of the sequence of
  +segments represent slashes at the start of the path.
  +
  +The string \"//\" would result in a sequence of three empty segments.
  +The first two represent the leading slashes and the last one
  +represents the empty file name."
     (let ((result (fset:empty-seq))
           (part (fset:empty-seq)))
       (loop :while (not (zerop (fset:size fragments))) :do
  
positive.code:        segments))))
  
  (defstruct fragment-stream
    (fragments (fset:empty-seq))
    (index 0))
  
  (defun fragment-stream-read (fragment-stream)
    (with-accessors
          ((fragments fragment-stream-fragments)
           (index fragment-stream-index))
  
negative.code:         (coerce result 'simple-string))))
  
  (defun make-wild-path-from-fragments (fragments)
    "Translate a `fset:seq' of fragments into a `wild-path'."
    (multiple-value-bind (absolute-part remaining-segments)
        (handle-leading-slashes (split-fragments-into-directory-segments fragments))
      (let ((path (make-wild-path)))
        (with-accessors
              ((directories wild-path-directories)
  