System.Directory.Tree

Provides a simple data structure mirroring a directory tree on the filesystem, as well as useful functions for reading and writing file and directory structures in the IO monad.

Errors are caught in a special constructor in the DirTree type.

Defined instances of Functor, Traversable and Foldable allow for easily operating on a directory of files. For example, you could use Foldable.foldr to create a hash of the entire contents of a directory.

The AnchoredDirTree type is a simple wrapper for DirTree to keep track of a base directory context for the DirTree.

Please send me any requests, bugs, or other feedback on this module!

Data types for representing directory trees

data DirTree a

the String in the name field is always a file name, never a full path. The free type variable is used in the File constructor and can hold Handles, Strings representing a file's contents or anything else you can think of. We catch any IO errors in the Failed constructor. an Exception can be converted to a String with show.

Constructors

Dir

Fields

name :: FileName

contents :: [DirTree a]

File

Fields

name :: FileName

file :: a

Failed

Fields

name :: FileName

err :: Exception

Instances

Functor DirTree

Foldable DirTree

Traversable DirTree

Eq a => Eq (DirTree a)

Ord a => Ord (DirTree a)

Show a => Show (DirTree a)

data AnchoredDirTree a

a simple wrapper to hold a base directory name, which can be either an absolute or relative path. This lets us give the DirTree a context, while still letting us store only directory and file NAMES (not full paths) in the DirTree. (uses an infix constructor; don't be scared)

Constructors

FilePath :/ (DirTree a)

Instances

Eq a => Eq (AnchoredDirTree a)

Ord a => Ord (AnchoredDirTree a)

Show a => Show (AnchoredDirTree a)

type FileName = String

an element in a FilePath:

High level IO functions

readDirectory :: FilePath -> IO (AnchoredDirTree String)

build an AnchoredDirTree, given the path to a directory, opening the files using readFile.

readDirectoryWith :: (FilePath -> IO a) -> FilePath -> IO (AnchoredDirTree a)

same as readDirectory but allows us to, for example, use ByteString.readFile to return a tree of ByteStrings.

writeDirectory :: AnchoredDirTree String -> IO ()

write a DirTree of strings to disk. clobbers files of the same name. doesn't affect files in the directories (if any already exist) with different names:

writeDirectoryWith :: (FilePath -> a -> IO ()) -> AnchoredDirTree a -> IO ()

writes the directory structure to disc, then uses the provided function to write the contents of Files to disc.

Lower level functions

zipPaths :: AnchoredDirTree a -> DirTree (FilePath, a)

tuple up the complete filename with the File contents, by building up the path, trie-style, from the root. The filepath will be relative to the current directory. This allows us to, for example, mapM_ 'uncurry writeFile' over a DirTree of strings.

build :: FilePath -> IO (AnchoredDirTree FilePath)

builds a DirTree from the contents of the directory passed to it, saving the base directory in the Anchored* wrapper. Errors are caught in the tree in the Failed constructor. The file fields initially are populated with full paths to the files they are abstracting.

openDirectory :: FilePath -> IOMode -> IO (AnchoredDirTree Handle)

a simple application of readDirectoryWith openFile:

writeJustDirs :: AnchoredDirTree a -> IO ()

writes the directory structure (not files) of a DirTree to the anchored directory. can be preparation for writing files:

Utility functions

Handling failure

successful :: DirTree a -> Bool

True if there are no Failed constructors in the tree

anyFailed :: DirTree a -> Bool

True if any Failed constructors in the tree

failures :: DirTree a -> [DirTree a]

returns a list of Failed constructors only:

failedMap :: (FileName -> Exception -> DirTree a) -> DirTree a -> DirTree a

maps a function to convert Failed DirTrees to Files or Dirs

Misc.

free :: AnchoredDirTree a -> DirTree a

strips away base directory wrapper: