anchor.diff:          (boundary +soft-word-boundary+)
           (values result (ensure-exit-info-seq exit-info))))))
   
  -(defun run-expansion-pipeline (things pipeline)
  -  (let ((last-result things)
  +(defvar *split-fields-default* t)
  +(defvar *allow-side-effects-default* t)
  +
  +(defun run-expansion-pipeline (things pipeline
  +                               &key (split-fields *split-fields-default*)
  +                                 (allow-side-effects *allow-side-effects-default*))
  +  "Feed `things' into the given expansion pipeline.
  +
  +Each phase of the pipeline is expected to produce two return values: a
  +result (to be fed to the next pipeline phase) and a sequence of
  +`exit-info' objects.  The return value is the first return value of
  +the final pipeline phase and the result of concatenating all the
  +`exit-info' sequences."
  +  (let ((*split-fields* split-fields)
  +        (*allow-side-effects* allow-side-effects)
  +        (last-result things)
           (exit-infos (fset:empty-seq))
           (pipeline (walk pipeline)))
       (do-while-popf (fn pipeline)
  
positive.code:   "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)
               (file-name wild-path-file-name))
  
negative.code:            (unless (zerop (fset:size matches))
               matches)))))))
  
  (defvar *error-on-failed-glob* nil
    "If this variable is non-nil, then an error will be signaled when
  pathname expansion cannot find any matches for a glob pattern.
  
  POSIX says that if a glob doesn't match any files then pathname
  expansion should simply produce the string the user typed.  So, if the
  user runs
      rm [fb]oo
  in a directory where neither foo nor boo exist, then rm will receive
  the string '[fb]oo' as its argument.  That's a bit whacky.  If this
  variable is non-nil, then a glob failure aborts the command.")
  
  (defun expand-wild-path (wild-path)
    "Given a `wild-path', produce an `fset:seq' of strings representing
  the paths that were matched.
  
  Returns nil if no matches were found."
    (unless (wild-path-has-wild-component-p wild-path)
      (return-from expand-wild-path (fset:seq (wild-path-original-fragments wild-path))))
  
    (let ((matches
            (with-local-working-directory (".")
              (%expand-wild-path (wild-path-directories wild-path) 0 (wild-path-file-name wild-path)))))
      (cond
        (matches
         (labels
             ((prepare-match (match)
                (fset:seq (make-string-fragment (fset:convert 'string match) :quoted-p t))))
           (declare (dynamic-extent #'prepare-match))
           (fset:image #'prepare-match matches)))
        (*error-on-failed-glob*
         (error "Glob pattern didn't match anything: ~A" (wild-path-original-fragments wild-path)))
        (t
         (wild-path-original-fragments wild-path)))))
  
  (defun expand-tilde-words (fragment-seqs)
    "Perform tilde expansion on the given sequence of fragment
  