Information collected during the traversal of a directory.

Monadic container for file information, allowing for clean construction of combinators. Wraps the State monad, but doesn't allow get or put.

Search a directory recursively, with recursion controlled by a RecursionPredicate. Lazily return a sorted list of all files matching the given FilterPredicate. Any errors that occur are ignored, with warnings printed to stderr.

Search a directory recursively, with recursion controlled by a RecursionPredicate. Fold over all files found. Any errors that occur are ignored, with warnings printed to stderr. The fold function is run from "left" to "right", so it should be strict in its left argument to avoid space leaks. If you need a right-to-left fold, use foldr on the result of findWithHandler instead.

Search a directory recursively, with recursion controlled by a RecursionPredicate. Lazily return a sorted list of all files matching the given FilterPredicate. Any errors that occur are dealt with by the given handler.

Search a directory recursively, with recursion controlled by a RecursionPredicate. Fold over all files found. Any errors that occur are dealt with by the given handler. The fold is strict, and run from "left" to "right", so the folded function should be strict in its left argument to avoid space leaks. If you need a right-to-left fold, use foldr on the result of findWithHandler instead.

Run the given FindClause on the given FileInfo and return its result. This can be useful if you are writing a function to pass to fold.

Example:

myFoldFunc :: a -> FileInfo -> a
myFoldFunc a i = let useThisFile = evalClause (fileName ==? "foo") i
                 in if useThisFile
                    then fiddleWith a
                    else a

Return the type of a file. This is much more useful for case analysis than the usual functions on FileStatus values.

Lift a binary operator into the FindClause monad, so that it becomes a combinator. The left hand side of the combinator should be a FindClause a, while the right remains a normal value of type a.

Return the name of the file being visited.

Return the FileStatus for the current file.

Return the current recursion depth.

Return the current FileInfo.

Unconditionally return True.

Return the file name extension.

Example:

extension "foo/bar.txt" => ".txt"

Return the directory name, without the file name.

What this means in practice:

directory "foo/bar.txt" => "foo"

Example in a clause:

let hasSuffix = liftOp isSuffixOf
in directory `hasSuffix` "tests"

Return the file name, without the directory name.

What this means in practice:

fileName "foo/bar.txt" => "bar.txt"

Example:

fileName ==? "init.c"

Return the type of file currently being visited.

Example:

fileType ==? RegularFile

Return True if the given path exists, relative to the current file. For example, if "foo" is being visited, and you call contains "bar", this combinator will return True if "foo/bar" exists.

Return the permission bits of the FileMode.

Return True if any of the given permission bits is set.

Example:

anyPerms 0444

Return the canonical path of the file being visited.

See canonicalizePath for details of what canonical path means.

Return the canonical name of the file (canonical path with the directory part removed).

If the current file is a symbolic link, return Just the target of the link, otherwise Nothing.

If the current file is a symbolic link, return Just the status of the ultimate endpoint of the link. Otherwise (including in the case of an error), return Nothing.

Example:

statusType `liftM` followStatus ==? RegularFile

Return True if the current file's name matches the given GlobPattern.

Return True if the current file's name does not match the given GlobPattern.

This operator is useful to check if bits are set in a FileMode.