anchor.diff:                         (let ((rest (recurse-and-prefix file t)))
                            (when rest
                              (fset:appendf matches rest))))
  -                     (setf matches (fset:with-last matches (fset:convert 'fset:seq file)))))))
  -           (if (zerop (fset:size matches))
  -               nil
  -               matches)))))))
  +                     (fset:push-last matches (fset:convert 'fset:seq file))))))
  +           (unless (zerop (fset:size matches))
  +             matches)))))))
   
   (defun expand-wild-path (wild-path)
     "Given a `wild-path', produce an `fset:seq' of strings representing
  
positive.code:                    (slash (if slash-p (fset:seq #\/) (fset:empty-seq))))
                 (fset:image (lambda (seq) (fset:concat s slash seq)) rest)))))
        (declare (dynamic-extent #'recurse #'recurse-and-prefix))
        (cond
          ((and (zerop index)
                (stringp next)
                (not (find-if-not (lambda (c) (equal #\/ c)) next)))
  
negative.code:          (with-directory-or-nil (next)
             (recurse-and-prefix next nil)))
  
          ;; Handle empty directory components (i.e. adjacent,
          ;; non-leading slash characters).
          ((equal next "")
           (assert as-directory-p)
           (recurse-and-prefix "/" nil))
  
          ;; Handle specifically named directories
          ((and (stringp next) as-directory-p)
           (with-directory-or-nil (next)
             (recurse-and-prefix next t)))
  
          ;; Handle specifically named files
          ((stringp next)
           (assert (not as-directory-p))
           (handler-case
               (shcl/core/fd-table:receive-ref-counted-fd
                   (fd (retained-fd-openat (get-fd-current-working-directory) next 0))
                 (declare (ignore fd))
                 (fset:seq (fset:convert 'fset:seq next)))
             (syscall-error ())))
  
          ;; Oooh.  Exciting.  A scanner.  Iterate the contents of the
          ;; current directory and look for things that match the given
          ;; name.
          ((not (stringp next))
           (let ((matches (fset:empty-seq)))
             (with-dir-ptr-for-fd (dir-ptr (get-fd-current-working-directory))
  