Documentation

Called with a directory, list of relative subdirectories, and a list of file names. If using pathWalk, the callback always returns '()'. If using pathWalkInterruptible, it returns whether to continue, prevent recursing further, or stop traversal entirely.

pathWalk recursively enumerates the given root directory, calling callback once per directory with the traversed directory name, a list of subdirectories, and a list of files.

The subdirectories and file names are always relative to the root given.

pathWalk "src" $ \dir subdirs files -> do
  forM_ files $ \file -> do
    when ("Test.hs" `isSuffixOf` file) $ do
      registerTestFile $ dir </> file

The callback given to pathWalkInterruptible returns a WalkStatus which determines which subsequent directories are traversed.

Traverses a directory tree, just like pathWalk, except that the callback can determine whether to continue traversal. See WalkStatus.

Traverses a directory tree, just like pathWalk. The difference is that each callback returns a Monoid value, all of which are accumulated into the result. Note that this uses WriterT and thus frequently appends to the right of the monoid. Be careful to avoid accidental quadratic behavior by using a data structure that supports fast appends. For example, use Data.Sequence instead of a list.

The lazy version of pathWalk. Instead of running a callback per directory, it returns a lazy list that reads from the filesystem as the list is evaluated.

pathWalkLazy does not allow selective recursion. For richer functionality, see the directory-tree package at https://hackage.haskell.org/package/directory-tree