anchor.diff:          (w-dir (pathname-directory w)))
       (labels ((match (p w)
                  (cond
  +                 ((eql (first w) :wild-inferiors)
  +                  ;; Eat elements until a match is found or the end of the
  +                  ;; directory is reached.
  +                  (loop
  +                     (when (match p (rest w))
  +                       (return t))
  +                     (when (null p)
  +                       (return nil))
  +                     (pop p)))
                    ((and (null p) (null w)) t)
                    ((or (null p) (null w)) nil)
                    ((eql (first w) :wild)
                     (match (rest p) (rest w)))
  -                 ((eql (first w) :wild-inferiors)
  -                  (error "TODO: wild-inferiors"))
                    (t (and (string= (first p) (first w))
                            (match (rest p) (rest w)))))))
         (and (eql (first p-dir) (first w-dir))
  
positive.code: (defgeneric directory-using-host (host path &key))
  
  (defun directory (pathspec &rest args &key &allow-other-keys)
    (let ((path (merge-pathnames pathspec)))
      (apply #'directory-using-host (pathname-host path) path args)))
  
  (defun translate-logical-pathname (pathname &key)
    (pathname pathname))
  
  (defun translate-one (source from to what)
    (cond ((member (funcall what to) '(nil :wild))
           (funcall what source))
          ((or (eql (funcall what source) (funcall what from))
               (eql (funcall what from) :wild))
           (funcall what source))
          (t (error "Source and from ~S don't match." what))))
  
  (defun translate-directory (source from-wildcard to-wildcard)
  
negative.code:   (check-type direction (member :input :output :io :probe))
    (check-type if-exists (member :error :new-version :rename :rename-and-delete :overwrite :append :supersede nil))
    (check-type if-does-not-exist (member :error :create nil))
    (let* ((path (translate-logical-pathname (merge-pathnames filespec)))
           (host (pathname-host path)))
      (when (wild-pathname-p path)
        (error 'simple-file-error
  