anchor.diff:            (error "Glob pattern didn't match anything: ~A" (concatenate-fragments fragments)))
           (fset:seq fragments))))
   
  -(defun concatenate-fragments-for-words (word-fragment-sequences)
  +(defun concatenate-fragmented-words (word-fragment-sequences)
  +  "Given a sequence of fragment sequences, this function joins the
  +fragment sequences and returns a sequence of words."
     (mapped-iterator word-fragment-sequences 'concatenate-fragments))
   
   (defun concatenate-fragments (fragments)
  
positive.code: (defun run-expansion-pipeline (things pipeline)
    (let ((last-result things)
          (exit-infos (make-extensible-vector)))
      (loop :for fn :across pipeline :do
         (multiple-value-bind
               (this-result this-exit-infos)
             (funcall fn last-result)
           (setf last-result this-result)
           (vector-push-extend this-exit-infos exit-infos)))
      (values last-result (concatenate-iterable-collection exit-infos))))
  
  (defun compute-expansion-pipeline (&key start-at end-at
  
negative.code:                                      (expand-token-sequence t)
                                       (expand-tilde-words t)
                                       (expand-pathname-words t)
                                       (concatenate-fragmented-words t))
    "Produce a sequence representing an expansion sequence.
  
  You generally don't want to use this function.  You probably want to
  use `expansion-for-words'.  This function is useful if you need to
  exercise a great deal of control over what phases of expansion take
  place.  To run the pipeline, use `run-expansion-pipeline'."
    (let ((pipeline (make-extensible-vector))
          (started (unless start-at t)))
      (macrolet
  