-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Expressive file and directory manipulation for Haskell.
--   
--   A Haskell library for working with files and directories. Includes
--   code for pattern matching, finding files, modifying file contents, and
--   more.
@package filemanip
@version 0.3.6.3

module System.FilePath.GlobPattern

-- | Glob pattern type.
type GlobPattern = String

-- | Match a file name against a glob pattern.
(~~) :: FilePath -> GlobPattern -> Bool

-- | Match a file name against a glob pattern, but return True if
--   the match fails.
(/~) :: FilePath -> GlobPattern -> Bool
instance GHC.Internal.Show.Show System.FilePath.GlobPattern.MatchTerm
instance (GHC.Internal.Ix.Ix a, GHC.Internal.Show.Show a) => GHC.Internal.Show.Show (System.FilePath.GlobPattern.SRange a)

module System.FilePath.Glob

-- | Return a list of names matching a glob pattern. The list is generated
--   lazily.
namesMatching :: String -> IO [FilePath]

-- | This module provides functions for traversing a filesystem hierarchy.
--   The find function generates a lazy list of matching files,
--   while fold performs a left fold.
--   
--   Both find and fold allow fine control over recursion,
--   using the FindClause type. This type is also used to pre-filter
--   the results returned by find.
--   
--   The FindClause type lets you write filtering and recursion
--   control expressions clearly and easily.
--   
--   For example, this clause matches C source files.
--   
--   
--   extension ==? ".c" ||? extension ==? ".h"
--   
--   
--   Because FindClause is a monad, you can use the usual monad
--   machinery to, for example, lift pure functions into it.
--   
--   Here's a clause that will return True for any file whose
--   directory name contains the word "temp".
--   
--   
--   (isInfixOf "temp") `liftM` directory
--   
module System.FilePath.Find

-- | Information collected during the traversal of a directory.
data FileInfo
FileInfo :: FilePath -> Int -> FileStatus -> FileInfo

-- | file path
[infoPath] :: FileInfo -> FilePath

-- | current recursion depth
[infoDepth] :: FileInfo -> Int

-- | status of file
[infoStatus] :: FileInfo -> FileStatus
data FileType
BlockDevice :: FileType
CharacterDevice :: FileType
NamedPipe :: FileType
RegularFile :: FileType
Directory :: FileType
SymbolicLink :: FileType
Socket :: FileType
Unknown :: FileType

-- | Monadic container for file information, allowing for clean
--   construction of combinators. Wraps the State monad, but doesn't
--   allow get or put.
data FindClause a
type FilterPredicate = FindClause Bool
type RecursionPredicate = FindClause Bool

-- | 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.
find :: RecursionPredicate -> FilterPredicate -> FilePath -> IO [FilePath]

-- | 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.
fold :: RecursionPredicate -> (a -> FileInfo -> a) -> a -> FilePath -> IO a

-- | 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.
findWithHandler :: (FilePath -> IOException -> IO [FilePath]) -> RecursionPredicate -> FilterPredicate -> FilePath -> IO [FilePath]

-- | 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.
foldWithHandler :: (FilePath -> a -> IOException -> IO a) -> RecursionPredicate -> (a -> FileInfo -> a) -> a -> FilePath -> IO a

-- | 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
--   
evalClause :: FindClause a -> FileInfo -> a

-- | Return the type of a file. This is much more useful for case analysis
--   than the usual functions on FileStatus values.
statusType :: FileStatus -> FileType

-- | 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.
liftOp :: Monad m => (a -> b -> c) -> m a -> b -> m c

-- | Return the name of the file being visited.
filePath :: FindClause FilePath

-- | Return the FileStatus for the current file.
fileStatus :: FindClause FileStatus

-- | Return the current recursion depth.
depth :: FindClause Int

-- | Return the current FileInfo.
fileInfo :: FindClause FileInfo

-- | Unconditionally return True.
always :: FindClause Bool

-- | Return the file name extension.
--   
--   Example:
--   
--   
--   extension "foo/bar.txt" => ".txt"
--   
extension :: FindClause FilePath

-- | 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"
--   
directory :: FindClause FilePath

-- | Return the file name, without the directory name.
--   
--   What this means in practice:
--   
--   
--   fileName "foo/bar.txt" => "bar.txt"
--   
--   
--   Example:
--   
--   
--   fileName ==? "init.c"
--   
fileName :: FindClause FilePath

-- | Return the type of file currently being visited.
--   
--   Example:
--   
--   
--   fileType ==? RegularFile
--   
fileType :: FindClause FileType

