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


-- | Alternative to 'directory' package with ByteString based filepaths
--   
--   This provides a safer alternative to the <a>directory</a> package.
--   FilePaths are ByteString based, so this package only works on POSIX
--   systems. For a more high-level version of this with proper Path type,
--   use 'hpath-io', which makes use of this package.
@package hpath-directory
@version 0.14.2


-- | Provides error handling.
module System.Posix.RawFilePath.Directory.Errors

-- | Additional generic IO exceptions that the posix functions do not
--   provide.
data HPathIOException
SameFile :: ByteString -> ByteString -> HPathIOException
DestinationInSource :: ByteString -> ByteString -> HPathIOException
RecursiveFailure :: [(RecursiveFailureHint, IOException)] -> HPathIOException

-- | A type for giving failure hints on recursive failure, which allows to
--   programmatically make choices without examining the weakly typed I/O
--   error attributes (like <tt>ioeGetFileName</tt>).
--   
--   The first argument to the data constructor is always the source and
--   the second the destination.
data RecursiveFailureHint
ReadContentsFailed :: ByteString -> ByteString -> RecursiveFailureHint
CreateDirFailed :: ByteString -> ByteString -> RecursiveFailureHint
CopyFileFailed :: ByteString -> ByteString -> RecursiveFailureHint
RecreateSymlinkFailed :: ByteString -> ByteString -> RecursiveFailureHint
isSameFile :: HPathIOException -> Bool
isDestinationInSource :: HPathIOException -> Bool
isRecursiveFailure :: HPathIOException -> Bool
isReadContentsFailed :: RecursiveFailureHint -> Bool
isCreateDirFailed :: RecursiveFailureHint -> Bool
isCopyFileFailed :: RecursiveFailureHint -> Bool
isRecreateSymlinkFailed :: RecursiveFailureHint -> Bool

-- | Throws <tt>AlreadyExists</tt> <a>IOError</a> if file exists.
throwFileDoesExist :: RawFilePath -> IO ()

-- | Throws <tt>AlreadyExists</tt> <a>IOError</a> if directory exists.
throwDirDoesExist :: RawFilePath -> IO ()

-- | Uses <a>isSameFile</a> and throws <a>SameFile</a> if it returns True.
throwSameFile :: RawFilePath -> RawFilePath -> IO ()

-- | Check if the files are the same by examining device and file id. This
--   follows symbolic links.
sameFile :: RawFilePath -> RawFilePath -> IO Bool

-- | Checks whether the destination directory is contained within the
--   source directory by comparing the device+file ID of the source
--   directory with all device+file IDs of the parent directories of the
--   destination.
throwDestinationInSource :: RawFilePath -> RawFilePath -> IO ()

-- | Carries out an action, then checks if there is an IOException and a
--   specific errno. If so, then it carries out another action, otherwise
--   it rethrows the error.
catchErrno :: [Errno] -> IO a -> IO a -> IO a

-- | Execute the given action and retrow IO exceptions as a new Exception
--   that have the given errno. If errno does not match the exception is
--   rethrown as is.
rethrowErrnoAs :: Exception e => [Errno] -> e -> IO a -> IO a

-- | Like <a>catchIOError</a>, with arguments swapped.
handleIOError :: (IOError -> IO a) -> IO a -> IO a
hideError :: IOErrorType -> IO () -> IO ()

-- | Like <a>bracket</a>, but allows to have different clean-up actions
--   depending on whether the in-between computation has raised an
--   exception or not.
bracketeer :: IO a -> (a -> IO b) -> (a -> IO b) -> (a -> IO c) -> IO c
reactOnError :: IO a -> [(IOErrorType, IO a)] -> [(HPathIOException, IO a)] -> IO a
instance GHC.Show.Show System.Posix.RawFilePath.Directory.Errors.RecursiveFailureHint
instance GHC.Classes.Eq System.Posix.RawFilePath.Directory.Errors.RecursiveFailureHint
instance GHC.Show.Show System.Posix.RawFilePath.Directory.Errors.HPathIOException
instance GHC.Classes.Eq System.Posix.RawFilePath.Directory.Errors.HPathIOException
instance GHC.Exception.Type.Exception System.Posix.RawFilePath.Directory.Errors.HPathIOException


-- | This module provides IO related file operations like copy, delete,
--   move and so on, similar to the <tt>directory</tt> package.
--   
--   Some of these operations are due to their nature <b>not atomic</b>,
--   which means they may do multiple syscalls which form one context. Some
--   of them also have to examine the filetypes explicitly before the
--   syscalls, so a reasonable decision can be made. That means the result
--   is undefined if another process changes that context while the
--   non-atomic operation is still happening. However, where possible, as
--   few syscalls as possible are used and the underlying exception
--   handling is kept.
--   
--   Note: <a>BlockDevice</a>, <a>CharacterDevice</a>, <a>NamedPipe</a> and
--   <a>Socket</a> are ignored by some of the more high-level functions
--   (like <a>easyCopy</a>). For other functions (like <a>copyFile</a>),
--   the behavior on these file types is unreliable/unsafe. Check the
--   documentation of those functions for details.
--   
--   Import as: &gt; import System.Posix.RawFilePath.Directory
module System.Posix.RawFilePath.Directory
data FileType
Directory :: FileType
RegularFile :: FileType
SymbolicLink :: FileType
BlockDevice :: FileType
CharacterDevice :: FileType
NamedPipe :: FileType
Socket :: FileType

-- | The error mode for recursive operations.
--   
--   On <a>FailEarly</a> the whole operation fails immediately if any of
--   the recursive sub-operations fail, which is sort of the default for IO
--   operations.
--   
--   On <a>CollectFailures</a> skips errors in the recursion and keeps on
--   recursing. However all errors are collected in the
--   <a>RecursiveFailure</a> error type, which is raised finally if there
--   was any error. Also note that <a>RecursiveFailure</a> does not give
--   any guarantees on the ordering of the collected exceptions.
data RecursiveErrorMode
FailEarly :: RecursiveErrorMode
CollectFailures :: RecursiveErrorMode

-- | The mode for copy and file moves. Overwrite mode is usually not very
--   well defined, but is a convenience shortcut.
data CopyMode

-- | fail if any target exists
Strict :: CopyMode

-- | overwrite targets
Overwrite :: CopyMode