-- | 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.
contains :: FilePath -> FindClause Bool
deviceID :: FindClause DeviceID
fileID :: FindClause FileID
fileOwner :: FindClause UserID
fileGroup :: FindClause GroupID
fileSize :: FindClause FileOffset
linkCount :: FindClause LinkCount
specialDeviceID :: FindClause DeviceID
fileMode :: FindClause FileMode
accessTime :: FindClause EpochTime
modificationTime :: FindClause EpochTime
statusChangeTime :: FindClause EpochTime

-- | Return the permission bits of the FileMode.
filePerms :: FindClause FileMode

-- | Return True if any of the given permission bits is set.
--   
--   Example:
--   
--   
--   anyPerms 0444
--   
anyPerms :: FileMode -> FindClause Bool

-- | Return the canonical path of the file being visited.
--   
--   See canonicalizePath for details of what canonical path means.
canonicalPath :: FindClause FilePath

-- | Return the canonical name of the file (canonical path with the
--   directory part removed).
canonicalName :: FindClause FilePath

-- | If the current file is a symbolic link, return Just the target
--   of the link, otherwise Nothing.
readLink :: FindClause (Maybe FilePath)

-- | 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
--   
followStatus :: FindClause (Maybe FileStatus)

-- | Return True if the current file's name matches the given
--   GlobPattern.
(~~?) :: FindClause FilePath -> GlobPattern -> FindClause Bool
infix 4 ~~?

-- | Return True if the current file's name does not match the given
--   GlobPattern.
(/~?) :: FindClause FilePath -> GlobPattern -> FindClause Bool
infix 4 /~?
(==?) :: Eq a => FindClause a -> a -> FindClause Bool
infix 4 ==?
(/=?) :: Eq a => FindClause a -> a -> FindClause Bool
infix 4 /=?
(>?) :: Ord a => FindClause a -> a -> FindClause Bool
infix 4 >?
(<?) :: Ord a => FindClause a -> a -> FindClause Bool
infix 4 <?
(>=?) :: Ord a => FindClause a -> a -> FindClause Bool
infix 4 >=?
(<=?) :: Ord a => FindClause a -> a -> FindClause Bool
infix 4 <=?

-- | This operator is useful to check if bits are set in a FileMode.
(.&.?) :: Bits a => FindClause a -> a -> FindClause a
infixl 7 .&.?
(&&?) :: FindClause Bool -> FindClause Bool -> FindClause Bool
infixr 3 &&?
(||?) :: FindClause Bool -> FindClause Bool -> FindClause Bool
infixr 2 ||?
instance GHC.Internal.Base.Applicative System.FilePath.Find.FindClause
instance GHC.Classes.Eq System.FilePath.Find.FileInfo
instance GHC.Classes.Eq System.Posix.Files.Common.FileStatus
instance GHC.Classes.Eq System.FilePath.Find.FileType
instance GHC.Internal.Base.Functor System.FilePath.Find.FindClause
instance GHC.Internal.Base.Monad System.FilePath.Find.FindClause
instance GHC.Classes.Ord System.FilePath.Find.FileType
instance GHC.Internal.Show.Show System.FilePath.Find.FileType

module System.FilePath.Manip

-- | Type class for string manipulation over files.
class Streamable a

-- | Read the entire contents of a Handle.
readAll :: Streamable a => Handle -> IO a

-- | Write an entire string to a Handle.
writeAll :: Streamable a => Handle -> a -> IO ()

-- | Use a renaming function to generate a new name for a file, then rename
--   it.
renameWith :: (FilePath -> FilePath) -> FilePath -> IO ()

-- | Modify a file in place using the given function. The new content is
--   written to a temporary file. Once this is complete, the file
--   manipulation action is called. Its arguments are the names of the
--   original and temporary files.
--   
--   Example:
--   
--   
--   modifyInPlace = modifyWith (flip rename)
--   
modifyWith :: Streamable a => (FilePath -> FilePath -> IO ()) -> (a -> a) -> FilePath -> IO ()

-- | Modify a file in place using the given function. The original copy of
--   the file is saved under a new name. This is performed by writing to a
--   temporary file; renaming the original file to its new name; then
--   renaming the temporary file to the original name.
--   
--   Example:
--   
--   
--   -- save original file with a ".bak" extension
--   modifyWithBackup (<.> "bak")
--   
modifyWithBackup :: Streamable a => (FilePath -> FilePath) -> (a -> a) -> FilePath -> IO ()

-- | Modify a file in place using the given function. This is performed by
--   writing to a temporary file, then renaming it on top of the existing
--   file when done.
modifyInPlace :: Streamable a => (a -> a) -> FilePath -> IO ()
instance System.FilePath.Manip.Streamable Data.ByteString.Lazy.Internal.ByteString
instance System.FilePath.Manip.Streamable Data.ByteString.Internal.Type.ByteString
instance System.FilePath.Manip.Streamable GHC.Internal.Base.String