-- | Copies the contents of a directory recursively to the given
--   destination, while preserving permissions. Does not follow symbolic
--   links. This behaves more or less like the following, without
--   descending into the destination if it already exists:
--   
--   <pre>
--   cp -a /source/dir /destination/somedir
--   </pre>
--   
--   For directory contents, this will ignore any file type that is not
--   <a>RegularFile</a>, <a>SymbolicLink</a> or <a>Directory</a>.
--   
--   For <a>Overwrite</a> copy mode this does not prune destination
--   directory contents, so the destination might contain more files than
--   the source after the operation has completed. Permissions of existing
--   directories are fixed.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li>not atomic</li>
--   <li>examines filetypes explicitly</li>
--   <li>an explicit check <a>throwDestinationInSource</a> is carried out
--   for the top directory for basic sanity, because otherwise we might end
--   up with an infinite copy loop... however, this operation is not
--   carried out recursively (because it's slow)</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if source directory does not exist</li>
--   <li><a>PermissionDenied</a> if source directory can't be opened</li>
--   <li><a>SameFile</a> if source and destination are the same file
--   (<a>HPathIOException</a>)</li>
--   <li><a>DestinationInSource</a> if destination is contained in source
--   (<a>HPathIOException</a>)</li>
--   </ul>
--   
--   Throws in <a>FailEarly</a> RecursiveErrorMode only:
--   
--   <ul>
--   <li><a>PermissionDenied</a> if output directory is not writable</li>
--   <li><a>InvalidArgument</a> if source directory is wrong type
--   (symlink)</li>
--   <li><a>InappropriateType</a> if source directory is wrong type
--   (regular file)</li>
--   </ul>
--   
--   Throws in <a>CollectFailures</a> RecursiveErrorMode only:
--   
--   <ul>
--   <li><a>RecursiveFailure</a> if any of the recursive operations that
--   are not part of the top-directory sanity-checks fail
--   (<a>HPathIOException</a>)</li>
--   </ul>
--   
--   Throws in <a>Strict</a> CopyMode only:
--   
--   <ul>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   </ul>
copyDirRecursive :: RawFilePath -> RawFilePath -> CopyMode -> RecursiveErrorMode -> IO ()

-- | Recreate a symlink.
--   
--   In <a>Overwrite</a> copy mode only files and empty directories are
--   deleted.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li><a>Overwrite</a> mode is inherently non-atomic</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>InvalidArgument</a> if source file is wrong type (not a
--   symlink)</li>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>PermissionDenied</a> if source directory cannot be opened</li>
--   <li><a>SameFile</a> if source and destination are the same file
--   (<a>HPathIOException</a>)</li>
--   </ul>
--   
--   Throws in <a>Strict</a> mode only:
--   
--   <ul>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   </ul>
--   
--   Throws in <a>Overwrite</a> mode only:
--   
--   <ul>
--   <li><a>UnsatisfiedConstraints</a> if destination file is non-empty
--   directory</li>
--   </ul>
--   
--   Notes:
--   
--   <ul>
--   <li>calls <tt>symlink</tt></li>
--   </ul>
recreateSymlink :: RawFilePath -> RawFilePath -> CopyMode -> IO ()

-- | Copies the given regular file to the given destination. Neither
--   follows symbolic links, nor accepts them. For "copying" symbolic
--   links, use <a>recreateSymlink</a> instead.
--   
--   Note that this is still sort of a low-level function and doesn't
--   examine file types. For a more high-level version, use <a>easyCopy</a>
--   instead.
--   
--   In <a>Overwrite</a> copy mode only overwrites actual files, not
--   directories. In <a>Strict</a> mode the destination file must not
--   exist.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li><a>Overwrite</a> mode is not atomic</li>
--   <li>when used on <a>CharacterDevice</a>, reads the "contents" and
--   copies them to a regular file, which might take indefinitely</li>
--   <li>when used on <a>BlockDevice</a>, may either read the "contents"
--   and copy them to a regular file (potentially hanging indefinitely) or
--   may create a regular empty destination file</li>
--   <li>when used on <a>NamedPipe</a>, will hang indefinitely</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if source file does not exist</li>
--   <li><a>NoSuchThing</a> if source file is a a <a>Socket</a></li>
--   <li><a>PermissionDenied</a> if output directory is not writable</li>
--   <li><a>PermissionDenied</a> if source directory can't be opened</li>
--   <li><a>InvalidArgument</a> if source file is wrong type (symlink or
--   directory)</li>
--   <li><a>SameFile</a> if source and destination are the same file
--   (<a>HPathIOException</a>)</li>
--   </ul>
--   
--   Throws in <a>Strict</a> mode only:
--   
--   <ul>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   </ul>
copyFile :: RawFilePath -> RawFilePath -> CopyMode -> IO ()

-- | Copies a regular file, directory or symbolic link. In case of a
--   symbolic link it is just recreated, even if it points to a directory.
--   Any other file type is ignored.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li>examines filetypes explicitly</li>
--   <li>calls <a>copyDirRecursive</a> for directories</li>
--   </ul>
easyCopy :: RawFilePath -> RawFilePath -> CopyMode -> RecursiveErrorMode -> IO ()

-- | Deletes the given file. Raises <tt>eISDIR</tt> if run on a directory.
--   Does not follow symbolic links.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> for wrong file type (directory)</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   <li><a>PermissionDenied</a> if the directory cannot be read</li>
--   </ul>
--   
--   Notes: calls <tt>unlink</tt>
deleteFile :: RawFilePath -> IO ()

-- | Deletes the given directory, which must be empty, never symlinks.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> for wrong file type (symlink to
--   directory)</li>
--   <li><a>InappropriateType</a> for wrong file type (regular file)</li>
--   <li><a>NoSuchThing</a> if directory does not exist</li>
--   <li><a>UnsatisfiedConstraints</a> if directory is not empty</li>
--   <li><a>PermissionDenied</a> if we can't open or write to parent
--   directory</li>
--   </ul>
--   
--   Notes: calls <tt>rmdir</tt>
deleteDir :: RawFilePath -> IO ()

-- | Deletes the given directory recursively. Does not follow symbolic
--   links. Tries <a>deleteDir</a> first before attemtping a recursive
--   deletion.
--   
--   On directory contents this behaves like <a>easyDelete</a> and thus
--   will ignore any file type that is not <a>RegularFile</a>,
--   <a>SymbolicLink</a> or <a>Directory</a>.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li>not atomic</li>
--   <li>examines filetypes explicitly</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> for wrong file type (symlink to
--   directory)</li>
--   <li><a>InappropriateType</a> for wrong file type (regular file)</li>
--   <li><a>NoSuchThing</a> if directory does not exist</li>
--   <li><a>PermissionDenied</a> if we can't open or write to parent
--   directory</li>
--   </ul>
deleteDirRecursive :: RawFilePath -> IO ()

-- | Deletes a file, directory or symlink. In case of directory, performs
--   recursive deletion. In case of a symlink, the symlink file is deleted.
--   Any other file type is ignored.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li>examines filetypes explicitly</li>
--   <li>calls <a>deleteDirRecursive</a> for directories</li>
--   </ul>
easyDelete :: RawFilePath -> IO ()

-- | Opens a file appropriately by invoking xdg-open. The file type is not
--   checked. This forks a process.
openFile :: RawFilePath -> IO ProcessID

-- | Executes a program with the given arguments. This forks a process.
executeFile :: RawFilePath -> [ByteString] -> IO ProcessID

-- | Create an empty regular file at the given directory with the given
--   filename.
--   
--   Throws:
--   
--   <ul>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   <li><a>NoSuchThing</a> if any of the parent components of the path do
--   not exist</li>
--   </ul>
createRegularFile :: FileMode -> RawFilePath -> IO ()

-- | Create an empty directory at the given directory with the given
--   filename.
--   
--   Throws:
--   
--   <ul>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   <li><a>NoSuchThing</a> if any of the parent components of the path do
--   not exist</li>
--   </ul>
createDir :: FileMode -> RawFilePath -> IO ()

-- | Create an empty directory at the given directory with the given
--   filename.
--   
--   Throws:
--   
--   <ul>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>NoSuchThing</a> if any of the parent components of the path do
--   not exist</li>
--   </ul>
createDirIfMissing :: FileMode -> RawFilePath -> IO ()

-- | Create an empty directory at the given directory with the given
--   filename. All parent directories are created with the same filemode.
--   This basically behaves like:
--   
--   <pre>
--   mkdir -p /some/dir
--   </pre>
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li>not atomic</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>PermissionDenied</a> if any part of the path components do not
--   exist and cannot be written to</li>
--   <li><a>AlreadyExists</a> if destination already exists and is *not* a
--   directory</li>
--   </ul>
createDirRecursive :: FileMode -> RawFilePath -> IO ()

-- | Create a symlink.
--   
--   Throws:
--   
--   <ul>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>AlreadyExists</a> if destination file already exists</li>
--   <li><a>NoSuchThing</a> if any of the parent components of the path do
--   not exist</li>
--   </ul>
--   
--   Note: calls <tt>symlink</tt>
createSymlink :: RawFilePath -> RawFilePath -> IO ()

-- | Rename a given file with the provided filename. Destination and source
--   must be on the same device, otherwise <a>eXDEV</a> will be raised.
--   
--   Does not follow symbolic links, but renames the symbolic link file.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li>has a separate set of exception handling, apart from the
--   syscall</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if source file does not exist</li>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>PermissionDenied</a> if source directory cannot be opened</li>
--   <li><a>UnsupportedOperation</a> if source and destination are on
--   different devices</li>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   <li><a>SameFile</a> if destination and source are the same file
--   (<a>HPathIOException</a>)</li>
--   </ul>
--   
--   Note: calls <a>rename</a> (but does not allow to rename over existing
--   files)
renameFile :: RawFilePath -> RawFilePath -> IO ()

-- | Move a file. This also works across devices by copy-delete fallback.
--   And also works on directories.
--   
--   Does not follow symbolic links, but renames the symbolic link file.
--   
--   Safety/reliability concerns:
--   
--   <ul>
--   <li><a>Overwrite</a> mode is not atomic</li>
--   <li>copy-delete fallback is inherently non-atomic</li>
--   <li>since this function calls <a>easyCopy</a> and <a>easyDelete</a> as
--   a fallback to <a>renameFile</a>, file types that are not
--   <a>RegularFile</a>, <a>SymbolicLink</a> or <a>Directory</a> may be
--   ignored</li>
--   <li>for <a>Overwrite</a> mode, the destination will be deleted (not
--   recursively) before moving</li>
--   </ul>
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if source file does not exist</li>
--   <li><a>PermissionDenied</a> if output directory cannot be written
--   to</li>
--   <li><a>PermissionDenied</a> if source directory cannot be opened</li>
--   <li><a>SameFile</a> if destination and source are the same file
--   (<a>HPathIOException</a>)</li>
--   </ul>
--   
--   Throws in <a>Strict</a> mode only:
--   
--   <ul>
--   <li><a>AlreadyExists</a> if destination already exists</li>
--   </ul>
--   
--   Notes:
--   
--   <ul>
--   <li>calls <a>rename</a> (but does not allow to rename over existing
--   files)</li>
--   </ul>
moveFile :: RawFilePath -> RawFilePath -> CopyMode -> IO ()

-- | Read the given file lazily.
--   
--   Symbolic links are followed. File must exist.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> if file is not a regular file or a
--   symlink</li>
--   <li><a>PermissionDenied</a> if we cannot read the file or the
--   directory containting it</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
readFile :: RawFilePath -> IO ByteString

-- | Read the given file strictly into memory.
--   
--   Symbolic links are followed. File must exist.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> if file is not a regular file or a
--   symlink</li>
--   <li><a>PermissionDenied</a> if we cannot read the file or the
--   directory containting it</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
readFileStrict :: RawFilePath -> IO ByteString

-- | Open the given file as a filestream. Once the filestream exits, the
--   filehandle is cleaned up.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> if file is not a regular file or a
--   symlink</li>
--   <li><a>PermissionDenied</a> if we cannot read the file or the
--   directory containting it</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
readFileStream :: RawFilePath -> IO (SerialT IO (Array Word8))

-- | Write a given ByteString to a file, truncating the file beforehand.
--   Follows symlinks.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> if file is not a regular file or a
--   symlink</li>
--   <li><a>PermissionDenied</a> if we cannot read the file or the
--   directory containting it</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
writeFile :: RawFilePath -> Maybe FileMode -> ByteString -> IO ()

-- | Write a given lazy ByteString to a file, truncating the file
--   beforehand. Follows symlinks.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> if file is not a regular file or a
--   symlink</li>
--   <li><a>PermissionDenied</a> if we cannot read the file or the
--   directory containting it</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
--   
--   Note: uses streamly under the hood
writeFileL :: RawFilePath -> Maybe FileMode -> ByteString -> IO ()

-- | Append a given ByteString to a file. The file must exist. Follows
--   symlinks.
--   
--   Throws:
--   
--   <ul>
--   <li><a>InappropriateType</a> if file is not a regular file or a
--   symlink</li>
--   <li><a>PermissionDenied</a> if we cannot read the file or the
--   directory containting it</li>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
appendFile :: RawFilePath -> ByteString -> IO ()

-- | Default permissions for a new file.
newFilePerms :: FileMode

-- | Default permissions for a new directory.
newDirPerms :: FileMode

-- | Checks if the given file exists. Does not follow symlinks.
--   
--   Only eNOENT is catched (and returns False).
doesExist :: RawFilePath -> IO Bool

-- | Checks if the given file exists and is not a directory. Does not
--   follow symlinks.
--   
--   Only eNOENT is catched (and returns False).
doesFileExist :: RawFilePath -> IO Bool

-- | Checks if the given file exists and is a directory. Does not follow
--   symlinks.
--   
--   Only eNOENT is catched (and returns False).
doesDirectoryExist :: RawFilePath -> IO Bool

-- | Checks whether a file or folder is readable.
--   
--   Only eACCES, eROFS, eTXTBSY, ePERM are catched (and return False).
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
isReadable :: RawFilePath -> IO Bool

-- | Checks whether a file or folder is writable.
--   
--   Only eACCES, eROFS, eTXTBSY, ePERM are catched (and return False).
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
isWritable :: RawFilePath -> IO Bool

-- | Checks whether a file or folder is executable.
--   
--   Only eACCES, eROFS, eTXTBSY, ePERM are catched (and return False).
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   </ul>
isExecutable :: RawFilePath -> IO Bool

-- | Checks whether the directory at the given path exists and can be
--   opened. This invokes <a>openDirStream</a> which follows symlinks.
canOpenDirectory :: RawFilePath -> IO Bool
getModificationTime :: RawFilePath -> IO UTCTime
setModificationTime :: RawFilePath -> EpochTime -> IO ()
setModificationTimeHiRes :: RawFilePath -> POSIXTime -> IO ()

-- | Gets all filenames of the given directory. This excludes "." and "..".
--   This version does not follow symbolic links.
--   
--   The contents are not sorted and there is no guarantee on the ordering.
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if directory does not exist</li>
--   <li><a>InappropriateType</a> if file type is wrong (file)</li>
--   <li><a>InappropriateType</a> if file type is wrong (symlink to
--   file)</li>
--   <li><a>InappropriateType</a> if file type is wrong (symlink to
--   dir)</li>
--   <li><a>PermissionDenied</a> if directory cannot be opened</li>
--   </ul>
getDirsFiles :: RawFilePath -> IO [RawFilePath]

-- | Like <a>getDirsFiles</a>, but returns the filename only, instead of
--   prepending the base path.
getDirsFiles' :: RawFilePath -> IO [RawFilePath]

-- | Like <a>getDirsFiles'</a>, except returning a Stream.
getDirsFilesStream :: (MonadCatch m, MonadAsync m, MonadMask m) => RawFilePath -> IO (SerialT m RawFilePath)

-- | Get the file type of the file located at the given path. Does not
--   follow symbolic links.
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if the file does not exist</li>
--   <li><a>PermissionDenied</a> if any part of the path is not
--   accessible</li>
--   </ul>
getFileType :: RawFilePath -> IO FileType

-- | Applies <tt>realpath</tt> on the given path.
--   
--   Throws:
--   
--   <ul>
--   <li><a>NoSuchThing</a> if the file at the given path does not
--   exist</li>
--   <li><a>NoSuchThing</a> if the symlink is broken</li>
--   </ul>
canonicalizePath :: RawFilePath -> IO RawFilePath

-- | Converts any path to an absolute path. This is done in the following
--   way:
--   
--   <ul>
--   <li>if the path is already an absolute one, just return it</li>
--   <li>if it's a relative path, prepend the current directory to it</li>
--   </ul>
toAbs :: RawFilePath -> IO RawFilePath
instance GHC.Show.Show System.Posix.RawFilePath.Directory.FileType
instance GHC.Classes.Eq System.Posix.RawFilePath.Directory.FileType