    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE TemplateHaskell #-}
    {-# LANGUAGE TupleSections #-}
    {-# LANGUAGE TypeFamilies #-}

    -- |
    -- Module      :  Path.IO
    -- Copyright   :  © 2016–present Mark Karpov
    -- License     :  BSD 3 clause
    --
    -- Maintainer  :  Mark Karpov <markkarpov92@gmail.com>
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- This module provides an interface to "System.Directory" for users of the
    -- "Path" module. It also implements some extra functionality like recursive
    -- scanning and copying of directories, working with temporary
    -- files\/directories, etc.
    module Path.IO
      ( -- * Actions on directories
        createDir,
        createDirIfMissing,
        ensureDir,
        removeDir,
        removeDirRecur,
        removePathForcibly,
        renameDir,
        renamePath,
        listDir,
        listDirRel,
        listDirRecur,
        listDirRecurRel,
        copyDirRecur,
        copyDirRecur',

        -- ** Walking directory trees
        WalkAction (..),
        walkDir,
        walkDirRel,
        walkDirAccum,
        walkDirAccumRel,

        -- ** Current working directory
        getCurrentDir,
        setCurrentDir,
        withCurrentDir,

        -- * Pre-defined directories
        getHomeDir,
        getAppUserDataDir,
        getUserDocsDir,
        getTempDir,
        D.XdgDirectory (..),
        getXdgDir,
        D.XdgDirectoryList (..),
        getXdgDirList,

        -- * Path transformation
        AnyPath (..),
        resolveFile,
        resolveFile',
        resolveDir,
        resolveDir',

        -- * Actions on files
        removeFile,
        renameFile,
        copyFile,
        getFileSize,
        findExecutable,
        findFile,
        findFiles,
        findFilesWith,

        -- * Symbolic links
        createFileLink,
        createDirLink,
        removeDirLink,
        getSymlinkTarget,
        isSymlink,

        -- * Temporary files and directories
        withTempFile,
        withTempDir,
        withSystemTempFile,
        withSystemTempDir,
        openTempFile,
        openBinaryTempFile,
        createTempDir,

        -- * Existence tests
        doesPathExist,
        doesFileExist,
        doesDirExist,
        isLocationOccupied,
        forgivingAbsence,
        ignoringAbsence,

        -- * Permissions
        D.Permissions,
        D.emptyPermissions,
        D.readable,
        D.writable,
        D.executable,
        D.searchable,
        D.setOwnerReadable,
        D.setOwnerWritable,
        D.setOwnerExecutable,
        D.setOwnerSearchable,
        getPermissions,
        setPermissions,
        copyPermissions,

        -- * Timestamps
        getAccessTime,
        setAccessTime,
        setModificationTime,
        getModificationTime,
      )
    where

    import Control.Arrow ((***))
    import Control.Monad
    import Control.Monad.Catch
    import Control.Monad.IO.Class (MonadIO (..))
    import Control.Monad.Trans.Class (lift)
    import Control.Monad.Trans.Maybe (MaybeT (..), runMaybeT)
    import Control.Monad.Trans.Writer.Strict (WriterT, execWriterT, tell)
    import Data.DList qualified as DList
    import Data.Either (lefts, rights)
    import Data.Kind (Type)
    import Data.List ((\\))
    import Data.Set qualified as S
    import Data.Time (UTCTime)
    import Path
    import System.Directory qualified as D
    import System.FilePath qualified as F
    import System.IO (Handle)
    import System.IO.Error (isDoesNotExistError)
    import System.IO.Temp qualified as T
    import System.PosixCompat.Files qualified as P

    ----------------------------------------------------------------------------
    -- Actions on directories

    -- | @'createDir' dir@ creates a new directory @dir@ which is initially
    -- empty, or as near to empty as the operating system allows.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' \/ 'PermissionDenied'
    -- The process has insufficient privileges to perform the operation.
    -- @[EROFS, EACCES]@
    --
    -- * 'isAlreadyExistsError' \/ 'AlreadyExists'
    -- The operand refers to a directory that already exists.
    -- @ [EEXIST]@
    --
    -- * 'HardwareFault'
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * 'InvalidArgument'
    -- The operand is not a valid directory name.
    -- @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'NoSuchThing'
    -- There is no path to the directory.
    -- @[ENOENT, ENOTDIR]@
    --
    -- * 'ResourceExhausted' Insufficient resources (virtual memory, process
    -- file descriptors, physical disk space, etc.) are available to perform the
    -- operation. @[EDQUOT, ENOSPC, ENOMEM, EMLINK]@
    --
    -- * 'InappropriateType'
    -- The path refers to an existing non-directory object.
    -- @[EEXIST]@
    createDir :: (MonadIO m) => Path b Dir -> m ()
    createDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    createDir = (FilePath -> IO ()) -> Path b Dir -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.createDirectory

    -- | @'createDirIfMissing' parents dir@ creates a new directory @dir@ if it
    -- doesn't exist. If the first argument is 'True' the function will also
    -- create all parent directories if they are missing.
    createDirIfMissing ::
      (MonadIO m) =>
      -- | Create its parents too?
      Bool ->
      -- | The path to the directory you want to make
      Path b Dir ->
      m ()
    createDirIfMissing :: forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
    createDirIfMissing Bool
    p = (FilePath -> IO ()) -> Path b Dir -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD (Bool -> FilePath -> IO ()
    D.createDirectoryIfMissing Bool
    p)

    -- | Ensure that a directory exists creating it and its parent directories
    -- if necessary. This is just a handy shortcut:
    --
    -- > ensureDir = createDirIfMissing True
    --
    -- @since 0.3.1
    ensureDir :: (MonadIO m) => Path b Dir -> m ()
    ensureDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    ensureDir = Bool -> Path b Dir -> m ()
    forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
    createDirIfMissing Bool
    True

    -- | @'removeDir' dir@ removes an existing directory @dir@. The
    -- implementation may specify additional constraints which must be satisfied
    -- before a directory can be removed (e.g. the directory has to be empty, or
    -- may not be in use by other processes). It is not legal for an
    -- implementation to partially remove a directory unless the entire
    -- directory is removed. A conformant implementation need not support
    -- directory removal in all situations (e.g. removal of the root directory).
    --
    -- The operation may fail with:
    --
    -- * 'HardwareFault'
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * 'InvalidArgument'
    -- The operand is not a valid directory name.
    -- @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'isDoesNotExistError' \/ 'NoSuchThing'
    -- The directory does not exist.
    -- @[ENOENT, ENOTDIR]@
    --
    -- * 'isPermissionError' \/ 'PermissionDenied'
    -- The process has insufficient privileges to perform the operation.
    -- @[EROFS, EACCES, EPERM]@
    --
    -- * 'UnsatisfiedConstraints'
    -- Implementation-dependent constraints are not satisfied.
    -- @[EBUSY, ENOTEMPTY, EEXIST]@
    --
    -- * 'UnsupportedOperation'
    -- The implementation does not support removal in this situation.
    -- @[EINVAL]@
    --
    -- * 'InappropriateType'
    -- The operand refers to an existing non-directory object.
    -- @[ENOTDIR]@
    removeDir :: (MonadIO m) => Path b Dir -> m ()
    removeDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    removeDir = (FilePath -> IO ()) -> Path b Dir -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.removeDirectory

    -- | @'removeDirRecur' dir@ removes an existing directory @dir@ together
    -- with its contents and sub-directories. Within this directory, symbolic
    -- links are removed without affecting their targets.
    removeDirRecur :: (MonadIO m) => Path b Dir -> m ()
    removeDirRecur :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    removeDirRecur = (FilePath -> IO ()) -> Path b Dir -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.removeDirectoryRecursive

    -- | Remove a file or directory at /path/ together with its contents and
    -- subdirectories. Symbolic links are removed without affecting their
    -- targets. If the path does not exist, nothing happens.
    --
    -- Unlike other removal functions, this function will also attempt to delete
    -- files marked as read-only or otherwise made unremovable due to permissions.
    -- As a result, if the removal is incomplete, the permissions or attributes on
    -- the remaining files may be altered.  If there are hard links in the
    -- directory, then permissions on all related hard links may be altered.
    --
    -- If an entry within the directory vanishes while @removePathForcibly@ is
    -- running, it is silently ignored.
    --
    -- If an exception occurs while removing an entry, @removePathForcibly@ will
    -- still try to remove as many entries as it can before failing with an
    -- exception.  The first exception that it encountered is re-thrown.
    --
    -- @since 1.7.0
    removePathForcibly :: (MonadIO m) => Path b t -> m ()
    removePathForcibly :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m ()
    removePathForcibly = (FilePath -> IO ()) -> Path b t -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.removePathForcibly

    -- | @'renameDir' old new@ changes the name of an existing directory from
    --  @old@ to @new@. If the @new@ directory already exists, it is atomically
    --  replaced by the @old@ directory. If the @new@ directory is neither the
    --  @old@ directory nor an alias of the @old@ directory, it is removed as if
    --  by 'removeDir'. A conformant implementation need not support renaming
    --  directories in all situations (e.g. renaming to an existing directory, or
    --  across different physical devices), but the constraints must be
    --  documented.
    --
    --  On Win32 platforms, @renameDir@ fails if the @new@ directory already
    --  exists.
    --
    --  The operation may fail with:
    --
    --  * 'HardwareFault'
    --  A physical I\/O error has occurred.
    --  @[EIO]@
    --
    --  * 'InvalidArgument'
    --  Either operand is not a valid directory name.
    --  @[ENAMETOOLONG, ELOOP]@
    --
    --  * 'isDoesNotExistError' \/ 'NoSuchThing'
    --  The original directory does not exist, or there is no path to the target.
    --  @[ENOENT, ENOTDIR]@
    --
    --  * 'isPermissionError' \/ 'PermissionDenied'
    --  The process has insufficient privileges to perform the operation.
    --  @[EROFS, EACCES, EPERM]@
    --
    --  * 'ResourceExhausted'
    --  Insufficient resources are available to perform the operation.
    --  @[EDQUOT, ENOSPC, ENOMEM, EMLINK]@
    --
    --  * 'UnsatisfiedConstraints'
    --  Implementation-dependent constraints are not satisfied.
    --  @[EBUSY, ENOTEMPTY, EEXIST]@
    --
    --  * 'UnsupportedOperation'
    --  The implementation does not support renaming in this situation.
    --  @[EINVAL, EXDEV]@
    --
    --  * 'InappropriateType'
    --  Either path refers to an existing non-directory object.
    --  @[ENOTDIR, EISDIR]@
    renameDir ::
      (MonadIO m) =>
      -- | Old name
      Path b0 Dir ->
      -- | New name
      Path b1 Dir ->
      m ()
    renameDir :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 Dir -> Path b1 Dir -> m ()
    renameDir = (FilePath -> FilePath -> IO ())
    -> Path b0 Dir -> Path b1 Dir -> m ()
    forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO ()
    D.renameDirectory

    -- | Rename a file or directory.  If the destination path already exists, it
    -- is replaced atomically.  The destination path must not point to an existing
    -- directory.  A conformant implementation need not support renaming files in
    -- all situations (e.g. renaming across different physical devices), but the
    -- constraints must be documented.
    --
    -- The operation may fail with:
    --
    -- * @HardwareFault@
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * @InvalidArgument@
    -- Either operand is not a valid file name.
    -- @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'isDoesNotExistError'
    -- The original file does not exist, or there is no path to the target.
    -- @[ENOENT, ENOTDIR]@
    --
    -- * 'isPermissionError'
    -- The process has insufficient privileges to perform the operation.
    -- @[EROFS, EACCES, EPERM]@
    --
    -- * 'System.IO.isFullError'
    -- Insufficient resources are available to perform the operation.
    -- @[EDQUOT, ENOSPC, ENOMEM, EMLINK]@
    --
    -- * @UnsatisfiedConstraints@
    -- Implementation-dependent constraints are not satisfied.
    -- @[EBUSY]@
    --
    -- * @UnsupportedOperation@
    -- The implementation does not support renaming in this situation.
    -- @[EXDEV]@
    --
    -- * @InappropriateType@
    -- Either the destination path refers to an existing directory, or one of the
    -- parent segments in the destination path is not a directory.
    -- @[ENOTDIR, EISDIR, EINVAL, EEXIST, ENOTEMPTY]@
    --
    -- @since 1.7.0
    renamePath :: (MonadIO m) => Path b0 t -> Path b1 t -> m ()
    renamePath :: forall (m :: * -> *) b0 t b1.
    MonadIO m =>
    Path b0 t -> Path b1 t -> m ()
    renamePath = (FilePath -> FilePath -> IO ()) -> Path b0 t -> Path b1 t -> m ()
    forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO ()
    D.renamePath

    -- | @'listDir' dir@ returns a list of /all/ entries in @dir@ without the
    -- special entries (@.@ and @..@). Entries are not sorted.
    --
    -- The operation may fail with:
    --
    -- * 'HardwareFault'
    --   A physical I\/O error has occurred.
    --   @[EIO]@
    --
    -- * 'InvalidArgument'
    --   The operand is not a valid directory name.
    --   @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'isDoesNotExistError' \/ 'NoSuchThing'
    --   The directory does not exist.
    --   @[ENOENT, ENOTDIR]@
    --
    -- * 'isPermissionError' \/ 'PermissionDenied'
    --   The process has insufficient privileges to perform the operation.
    --   @[EACCES]@
    --
    -- * 'ResourceExhausted'
    --   Insufficient resources are available to perform the operation.
    --   @[EMFILE, ENFILE]@
    --
    -- * 'InappropriateType'
    --   The path refers to an existing non-directory object.
    --   @[ENOTDIR]@
    listDir ::
      (MonadIO m) =>
      -- | Directory to list
      Path b Dir ->
      -- | Sub-directories and files
      m ([Path Abs Dir], [Path Abs File])
    listDir :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> m ([Path Abs Dir], [Path Abs File])
    listDir Path b Dir
    path = do
      bpath <- Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    path
      (subdirs, files) <- listDirRel bpath
      return
        ( (bpath </>) <$> subdirs,
          (bpath </>) <$> files
        )

    -- | The same as 'listDir' but returns relative paths.
    --
    -- @since 1.4.0
    listDirRel ::
      (MonadIO m) =>
      -- | Directory to list
      Path b Dir ->
      -- | Sub-directories and files
      m ([Path Rel Dir], [Path Rel File])
    listDirRel :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> m ([Path Rel Dir], [Path Rel File])
    listDirRel Path b Dir
    path = IO ([Path Rel Dir], [Path Rel File])
    -> m ([Path Rel Dir], [Path Rel File])
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ([Path Rel Dir], [Path Rel File])
     -> m ([Path Rel Dir], [Path Rel File]))
    -> IO ([Path Rel Dir], [Path Rel File])
    -> m ([Path Rel Dir], [Path Rel File])
    forall a b. (a -> b) -> a -> b
    $ do
      raw <- (FilePath -> IO [FilePath]) -> Path b Dir -> IO [FilePath]
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO [FilePath]
    D.getDirectoryContents Path b Dir
    path
      items <- forM (raw \\ [".", ".."]) $ \FilePath
    item -> do
        isDir <- IO Bool -> IO Bool
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> IO Bool
    D.doesDirectoryExist (FilePath -> IO Bool) -> FilePath -> IO Bool
    forall a b. (a -> b) -> a -> b
    $ Path b Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path b Dir
    path FilePath -> FilePath -> FilePath
    F.</> FilePath
    item)
        if isDir
          then Left <$> parseRelDir item
          else Right <$> parseRelFile item
      return (lefts items, rights items)

    -- | Similar to 'listDir', but recursively traverses every sub-directory
    -- /excluding symbolic links/, and returns all files and directories found.
    -- This can fail with the same exceptions as 'listDir'.
    --
    -- __Note__: before version /1.3.0/, this function followed symlinks.
    listDirRecur ::
      (MonadIO m) =>
      -- | Directory to list
      Path b Dir ->
      -- | Sub-directories and files
      m ([Path Abs Dir], [Path Abs File])
    listDirRecur :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> m ([Path Abs Dir], [Path Abs File])
    listDirRecur Path b Dir
    dir =
      (DList (Path Abs Dir) -> [Path Abs Dir]
    forall a. DList a -> [a]
    DList.toList (DList (Path Abs Dir) -> [Path Abs Dir])
    -> (DList (Path Abs File) -> [Path Abs File])
    -> (DList (Path Abs Dir), DList (Path Abs File))
    -> ([Path Abs Dir], [Path Abs File])
    forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
    forall (a :: * -> * -> *) b c b' c'.
    Arrow a =>
    a b c -> a b' c' -> a (b, b') (c, c')
    *** DList (Path Abs File) -> [Path Abs File]
    forall a. DList a -> [a]
    DList.toList)
        ((DList (Path Abs Dir), DList (Path Abs File))
     -> ([Path Abs Dir], [Path Abs File]))
    -> m (DList (Path Abs Dir), DList (Path Abs File))
    -> m ([Path Abs Dir], [Path Abs File])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe
      (Path Abs Dir
       -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> (Path Abs Dir
        -> [Path Abs Dir]
        -> [Path Abs File]
        -> m (DList (Path Abs Dir), DList (Path Abs File)))
    -> Path b Dir
    -> m (DList (Path Abs Dir), DList (Path Abs File))
    forall (m :: * -> *) o b.
    (MonadIO m, Monoid o) =>
    Maybe
      (Path Abs Dir
       -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccum ((Path Abs Dir
     -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> Maybe
         (Path Abs Dir
          -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    forall a. a -> Maybe a
    Just Path Abs Dir
    -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)
    forall {f :: * -> *} {p} {b} {p}.
    MonadIO f =>
    p -> [Path b Dir] -> p -> f (WalkAction b)
    excludeSymlinks) Path Abs Dir
    -> [Path Abs Dir]
    -> [Path Abs File]
    -> m (DList (Path Abs Dir), DList (Path Abs File))
    forall {m :: * -> *} {p} {a} {a}.
    Monad m =>
    p -> [a] -> [a] -> m (DList a, DList a)
    writer Path b Dir
    dir
      where
        excludeSymlinks :: p -> [Path b Dir] -> p -> f (WalkAction b)
    excludeSymlinks p
    _ [Path b Dir]
    subdirs p
    _ =
          [Path b Dir] -> WalkAction b
    forall b. [Path b Dir] -> WalkAction b
    WalkExclude ([Path b Dir] -> WalkAction b)
    -> f [Path b Dir] -> f (WalkAction b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Path b Dir -> f Bool) -> [Path b Dir] -> f [Path b Dir]
    forall (m :: * -> *) a.
    Applicative m =>
    (a -> m Bool) -> [a] -> m [a]
    filterM Path b Dir -> f Bool
    forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
    isSymlink [Path b Dir]
    subdirs
        writer :: p -> [a] -> [a] -> m (DList a, DList a)
    writer p
    _ [a]
    ds [a]
    fs =
          (DList a, DList a) -> m (DList a, DList a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return
            ( [a] -> DList a
    forall a. [a] -> DList a
    DList.fromList [a]
    ds,
              [a] -> DList a
    forall a. [a] -> DList a
    DList.fromList [a]
    fs
            )

    -- | The same as 'listDirRecur' but returns paths that are relative to the
    -- given directory.
    --
    -- @since 1.4.2
    listDirRecurRel ::
      (MonadIO m) =>
      -- | Directory to list
      Path b Dir ->
      -- | Sub-directories and files
      m ([Path Rel Dir], [Path Rel File])
    listDirRecurRel :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> m ([Path Rel Dir], [Path Rel File])
    listDirRecurRel Path b Dir
    dir =
      (DList (Path Rel Dir) -> [Path Rel Dir]
    forall a. DList a -> [a]
    DList.toList (DList (Path Rel Dir) -> [Path Rel Dir])
    -> (DList (Path Rel File) -> [Path Rel File])
    -> (DList (Path Rel Dir), DList (Path Rel File))
    -> ([Path Rel Dir], [Path Rel File])
    forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
    forall (a :: * -> * -> *) b c b' c'.
    Arrow a =>
    a b c -> a b' c' -> a (b, b') (c, c')
    *** DList (Path Rel File) -> [Path Rel File]
    forall a. DList a -> [a]
    DList.toList)
        ((DList (Path Rel Dir), DList (Path Rel File))
     -> ([Path Rel Dir], [Path Rel File]))
    -> m (DList (Path Rel Dir), DList (Path Rel File))
    -> m ([Path Rel Dir], [Path Rel File])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe
      (Path Rel Dir
       -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> (Path Rel Dir
        -> [Path Rel Dir]
        -> [Path Rel File]
        -> m (DList (Path Rel Dir), DList (Path Rel File)))
    -> Path b Dir
    -> m (DList (Path Rel Dir), DList (Path Rel File))
    forall (m :: * -> *) o b.
    (MonadIO m, Monoid o) =>
    Maybe
      (Path Rel Dir
       -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccumRel ((Path Rel Dir
     -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> Maybe
         (Path Rel Dir
          -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    forall a. a -> Maybe a
    Just Path Rel Dir
    -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
    excludeSymlinks) Path Rel Dir
    -> [Path Rel Dir]
    -> [Path Rel File]
    -> m (DList (Path Rel Dir), DList (Path Rel File))
    forall {m :: * -> *} {b} {t} {t}.
    Monad m =>
    Path b Dir
    -> [Path Rel t]
    -> [Path Rel t]
    -> m (DList (Path b t), DList (Path b t))
    writer Path b Dir
    dir
      where
        excludeSymlinks :: Path Rel Dir
    -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
    excludeSymlinks Path Rel Dir
    tdir [Path Rel Dir]
    subdirs [Path Rel File]
    _ =
          [Path Rel Dir] -> WalkAction Rel
    forall b. [Path b Dir] -> WalkAction b
    WalkExclude ([Path Rel Dir] -> WalkAction Rel)
    -> m [Path Rel Dir] -> m (WalkAction Rel)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Path Rel Dir -> m Bool) -> [Path Rel Dir] -> m [Path Rel Dir]
    forall (m :: * -> *) a.
    Applicative m =>
    (a -> m Bool) -> [a] -> m [a]
    filterM (Path b Dir -> m Bool
    forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
    isSymlink (Path b Dir -> m Bool)
    -> (Path Rel Dir -> Path b Dir) -> Path Rel Dir -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Path b Dir
    dir Path b Dir -> Path Rel Dir -> Path b Dir
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </>) (Path Rel Dir -> Path b Dir)
    -> (Path Rel Dir -> Path Rel Dir) -> Path Rel Dir -> Path b Dir
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Path Rel Dir
    tdir Path Rel Dir -> Path Rel Dir -> Path Rel Dir
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </>)) [Path Rel Dir]
    subdirs
        writer :: Path b Dir
    -> [Path Rel t]
    -> [Path Rel t]
    -> m (DList (Path b t), DList (Path b t))
    writer Path b Dir
    tdir [Path Rel t]
    ds [Path Rel t]
    fs =
          (DList (Path b t), DList (Path b t))
    -> m (DList (Path b t), DList (Path b t))
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return
            ( [Path b t] -> DList (Path b t)
    forall a. [a] -> DList a
    DList.fromList ((Path b Dir
    tdir Path b Dir -> Path Rel t -> Path b t
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </>) (Path Rel t -> Path b t) -> [Path Rel t] -> [Path b t]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Path Rel t]
    ds),
              [Path b t] -> DList (Path b t)
    forall a. [a] -> DList a
    DList.fromList ((Path b Dir
    tdir Path b Dir -> Path Rel t -> Path b t
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </>) (Path Rel t -> Path b t) -> [Path Rel t] -> [Path b t]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Path Rel t]
    fs)
            )

    -- | Copies a directory recursively. It /does not/ follow symbolic links and
    -- preserves permissions when possible. If the destination directory already
    -- exists, new files and sub-directories complement its structure, possibly
    -- overwriting old files if they happen to have the same name as the new
    -- ones.
    --
    -- __Note__: before version /1.3.0/, this function followed symlinks.
    --
    -- __Note__: before version /1.6.0/, the function created empty directories
    -- in the destination directory when the source directory contained
    -- directory symlinks. The symlinked directories were not recursively
    -- traversed. It also copied symlinked files creating normal regular files
    -- in the target directory as the result. This was fixed in the version
    -- /1.6.0/ so that the function now behaves much like the @cp@ utility, not
    -- traversing symlinked directories, but recreating symlinks in the target
    -- directory according to their targets in the source directory.
    copyDirRecur ::
      (MonadIO m) =>
      -- | Source
      Path b0 Dir ->
      -- | Destination
      Path b1 Dir ->
      m ()
    copyDirRecur :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 Dir -> Path b1 Dir -> m ()
    copyDirRecur = Bool -> Path b0 Dir -> Path b1 Dir -> m ()
    forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Bool -> Path b0 Dir -> Path b1 Dir -> m ()
    copyDirRecurGen Bool
    True

    -- | The same as 'copyDirRecur', but it /does not/ preserve directory
    -- permissions. This may be useful, for example, if the directory you want
    -- to copy is “read-only”, but you want your copy to be editable.
    --
    -- @since 1.1.0
    --
    -- __Note__: before version /1.3.0/, this function followed symlinks.
    --
    -- __Note__: before version /1.6.0/, the function created empty directories
    -- in the destination directory when the source directory contained
    -- directory symlinks. The symlinked directories were not recursively
    -- traversed. It also copied symlinked files creating normal regular files
    -- in the target directory as the result. This was fixed in the version
    -- /1.6.0/ so that the function now behaves much like the @cp@ utility, not
    -- traversing symlinked directories, but recreating symlinks in the target
    -- directory according to their targets in the source directory.
    copyDirRecur' ::
      (MonadIO m) =>
      -- | Source
      Path b0 Dir ->
      -- | Destination
      Path b1 Dir ->
      m ()
    copyDirRecur' :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 Dir -> Path b1 Dir -> m ()
    copyDirRecur' = Bool -> Path b0 Dir -> Path b1 Dir -> m ()
    forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Bool -> Path b0 Dir -> Path b1 Dir -> m ()
    copyDirRecurGen Bool
    False

    -- | Generic version of 'copyDirRecur'. The first argument controls whether
    -- to preserve directory permissions or not. /Does not/ follow symbolic
    -- links. Internal function.
    copyDirRecurGen ::
      (MonadIO m) =>
      -- | Should we preserve directory permissions?
      Bool ->
      -- | Source
      Path b0 Dir ->
      -- | Destination
      Path b1 Dir ->
      m ()
    copyDirRecurGen :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Bool -> Path b0 Dir -> Path b1 Dir -> m ()
    copyDirRecurGen Bool
    preserveDirPermissions Path b0 Dir
    src Path b1 Dir
    dest = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
      bsrc <- Path b0 Dir -> IO (AbsPath (Path b0 Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b0 Dir -> m (AbsPath (Path b0 Dir))
    makeAbsolute Path b0 Dir
    src
      bdest <- makeAbsolute dest
      (dirs, files) <- listDirRecur bsrc
      let swapParent ::
            Path Abs Dir ->
            Path Abs Dir ->
            Path Abs t ->
            IO (Path Abs t)
          swapParent Path Abs Dir
    old Path Abs Dir
    new Path Abs t
    path =
            (Path Abs Dir
    new Path Abs Dir -> Path Rel t -> Path Abs t
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </>)
              (Path Rel t -> Path Abs t) -> IO (Path Rel t) -> IO (Path Abs t)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Path Abs Dir -> Path Abs t -> IO (Path Rel t)
    forall (m :: * -> *) b t.
    MonadThrow m =>
    Path b Dir -> Path b t -> m (Path Rel t)
    stripProperPrefix Path Abs Dir
    old Path Abs t
    path
      ensureDir bdest
      copyPermissionsIOs <- forM dirs $ \Path Abs Dir
    srcDir -> do
        destDir <- Path Abs Dir -> Path Abs Dir -> Path Abs Dir -> IO (Path Abs Dir)
    forall t.
    Path Abs Dir -> Path Abs Dir -> Path Abs t -> IO (Path Abs t)
    swapParent Path Abs Dir
    bsrc Path Abs Dir
    bdest Path Abs Dir
    srcDir
        dirIsSymlink <- isSymlink srcDir
        if dirIsSymlink
          then do
            target <- getSymlinkTarget srcDir
            D.createDirectoryLink target $
              toFilePath' destDir
          else ensureDir destDir
        pure $ ignoringIOErrors (copyPermissions srcDir destDir)
      forM_ files $ \Path Abs File
    srcFile -> do
        destFile <- Path Abs Dir -> Path Abs Dir -> Path Abs File -> IO (Path Abs File)
    forall t.
    Path Abs Dir -> Path Abs Dir -> Path Abs t -> IO (Path Abs t)
    swapParent Path Abs Dir
    bsrc Path Abs Dir
    bdest Path Abs File
    srcFile
        fileIsSymlink <- isSymlink srcFile
        if fileIsSymlink
          then do
            target <- getSymlinkTarget srcFile
            D.createFileLink target (toFilePath destFile)
          else copyFile srcFile destFile
      when preserveDirPermissions $ do
        ignoringIOErrors (copyPermissions bsrc bdest)
        sequence_ copyPermissionsIOs

    ----------------------------------------------------------------------------
    -- Walking directory trees

    -- Recursive directory walk functionality, with a flexible API and avoidance
    -- of loops. Following are some notes on the design.
    --
    -- Callback handler API:
    --
    -- The callback handler interface is designed to be highly flexible. There are
    -- two possible alternative ways to control the traversal:
    --
    -- - In the context of the parent dir, decide which subdirs to descend into.
    -- - In the context of the subdir, decide whether to traverse the subdir or not.
    --
    -- We choose the first approach here since it is more flexible and can
    -- achieve everything that the second one can. The additional benefit with
    -- this is that we can use the parent dir context efficiently instead of
    -- each child looking at the parent context independently.
    --
    -- To control which subdirs to descend we use a 'WalkExclude' API instead of
    -- a “WalkInclude” type of API so that the handlers cannot accidentally ask
    -- us to descend a dir which is not a subdir of the directory being walked.
    --
    -- Avoiding Traversal Loops:
    --
    -- There can be loops in the path being traversed due to subdirectory
    -- symlinks or filesystem corruptions can cause loops by creating directory
    -- hardlinks. Also, if the filesystem is changing while we are traversing
    -- then we might be going in loops due to the changes.
    --
    -- We record the path we are coming from to detect the loops. If we end up
    -- traversing the same directory again we are in a loop.

    -- | Action returned by the traversal handler function. The action controls
    -- how the traversal will proceed.
    --
    -- __Note__: in version /1.4.0/ the type was adjusted to have the @b@ type
    -- parameter.
    --
    -- @since 1.2.0
    data WalkAction b
      = -- | Finish the entire walk altogether
        WalkFinish
      | -- | List of sub-directories to exclude from
        -- descending
        WalkExclude [Path b Dir]
      deriving (WalkAction b -> WalkAction b -> Bool
    (WalkAction b -> WalkAction b -> Bool)
    -> (WalkAction b -> WalkAction b -> Bool) -> Eq (WalkAction b)
    forall b. WalkAction b -> WalkAction b -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall b. WalkAction b -> WalkAction b -> Bool
    == :: WalkAction b -> WalkAction b -> Bool
    $c/= :: forall b. WalkAction b -> WalkAction b -> Bool
    /= :: WalkAction b -> WalkAction b -> Bool
    Eq, Int -> WalkAction b -> FilePath -> FilePath
    [WalkAction b] -> FilePath -> FilePath
    WalkAction b -> FilePath
    (Int -> WalkAction b -> FilePath -> FilePath)
    -> (WalkAction b -> FilePath)
    -> ([WalkAction b] -> FilePath -> FilePath)
    -> Show (WalkAction b)
    forall b. Int -> WalkAction b -> FilePath -> FilePath
    forall b. [WalkAction b] -> FilePath -> FilePath
    forall b. WalkAction b -> FilePath
    forall a.
    (Int -> a -> FilePath -> FilePath)
    -> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
    $cshowsPrec :: forall b. Int -> WalkAction b -> FilePath -> FilePath
    showsPrec :: Int -> WalkAction b -> FilePath -> FilePath
    $cshow :: forall b. WalkAction b -> FilePath
    show :: WalkAction b -> FilePath
    $cshowList :: forall b. [WalkAction b] -> FilePath -> FilePath
    showList :: [WalkAction b] -> FilePath -> FilePath
    Show)

    -- | Traverse a directory tree using depth first pre-order traversal,
    -- calling a handler function at each directory node traversed. The absolute
    -- paths of the parent directory, sub-directories and the files in the
    -- directory are provided as arguments to the handler.
    --
    -- The function is capable of detecting and avoiding traversal loops in the
    -- directory tree. Note that the traversal follows symlinks by default, an
    -- appropriate traversal handler can be used to avoid that when necessary.
    --
    -- @since 1.2.0
    walkDir ::
      (MonadIO m) =>
      -- | Handler (@dir -> subdirs -> files -> 'WalkAction'@)
      (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)) ->
      -- | Directory where traversal begins
      Path b Dir ->
      m ()
    walkDir :: forall (m :: * -> *) b.
    MonadIO m =>
    (Path Abs Dir
     -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> Path b Dir -> m ()
    walkDir Path Abs Dir
    -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)
    handler Path b Dir
    topdir =
      m (Maybe ()) -> m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (m (Maybe ()) -> m ()) -> m (Maybe ()) -> m ()
    forall a b. (a -> b) -> a -> b
    $
        Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    topdir m (Path Abs Dir) -> (Path Abs Dir -> m (Maybe ())) -> m (Maybe ())
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
    walkAvoidLoop Set (DeviceID, FileID)
    forall a. Set a
    S.empty
      where
        walkAvoidLoop :: Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
    walkAvoidLoop Set (DeviceID, FileID)
    traversed Path Abs Dir
    curdir = do
          mRes <- Set (DeviceID, FileID)
    -> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
    forall {m :: * -> *}.
    MonadIO m =>
    Set (DeviceID, FileID)
    -> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
    checkLoop Set (DeviceID, FileID)
    traversed Path Abs Dir
    curdir
          case mRes of
            Maybe (Set (DeviceID, FileID))
    Nothing -> Maybe () -> m (Maybe ())
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
    forall a b. (a -> b) -> a -> b
    $ () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
            Just Set (DeviceID, FileID)
    traversed' -> Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
    walktree Set (DeviceID, FileID)
    traversed' Path Abs Dir
    curdir
        walktree :: Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
    walktree Set (DeviceID, FileID)
    traversed Path Abs Dir
    curdir = do
          (subdirs, files) <- Path Abs Dir -> m ([Path Abs Dir], [Path Abs File])
    forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> m ([Path Abs Dir], [Path Abs File])
    listDir Path Abs Dir
    curdir
          action <- handler curdir subdirs files
          case action of
            WalkAction Abs
    WalkFinish -> Maybe () -> m (Maybe ())
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe ()
    forall a. Maybe a
    Nothing
            WalkExclude [Path Abs Dir]
    xdirs ->
              case [Path Abs Dir]
    subdirs [Path Abs Dir] -> [Path Abs Dir] -> [Path Abs Dir]
    forall a. Eq a => [a] -> [a] -> [a]
    \\ [Path Abs Dir]
    xdirs of
                [] -> Maybe () -> m (Maybe ())
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
    forall a b. (a -> b) -> a -> b
    $ () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
                [Path Abs Dir]
    ds ->
                  MaybeT m () -> m (Maybe ())
    forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT (MaybeT m () -> m (Maybe ())) -> MaybeT m () -> m (Maybe ())
    forall a b. (a -> b) -> a -> b
    $
                    (Path Abs Dir -> MaybeT m ()) -> [Path Abs Dir] -> MaybeT m ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_
                      (m (Maybe ()) -> MaybeT m ()
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (m (Maybe ()) -> MaybeT m ())
    -> (Path Abs Dir -> m (Maybe ())) -> Path Abs Dir -> MaybeT m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
    walkAvoidLoop Set (DeviceID, FileID)
    traversed)
                      [Path Abs Dir]
    ds
        checkLoop :: Set (DeviceID, FileID)
    -> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
    checkLoop Set (DeviceID, FileID)
    traversed Path Abs Dir
    dir = do
          st <- IO FileStatus -> m FileStatus
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileStatus -> m FileStatus) -> IO FileStatus -> m FileStatus
    forall a b. (a -> b) -> a -> b
    $ FilePath -> IO FileStatus
    P.getFileStatus (Path Abs Dir -> FilePath
    fromAbsDir Path Abs Dir
    dir)
          let ufid = (FileStatus -> DeviceID
    P.deviceID FileStatus
    st, FileStatus -> FileID
    P.fileID FileStatus
    st)
          return $
            if S.member ufid traversed
              then Nothing
              else Just (S.insert ufid traversed)

    -- | The same as 'walkDir' but uses relative paths. The handler is given
    -- @dir@, directory relative to the directory where traversal begins.
    -- Sub-directories and files are relative to @dir@.
    --
    -- @since 1.4.2
    walkDirRel ::
      (MonadIO m) =>
      -- | Handler (@dir -> subdirs -> files -> 'WalkAction'@)
      ( Path Rel Dir ->
        [Path Rel Dir] ->
        [Path Rel File] ->
        m (WalkAction Rel)
      ) ->
      -- | Directory where traversal begins
      Path b Dir ->
      m ()
    walkDirRel :: forall (m :: * -> *) b.
    MonadIO m =>
    (Path Rel Dir
     -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> Path b Dir -> m ()
    walkDirRel Path Rel Dir
    -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
    handler Path b Dir
    topdir' = do
      topdir <- Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    topdir'
      let walkAvoidLoop Set (DeviceID, FileID)
    traversed Path Rel Dir
    curdir = do
            mRes <- Set (DeviceID, FileID)
    -> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
    forall {m :: * -> *}.
    MonadIO m =>
    Set (DeviceID, FileID)
    -> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
    checkLoop Set (DeviceID, FileID)
    traversed (Path Abs Dir
    topdir Path Abs Dir -> Path Rel Dir -> Path Abs Dir
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </> Path Rel Dir
    curdir)
            case mRes of
              Maybe (Set (DeviceID, FileID))
    Nothing -> Maybe () -> m (Maybe ())
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
    forall a b. (a -> b) -> a -> b
    $ () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
              Just Set (DeviceID, FileID)
    traversed' -> Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
    walktree Set (DeviceID, FileID)
    traversed' Path Rel Dir
    curdir
          walktree Set (DeviceID, FileID)
    traversed Path Rel Dir
    curdir = do
            (subdirs, files) <- Path Abs Dir -> m ([Path Rel Dir], [Path Rel File])
    forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> m ([Path Rel Dir], [Path Rel File])
    listDirRel (Path Abs Dir
    topdir Path Abs Dir -> Path Rel Dir -> Path Abs Dir
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </> Path Rel Dir
    curdir)
            action <- handler curdir subdirs files
            case action of
              WalkAction Rel
    WalkFinish -> Maybe () -> m (Maybe ())
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe ()
    forall a. Maybe a
    Nothing
              WalkExclude [Path Rel Dir]
    xdirs ->
                case [Path Rel Dir]
    subdirs [Path Rel Dir] -> [Path Rel Dir] -> [Path Rel Dir]
    forall a. Eq a => [a] -> [a] -> [a]
    \\ [Path Rel Dir]
    xdirs of
                  [] -> Maybe () -> m (Maybe ())
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
    forall a b. (a -> b) -> a -> b
    $ () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
                  [Path Rel Dir]
    ds ->
                    MaybeT m () -> m (Maybe ())
    forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT (MaybeT m () -> m (Maybe ())) -> MaybeT m () -> m (Maybe ())
    forall a b. (a -> b) -> a -> b
    $
                      (Path Rel Dir -> MaybeT m ()) -> [Path Rel Dir] -> MaybeT m ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_
                        (m (Maybe ()) -> MaybeT m ()
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (m (Maybe ()) -> MaybeT m ())
    -> (Path Rel Dir -> m (Maybe ())) -> Path Rel Dir -> MaybeT m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
    walkAvoidLoop Set (DeviceID, FileID)
    traversed)
                        ((Path Rel Dir
    curdir Path Rel Dir -> Path Rel Dir -> Path Rel Dir
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </>) (Path Rel Dir -> Path Rel Dir) -> [Path Rel Dir] -> [Path Rel Dir]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Path Rel Dir]
    ds)
          checkLoop Set (DeviceID, FileID)
    traversed Path Abs Dir
    dir = do
            st <- IO FileStatus -> m FileStatus
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileStatus -> m FileStatus) -> IO FileStatus -> m FileStatus
    forall a b. (a -> b) -> a -> b
    $ FilePath -> IO FileStatus
    P.getFileStatus (Path Abs Dir -> FilePath
    fromAbsDir Path Abs Dir
    dir)
            let ufid = (FileStatus -> DeviceID
    P.deviceID FileStatus
    st, FileStatus -> FileID
    P.fileID FileStatus
    st)
            return $
              if S.member ufid traversed
                then Nothing
                else Just (S.insert ufid traversed)
      void (walkAvoidLoop S.empty $(mkRelDir "."))

    -- | Similar to 'walkDir' but accepts a 'Monoid'-returning output writer as
    -- well. Values returned by the output writer invocations are accumulated
    -- and returned.
    --
    -- Both, the descend handler as well as the output writer can be used for
    -- side effects but keep in mind that the output writer runs before the
    -- descend handler.
    --
    -- @since 1.2.0
    walkDirAccum ::
      (MonadIO m, Monoid o) =>
      -- | Descend handler (@dir -> subdirs -> files -> 'WalkAction'@),
      -- descend the whole tree if omitted
      Maybe
        (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)) ->
      -- | Output writer (@dir -> subdirs -> files -> o@)
      (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o) ->
      -- | Directory where traversal begins
      Path b Dir ->
      -- | Accumulation of outputs generated by the output writer invocations
      m o
    walkDirAccum :: forall (m :: * -> *) o b.
    (MonadIO m, Monoid o) =>
    Maybe
      (Path Abs Dir
       -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccum = ((Path Abs Dir
      -> [Path Abs Dir]
      -> [Path Abs File]
      -> WriterT o m (WalkAction Abs))
     -> Path b Dir -> WriterT o m ())
    -> Maybe
         (Path Abs Dir
          -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o)
    -> Path b Dir
    -> m o
    forall (m :: * -> *) o a b.
    (MonadIO m, Monoid o) =>
    ((Path a Dir
      -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
     -> Path b Dir -> WriterT o m ())
    -> Maybe
         (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
    -> (Path a Dir -> [Path a Dir] -> [Path a File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccumWith (Path Abs Dir
     -> [Path Abs Dir]
     -> [Path Abs File]
     -> WriterT o m (WalkAction Abs))
    -> Path b Dir -> WriterT o m ()
    forall (m :: * -> *) b.
    MonadIO m =>
    (Path Abs Dir
     -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
    -> Path b Dir -> m ()
    walkDir

    -- | The same as 'walkDirAccum' but uses relative paths. The handler and
    -- writer are given @dir@, directory relative to the directory where
    -- traversal begins. Sub-directories and files are relative to @dir@.
    --
    -- @since 1.4.2
    walkDirAccumRel ::
      (MonadIO m, Monoid o) =>
      -- | Descend handler (@dir -> subdirs -> files -> 'WalkAction'@),
      -- descend the whole tree if omitted
      Maybe
        (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)) ->
      -- | Output writer (@dir -> subdirs -> files -> o@)
      (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o) ->
      -- | Directory where traversal begins
      Path b Dir ->
      -- | Accumulation of outputs generated by the output writer invocations
      m o
    walkDirAccumRel :: forall (m :: * -> *) o b.
    (MonadIO m, Monoid o) =>
    Maybe
      (Path Rel Dir
       -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccumRel = ((Path Rel Dir
      -> [Path Rel Dir]
      -> [Path Rel File]
      -> WriterT o m (WalkAction Rel))
     -> Path b Dir -> WriterT o m ())
    -> Maybe
         (Path Rel Dir
          -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o)
    -> Path b Dir
    -> m o
    forall (m :: * -> *) o a b.
    (MonadIO m, Monoid o) =>
    ((Path a Dir
      -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
     -> Path b Dir -> WriterT o m ())
    -> Maybe
         (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
    -> (Path a Dir -> [Path a Dir] -> [Path a File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccumWith (Path Rel Dir
     -> [Path Rel Dir]
     -> [Path Rel File]
     -> WriterT o m (WalkAction Rel))
    -> Path b Dir -> WriterT o m ()
    forall (m :: * -> *) b.
    MonadIO m =>
    (Path Rel Dir
     -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
    -> Path b Dir -> m ()
    walkDirRel

    -- | Non-public helper function for defining accumulating walking actions.
    walkDirAccumWith ::
      (MonadIO m, Monoid o) =>
      -- | The walk function we use
      ( ( Path a Dir ->
          [Path a Dir] ->
          [Path a File] ->
          WriterT o m (WalkAction a)
        ) ->
        Path b Dir ->
        WriterT o m ()
      ) ->
      -- | Descend handler (@dir -> subdirs -> files -> 'WalkAction'@),
      -- descend the whole tree if omitted
      Maybe (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a)) ->
      -- | Output writer (@dir -> subdirs -> files -> o@)
      (Path a Dir -> [Path a Dir] -> [Path a File] -> m o) ->
      -- | Directory where traversal begins
      Path b Dir ->
      -- | Accumulation of outputs generated by the output writer invocations
      m o
    walkDirAccumWith :: forall (m :: * -> *) o a b.
    (MonadIO m, Monoid o) =>
    ((Path a Dir
      -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
     -> Path b Dir -> WriterT o m ())
    -> Maybe
         (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
    -> (Path a Dir -> [Path a Dir] -> [Path a File] -> m o)
    -> Path b Dir
    -> m o
    walkDirAccumWith (Path a Dir
     -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
    -> Path b Dir -> WriterT o m ()
    walkF Maybe
      (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
    dHandler Path a Dir -> [Path a Dir] -> [Path a File] -> m o
    writer Path b Dir
    topdir =
      WriterT o m () -> m o
    forall (m :: * -> *) w a. Monad m => WriterT w m a -> m w
    execWriterT ((Path a Dir
     -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
    -> Path b Dir -> WriterT o m ()
    walkF Path a Dir
    -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a)
    handler Path b Dir
    topdir)
      where
        handler :: Path a Dir
    -> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a)
    handler Path a Dir
    dir [Path a Dir]
    subdirs [Path a File]
    files = do
          res <- m o -> WriterT o m o
    forall (m :: * -> *) a. Monad m => m a -> WriterT o m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m o -> WriterT o m o) -> m o -> WriterT o m o
    forall a b. (a -> b) -> a -> b
    $ Path a Dir -> [Path a Dir] -> [Path a File] -> m o
    writer Path a Dir
    dir [Path a Dir]
    subdirs [Path a File]
    files
          tell res
          case dHandler of
            Just Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a)
    h -> m (WalkAction a) -> WriterT o m (WalkAction a)
    forall (m :: * -> *) a. Monad m => m a -> WriterT o m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m (WalkAction a) -> WriterT o m (WalkAction a))
    -> m (WalkAction a) -> WriterT o m (WalkAction a)
    forall a b. (a -> b) -> a -> b
    $ Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a)
    h Path a Dir
    dir [Path a Dir]
    subdirs [Path a File]
    files
            Maybe
      (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
    Nothing -> WalkAction a -> WriterT o m (WalkAction a)
    forall a. a -> WriterT o m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Path a Dir] -> WalkAction a
    forall b. [Path b Dir] -> WalkAction b
    WalkExclude [])

    ----------------------------------------------------------------------------
    -- Current working directory

    -- | Obtain the current working directory as an absolute path.
    --
    -- In a multithreaded program, the current working directory is a global
    -- state shared among all threads of the process. Therefore, when performing
    -- filesystem operations from multiple threads, it is highly recommended to
    -- use absolute rather than relative paths (see: 'makeAbsolute').
    --
    -- The operation may fail with:
    --
    -- * 'HardwareFault'
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * 'isDoesNotExistError' or 'NoSuchThing'
    -- There is no path referring to the working directory.
    -- @[EPERM, ENOENT, ESTALE...]@
    --
    -- * 'isPermissionError' or 'PermissionDenied'
    -- The process has insufficient privileges to perform the operation.
    -- @[EACCES]@
    --
    -- * 'ResourceExhausted'
    -- Insufficient resources are available to perform the operation.
    --
    -- * 'UnsupportedOperation'
    -- The operating system has no notion of current working directory.
    getCurrentDir :: (MonadIO m) => m (Path Abs Dir)
    getCurrentDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getCurrentDir = IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a b. (a -> b) -> a -> b
    $ IO FilePath
    D.getCurrentDirectory IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir

    -- | Change the working directory to the given path.
    --
    -- In a multithreaded program, the current working directory is a global
    -- state shared among all threads of the process. Therefore, when performing
    -- filesystem operations from multiple threads, it is highly recommended to
    -- use absolute rather than relative paths (see: 'makeAbsolute').
    --
    -- The operation may fail with:
    --
    -- * 'HardwareFault'
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * 'InvalidArgument'
    -- The operand is not a valid directory name.
    -- @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'isDoesNotExistError' or 'NoSuchThing'
    -- The directory does not exist.
    -- @[ENOENT, ENOTDIR]@
    --
    -- * 'isPermissionError' or 'PermissionDenied'
    -- The process has insufficient privileges to perform the operation.
    -- @[EACCES]@
    --
    -- * 'UnsupportedOperation'
    -- The operating system has no notion of current working directory, or the
    -- working directory cannot be dynamically changed.
    --
    -- * 'InappropriateType'
    -- The path refers to an existing non-directory object.
    -- @[ENOTDIR]@
    setCurrentDir :: (MonadIO m) => Path b Dir -> m ()
    setCurrentDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    setCurrentDir = (FilePath -> IO ()) -> Path b Dir -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.setCurrentDirectory

    -- | Run an 'IO' action with the given working directory and restore the
    -- original working directory afterwards, even if the given action fails due
    -- to an exception.
    --
    -- The operation may fail with the same exceptions as 'getCurrentDir' and
    -- 'setCurrentDir'.
    withCurrentDir ::
      (MonadIO m, MonadMask m) =>
      -- | Directory to execute in
      Path b Dir ->
      -- | Action to be executed
      m a ->
      m a
    withCurrentDir :: forall (m :: * -> *) b a.
    (MonadIO m, MonadMask m) =>
    Path b Dir -> m a -> m a
    withCurrentDir Path b Dir
    dir m a
    action =
      m (Path Abs Dir)
    -> (Path Abs Dir -> m ()) -> (Path Abs Dir -> m a) -> m a
    forall (m :: * -> *) a c b.
    (HasCallStack, MonadMask m) =>
    m a -> (a -> m c) -> (a -> m b) -> m b
    bracket m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getCurrentDir Path Abs Dir -> m ()
    forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    setCurrentDir ((Path Abs Dir -> m a) -> m a) -> (Path Abs Dir -> m a) -> m a
    forall a b. (a -> b) -> a -> b
    $ m a -> Path Abs Dir -> m a
    forall a b. a -> b -> a
    const (Path b Dir -> m ()
    forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    setCurrentDir Path b Dir
    dir m () -> m a -> m a
    forall a b. m a -> m b -> m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> m a
    action)

    ----------------------------------------------------------------------------
    -- Pre-defined directories

    -- | Return the current user's home directory.
    --
    -- The directory returned is expected to be writable by the current user,
    -- but note that it isn't generally considered good practice to store
    -- application-specific data here; use 'getAppUserDataDir' instead.
    --
    -- On Unix, 'getHomeDir' returns the value of the @HOME@ environment
    -- variable. On Windows, the system is queried for a suitable path; a
    -- typical path might be @C:\/Users\//\<user\>/@.
    --
    -- The operation may fail with:
    --
    -- * 'UnsupportedOperation'
    -- The operating system has no notion of home directory.
    --
    -- * 'isDoesNotExistError'
    -- The home directory for the current user does not exist, or
    -- cannot be found.
    getHomeDir :: (MonadIO m) => m (Path Abs Dir)
    getHomeDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getHomeDir = IO FilePath -> m FilePath
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO FilePath
    D.getHomeDirectory m FilePath -> (FilePath -> m (Path Abs Dir)) -> m (Path Abs Dir)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
    resolveDir'

    -- | Obtain the path to a special directory for storing user-specific
    -- application data (traditional Unix location).
    --
    -- The argument is usually the name of the application. Since it will be
    -- integrated into the path, it must consist of valid path characters.
    --
    -- * On Unix-like systems, the path is @~\/./\<app\>/@.
    -- * On Windows, the path is @%APPDATA%\//\<app\>/@
    --   (e.g. @C:\/Users\//\<user\>/\/AppData\/Roaming\//\<app\>/@)
    --
    -- Note: the directory may not actually exist, in which case you would need
    -- to create it. It is expected that the parent directory exists and is
    -- writable.
    --
    -- The operation may fail with:
    --
    -- * 'UnsupportedOperation'
    --   The operating system has no notion of application-specific data
    --   directory.
    --
    -- * 'isDoesNotExistError'
    --   The home directory for the current user does not exist, or cannot be
    --   found.
    getAppUserDataDir ::
      (MonadIO m) =>
      -- | Name of application (used in path construction)
      String ->
      m (Path Abs Dir)
    getAppUserDataDir :: forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
    getAppUserDataDir = IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> (FilePath -> IO (Path Abs Dir)) -> FilePath -> m (Path Abs Dir)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir) (IO FilePath -> IO (Path Abs Dir))
    -> (FilePath -> IO FilePath) -> FilePath -> IO (Path Abs Dir)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO FilePath
    D.getAppUserDataDirectory

    -- | Return the current user's document directory.
    --
    -- The directory returned is expected to be writable by the current user,
    -- but note that it isn't generally considered good practice to store
    -- application-specific data here; use 'getAppUserDataDir' instead.
    --
    -- On Unix, 'getUserDocsDir' returns the value of the @HOME@ environment
    -- variable. On Windows, the system is queried for a suitable path; a
    -- typical path might be @C:\/Users\//\<user\>/\/Documents@.
    --
    -- The operation may fail with:
    --
    -- * 'UnsupportedOperation'
    -- The operating system has no notion of document directory.
    --
    -- * 'isDoesNotExistError'
    -- The document directory for the current user does not exist, or
    -- cannot be found.
    getUserDocsDir :: (MonadIO m) => m (Path Abs Dir)
    getUserDocsDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getUserDocsDir = IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a b. (a -> b) -> a -> b
    $ IO FilePath
    D.getUserDocumentsDirectory IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir

    -- | Return the current directory for temporary files.
    --
    -- On Unix, 'getTempDir' returns the value of the @TMPDIR@ environment
    -- variable or \"\/tmp\" if the variable isn\'t defined. On Windows, the
    -- function checks for the existence of environment variables in the
    -- following order and uses the first path found:
    --
    -- *
    -- TMP environment variable.
    --
    -- *
    -- TEMP environment variable.
    --
    -- *
    -- USERPROFILE environment variable.
    --
    -- *
    -- The Windows directory
    --
    -- The operation may fail with:
    --
    -- * 'UnsupportedOperation'
    -- The operating system has no notion of temporary directory.
    --
    -- The function doesn't verify whether the path exists.
    getTempDir :: (MonadIO m) => m (Path Abs Dir)
    getTempDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getTempDir = IO FilePath -> m FilePath
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO FilePath
    D.getTemporaryDirectory m FilePath -> (FilePath -> m (Path Abs Dir)) -> m (Path Abs Dir)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
    resolveDir'

    -- | Obtain the paths to special directories for storing user-specific
    -- application data, configuration, and cache files, conforming to the
    -- <http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html XDG Base Directory Specification>.
    -- Compared with 'getAppUserDataDir', this function provides a more
    -- fine-grained hierarchy as well as greater flexibility for the user.
    --
    -- It also works on Windows, although in that case 'D.XdgData' and
    -- 'D.XdgConfig' will map to the same directory.
    --
    -- Note: The directory may not actually exist, in which case you would need
    -- to create it with file mode @700@ (i.e. only accessible by the owner).
    --
    -- Note also: this is a piece of conditional API, only available if
    -- @directory-1.2.3.0@ or later is used.
    --
    -- @since 1.2.1
    getXdgDir ::
      (MonadIO m) =>
      -- | Which special directory
      D.XdgDirectory ->
      -- | A relative path that is appended to the path; if 'Nothing', the
      -- base path is returned
      Maybe (Path Rel Dir) ->
      m (Path Abs Dir)
    getXdgDir :: forall (m :: * -> *).
    MonadIO m =>
    XdgDirectory -> Maybe (Path Rel Dir) -> m (Path Abs Dir)
    getXdgDir XdgDirectory
    xdgDir Maybe (Path Rel Dir)
    suffix =
      IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a b. (a -> b) -> a -> b
    $ (XdgDirectory -> FilePath -> IO FilePath
    D.getXdgDirectory XdgDirectory
    xdgDir (FilePath -> IO FilePath) -> FilePath -> IO FilePath
    forall a b. (a -> b) -> a -> b
    $ FilePath
    -> (Path Rel Dir -> FilePath) -> Maybe (Path Rel Dir) -> FilePath
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe FilePath
    "" Path Rel Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Maybe (Path Rel Dir)
    suffix) IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir

    -- | Similar to 'getXdgDir' but retrieves the entire list of XDG
    -- directories.
    --
    -- On Windows, 'D.XdgDataDirs' and 'D.XdgConfigDirs' usually map to the same
    -- list of directories unless overridden.
    --
    -- Refer to the docs of 'D.XdgDirectoryList' for more details.
    --
    -- @since 1.5.0
    getXdgDirList ::
      (MonadIO m) =>
      -- | Which special directory list
      D.XdgDirectoryList ->
      m [Path Abs Dir]
    getXdgDirList :: forall (m :: * -> *).
    MonadIO m =>
    XdgDirectoryList -> m [Path Abs Dir]
    getXdgDirList XdgDirectoryList
    xdgDirList =
      IO [Path Abs Dir] -> m [Path Abs Dir]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (XdgDirectoryList -> IO [FilePath]
    D.getXdgDirectoryList XdgDirectoryList
    xdgDirList IO [FilePath]
    -> ([FilePath] -> IO [Path Abs Dir]) -> IO [Path Abs Dir]
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (FilePath -> IO (Path Abs Dir)) -> [FilePath] -> IO [Path Abs Dir]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir)

    ----------------------------------------------------------------------------
    -- Path transformation

    -- | Class of things ('Path's) that can be canonicalized, made absolute, and
    -- made relative to a some base directory.
    class AnyPath path where
      -- | Type of absolute version of the given @path@.
      type AbsPath path :: Type

      -- | Type of relative version of the given @path@.
      type RelPath path :: Type

      -- | Make a path absolute and remove as many indirections from it as
      -- possible. Indirections include the two special directories @.@ and
      -- @..@, as well as any symbolic links. The input path need not point to
      -- an existing file or directory.
      --
      -- __Note__: if you require only an absolute path, use 'makeAbsolute'
      -- instead. Most programs need not care about whether a path contains
      -- symbolic links.
      --
      -- Due to the fact that symbolic links are dependent on the state of the
      -- existing filesystem, the function can only make a conservative,
      -- best-effort attempt. Nevertheless, if the input path points to an
      -- existing file or directory, then the output path shall also point to
      -- the same file or directory.
      --
      -- Formally, symbolic links are removed from the longest prefix of the
      -- path that still points to an existing file. The function is not atomic,
      -- therefore concurrent changes in the filesystem may lead to incorrect
      -- results.
      --
      -- (Despite the name, the function does not guarantee canonicity of the
      -- returned path due to the presence of hard links, mount points, etc.)
      --
      -- /Known bug(s)/: on Windows, the function does not resolve symbolic
      -- links.
      --
      -- Please note that before version 1.2.3.0 of the @directory@ package,
      -- this function had unpredictable behavior on non-existent paths.
      canonicalizePath ::
        (MonadIO m) =>
        path ->
        m (AbsPath path)

      -- | Make a path absolute by prepending the current directory (if it isn't
      -- already absolute) and applying 'F.normalise' to the result.
      --
      -- If the path is already absolute, the operation never fails. Otherwise,
      -- the operation may fail with the same exceptions as 'getCurrentDir'.
      makeAbsolute ::
        (MonadIO m) =>
        path ->
        m (AbsPath path)

      -- | Make a path relative to a given directory.
      --
      -- @since 0.3.0
      makeRelative ::
        (MonadThrow m) =>
        -- | Base directory
        Path Abs Dir ->
        -- | Path that will be made relative to base directory
        path ->
        m (RelPath path)

      -- | Make a path relative to current working directory.
      --
      -- @since 0.3.0
      makeRelativeToCurrentDir ::
        (MonadIO m) =>
        path ->
        m (RelPath path)

    instance AnyPath (Path b File) where
      type AbsPath (Path b File) = Path Abs File
      type RelPath (Path b File) = Path Rel File

      canonicalizePath :: forall (m :: * -> *).
    MonadIO m =>
    Path b File -> m (AbsPath (Path b File))
    canonicalizePath = (FilePath -> IO (AbsPath (Path b File)))
    -> Path b File -> m (AbsPath (Path b File))
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD ((FilePath -> IO (AbsPath (Path b File)))
     -> Path b File -> m (AbsPath (Path b File)))
    -> (FilePath -> IO (AbsPath (Path b File)))
    -> Path b File
    -> m (AbsPath (Path b File))
    forall a b. (a -> b) -> a -> b
    $ FilePath -> IO FilePath
    D.canonicalizePath (FilePath -> IO FilePath)
    -> (FilePath -> IO (Path Abs File))
    -> FilePath
    -> IO (Path Abs File)
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> FilePath -> IO (Path Abs File)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
    parseAbsFile
      makeAbsolute :: forall (m :: * -> *).
    MonadIO m =>
    Path b File -> m (AbsPath (Path b File))
    makeAbsolute = (FilePath -> IO (AbsPath (Path b File)))
    -> Path b File -> m (AbsPath (Path b File))
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD ((FilePath -> IO (AbsPath (Path b File)))
     -> Path b File -> m (AbsPath (Path b File)))
    -> (FilePath -> IO (AbsPath (Path b File)))
    -> Path b File
    -> m (AbsPath (Path b File))
    forall a b. (a -> b) -> a -> b
    $ FilePath -> IO FilePath
    D.makeAbsolute (FilePath -> IO FilePath)
    -> (FilePath -> IO (Path Abs File))
    -> FilePath
    -> IO (Path Abs File)
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> FilePath -> IO (Path Abs File)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
    parseAbsFile
      makeRelative :: forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path b File -> m (RelPath (Path b File))
    makeRelative Path Abs Dir
    b Path b File
    p = FilePath -> m (Path Rel File)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Rel File)
    parseRelFile (FilePath -> FilePath -> FilePath
    F.makeRelative (Path Abs Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path Abs Dir
    b) (Path b File -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path b File
    p))
      makeRelativeToCurrentDir :: forall (m :: * -> *).
    MonadIO m =>
    Path b File -> m (RelPath (Path b File))
    makeRelativeToCurrentDir Path b File
    p = IO (RelPath (Path b File)) -> m (RelPath (Path b File))
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (RelPath (Path b File)) -> m (RelPath (Path b File)))
    -> IO (RelPath (Path b File)) -> m (RelPath (Path b File))
    forall a b. (a -> b) -> a -> b
    $ IO (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getCurrentDir IO (Path Abs Dir)
    -> (Path Abs Dir -> IO (Path Rel File)) -> IO (Path Rel File)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Path Abs Dir -> Path b File -> IO (Path Rel File))
    -> Path b File -> Path Abs Dir -> IO (Path Rel File)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Path Abs Dir -> Path b File -> IO (Path Rel File)
    Path Abs Dir -> Path b File -> IO (RelPath (Path b File))
    forall path (m :: * -> *).
    (AnyPath path, MonadThrow m) =>
    Path Abs Dir -> path -> m (RelPath path)
    forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path b File -> m (RelPath (Path b File))
    makeRelative Path b File
    p

    instance AnyPath (Path b Dir) where
      type AbsPath (Path b Dir) = Path Abs Dir
      type RelPath (Path b Dir) = Path Rel Dir

      canonicalizePath :: forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    canonicalizePath = (FilePath -> IO FilePath) -> Path b Dir -> m FilePath
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO FilePath
    D.canonicalizePath (Path b Dir -> m FilePath)
    -> (FilePath -> m (Path Abs Dir)) -> Path b Dir -> m (Path Abs Dir)
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> (FilePath -> IO (Path Abs Dir)) -> FilePath -> m (Path Abs Dir)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir
      makeAbsolute :: forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute = (FilePath -> IO FilePath) -> Path b Dir -> m FilePath
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO FilePath
    D.makeAbsolute (Path b Dir -> m FilePath)
    -> (FilePath -> m (Path Abs Dir)) -> Path b Dir -> m (Path Abs Dir)
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> (FilePath -> IO (Path Abs Dir)) -> FilePath -> m (Path Abs Dir)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir
      makeRelative :: forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path b Dir -> m (RelPath (Path b Dir))
    makeRelative Path Abs Dir
    b Path b Dir
    p = FilePath -> m (Path Rel Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Rel Dir)
    parseRelDir (FilePath -> FilePath -> FilePath
    F.makeRelative (Path Abs Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path Abs Dir
    b) (Path b Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path b Dir
    p))
      makeRelativeToCurrentDir :: forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (RelPath (Path b Dir))
    makeRelativeToCurrentDir Path b Dir
    p = IO (RelPath (Path b Dir)) -> m (RelPath (Path b Dir))
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (RelPath (Path b Dir)) -> m (RelPath (Path b Dir)))
    -> IO (RelPath (Path b Dir)) -> m (RelPath (Path b Dir))
    forall a b. (a -> b) -> a -> b
    $ IO (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getCurrentDir IO (Path Abs Dir)
    -> (Path Abs Dir -> IO (Path Rel Dir)) -> IO (Path Rel Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Path Abs Dir -> Path b Dir -> IO (Path Rel Dir))
    -> Path b Dir -> Path Abs Dir -> IO (Path Rel Dir)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Path Abs Dir -> Path b Dir -> IO (Path Rel Dir)
    Path Abs Dir -> Path b Dir -> IO (RelPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadThrow m) =>
    Path Abs Dir -> path -> m (RelPath path)
    forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path b Dir -> m (RelPath (Path b Dir))
    makeRelative Path b Dir
    p

    -- | @since 1.8.0
    instance AnyPath (SomeBase File) where
      type AbsPath (SomeBase File) = Path Abs File
      type RelPath (SomeBase File) = Path Rel File

      canonicalizePath :: forall (m :: * -> *).
    MonadIO m =>
    SomeBase File -> m (AbsPath (SomeBase File))
    canonicalizePath SomeBase File
    s = case SomeBase File
    s of
        Abs Path Abs File
    a -> Path Abs File -> m (AbsPath (Path Abs File))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs File -> m (AbsPath (Path Abs File))
    canonicalizePath Path Abs File
    a
        Rel Path Rel File
    a -> Path Rel File -> m (AbsPath (Path Rel File))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Rel File -> m (AbsPath (Path Rel File))
    canonicalizePath Path Rel File
    a

      makeAbsolute :: forall (m :: * -> *).
    MonadIO m =>
    SomeBase File -> m (AbsPath (SomeBase File))
    makeAbsolute SomeBase File
    s = case SomeBase File
    s of
        Abs Path Abs File
    a -> Path Abs File -> m (AbsPath (Path Abs File))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs File -> m (AbsPath (Path Abs File))
    makeAbsolute Path Abs File
    a
        Rel Path Rel File
    a -> Path Rel File -> m (AbsPath (Path Rel File))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Rel File -> m (AbsPath (Path Rel File))
    makeAbsolute Path Rel File
    a

      makeRelative :: forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> SomeBase File -> m (RelPath (SomeBase File))
    makeRelative Path Abs Dir
    r SomeBase File
    s = case SomeBase File
    s of
        Abs Path Abs File
    a -> Path Abs Dir -> Path Abs File -> m (RelPath (Path Abs File))
    forall path (m :: * -> *).
    (AnyPath path, MonadThrow m) =>
    Path Abs Dir -> path -> m (RelPath path)
    forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path Abs File -> m (RelPath (Path Abs File))
    makeRelative Path Abs Dir
    r Path Abs File
    a
        Rel Path Rel File
    a -> Path Abs Dir -> Path Rel File -> m (RelPath (Path Rel File))
    forall path (m :: * -> *).
    (AnyPath path, MonadThrow m) =>
    Path Abs Dir -> path -> m (RelPath path)
    forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path Rel File -> m (RelPath (Path Rel File))
    makeRelative Path Abs Dir
    r Path Rel File
    a

      makeRelativeToCurrentDir :: forall (m :: * -> *).
    MonadIO m =>
    SomeBase File -> m (RelPath (SomeBase File))
    makeRelativeToCurrentDir SomeBase File
    s = case SomeBase File
    s of
        Abs Path Abs File
    a -> Path Abs File -> m (RelPath (Path Abs File))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (RelPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs File -> m (RelPath (Path Abs File))
    makeRelativeToCurrentDir Path Abs File
    a
        Rel Path Rel File
    a -> Path Rel File -> m (RelPath (Path Rel File))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (RelPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Rel File -> m (RelPath (Path Rel File))
    makeRelativeToCurrentDir Path Rel File
    a

    -- | @since 1.8.0
    instance AnyPath (SomeBase Dir) where
      type AbsPath (SomeBase Dir) = Path Abs Dir
      type RelPath (SomeBase Dir) = Path Rel Dir

      canonicalizePath :: forall (m :: * -> *).
    MonadIO m =>
    SomeBase Dir -> m (AbsPath (SomeBase Dir))
    canonicalizePath SomeBase Dir
    s = case SomeBase Dir
    s of
        Abs Path Abs Dir
    a -> Path Abs Dir -> m (AbsPath (Path Abs Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> m (AbsPath (Path Abs Dir))
    canonicalizePath Path Abs Dir
    a
        Rel Path Rel Dir
    a -> Path Rel Dir -> m (AbsPath (Path Rel Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Rel Dir -> m (AbsPath (Path Rel Dir))
    canonicalizePath Path Rel Dir
    a

      makeAbsolute :: forall (m :: * -> *).
    MonadIO m =>
    SomeBase Dir -> m (AbsPath (SomeBase Dir))
    makeAbsolute SomeBase Dir
    s = case SomeBase Dir
    s of
        Abs Path Abs Dir
    a -> Path Abs Dir -> m (AbsPath (Path Abs Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> m (AbsPath (Path Abs Dir))
    makeAbsolute Path Abs Dir
    a
        Rel Path Rel Dir
    a -> Path Rel Dir -> m (AbsPath (Path Rel Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Rel Dir -> m (AbsPath (Path Rel Dir))
    makeAbsolute Path Rel Dir
    a

      makeRelative :: forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> SomeBase Dir -> m (RelPath (SomeBase Dir))
    makeRelative Path Abs Dir
    r SomeBase Dir
    s = case SomeBase Dir
    s of
        Abs Path Abs Dir
    a -> Path Abs Dir -> Path Abs Dir -> m (RelPath (Path Abs Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadThrow m) =>
    Path Abs Dir -> path -> m (RelPath path)
    forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path Abs Dir -> m (RelPath (Path Abs Dir))
    makeRelative Path Abs Dir
    r Path Abs Dir
    a
        Rel Path Rel Dir
    a -> Path Abs Dir -> Path Rel Dir -> m (RelPath (Path Rel Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadThrow m) =>
    Path Abs Dir -> path -> m (RelPath path)
    forall (m :: * -> *).
    MonadThrow m =>
    Path Abs Dir -> Path Rel Dir -> m (RelPath (Path Rel Dir))
    makeRelative Path Abs Dir
    r Path Rel Dir
    a

      makeRelativeToCurrentDir :: forall (m :: * -> *).
    MonadIO m =>
    SomeBase Dir -> m (RelPath (SomeBase Dir))
    makeRelativeToCurrentDir SomeBase Dir
    s = case SomeBase Dir
    s of
        Abs Path Abs Dir
    a -> Path Abs Dir -> m (RelPath (Path Abs Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (RelPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> m (RelPath (Path Abs Dir))
    makeRelativeToCurrentDir Path Abs Dir
    a
        Rel Path Rel Dir
    a -> Path Rel Dir -> m (RelPath (Path Rel Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (RelPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path Rel Dir -> m (RelPath (Path Rel Dir))
    makeRelativeToCurrentDir Path Rel Dir
    a

    -- | Append stringly-typed path to an absolute path and then canonicalize
    -- it.
    --
    -- @since 0.3.0
    resolveFile ::
      (MonadIO m) =>
      -- | Base directory
      Path Abs Dir ->
      -- | Path to resolve
      FilePath ->
      m (Path Abs File)
    resolveFile :: forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> FilePath -> m (Path Abs File)
    resolveFile Path Abs Dir
    b FilePath
    p = IO (Path Abs File) -> m (Path Abs File)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs File) -> m (Path Abs File))
    -> IO (Path Abs File) -> m (Path Abs File)
    forall a b. (a -> b) -> a -> b
    $ FilePath -> IO FilePath
    D.canonicalizePath (Path Abs Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path Abs Dir
    b FilePath -> FilePath -> FilePath
    F.</> FilePath
    p) IO FilePath
    -> (FilePath -> IO (Path Abs File)) -> IO (Path Abs File)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs File)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
    parseAbsFile

    -- | The same as 'resolveFile', but uses current working directory.
    --
    -- @since 0.3.0
    resolveFile' ::
      (MonadIO m) =>
      -- | Path to resolve
      FilePath ->
      m (Path Abs File)
    resolveFile' :: forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs File)
    resolveFile' FilePath
    p = m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getCurrentDir m (Path Abs Dir)
    -> (Path Abs Dir -> m (Path Abs File)) -> m (Path Abs File)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Path Abs Dir -> FilePath -> m (Path Abs File))
    -> FilePath -> Path Abs Dir -> m (Path Abs File)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Path Abs Dir -> FilePath -> m (Path Abs File)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> FilePath -> m (Path Abs File)
    resolveFile FilePath
    p

    -- | The same as 'resolveFile', but for directories.
    --
    -- @since 0.3.0
    resolveDir ::
      (MonadIO m) =>
      -- | Base directory
      Path Abs Dir ->
      -- | Path to resolve
      FilePath ->
      m (Path Abs Dir)
    resolveDir :: forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> FilePath -> m (Path Abs Dir)
    resolveDir Path Abs Dir
    b FilePath
    p = IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a b. (a -> b) -> a -> b
    $ FilePath -> IO FilePath
    D.canonicalizePath (Path Abs Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path Abs Dir
    b FilePath -> FilePath -> FilePath
    F.</> FilePath
    p) IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir

    -- | The same as 'resolveDir', but uses current working directory.
    --
    -- @since 0.3.0
    resolveDir' ::
      (MonadIO m) =>
      -- | Path to resolve
      FilePath ->
      m (Path Abs Dir)
    resolveDir' :: forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
    resolveDir' FilePath
    p = m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getCurrentDir m (Path Abs Dir)
    -> (Path Abs Dir -> m (Path Abs Dir)) -> m (Path Abs Dir)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Path Abs Dir -> FilePath -> m (Path Abs Dir))
    -> FilePath -> Path Abs Dir -> m (Path Abs Dir)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Path Abs Dir -> FilePath -> m (Path Abs Dir)
    forall (m :: * -> *).
    MonadIO m =>
    Path Abs Dir -> FilePath -> m (Path Abs Dir)
    resolveDir FilePath
    p

    ----------------------------------------------------------------------------
    -- Actions on files

    -- | @'removeFile' file@ removes the directory entry for an existing file
    -- @file@, where @file@ is not itself a directory. The implementation may
    -- specify additional constraints which must be satisfied before a file can
    -- be removed (e.g. the file may not be in use by other processes).
    --
    -- The operation may fail with:
    --
    -- * 'HardwareFault'
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * 'InvalidArgument'
    -- The operand is not a valid file name.
    -- @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'isDoesNotExistError' \/ 'NoSuchThing'
    -- The file does not exist.
    -- @[ENOENT, ENOTDIR]@
    --
    -- * 'isPermissionError' \/ 'PermissionDenied'
    -- The process has insufficient privileges to perform the operation.
    -- @[EROFS, EACCES, EPERM]@
    --
    -- * 'UnsatisfiedConstraints'
    -- Implementation-dependent constraints are not satisfied.
    -- @[EBUSY]@
    --
    -- * 'InappropriateType'
    -- The operand refers to an existing directory.
    -- @[EPERM, EINVAL]@
    removeFile :: (MonadIO m) => Path b File -> m ()
    removeFile :: forall (m :: * -> *) b. MonadIO m => Path b File -> m ()
    removeFile = (FilePath -> IO ()) -> Path b File -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.removeFile

    -- | @'renameFile' old new@ changes the name of an existing file system
    -- object from /old/ to /new/. If the /new/ object already exists, it is
    -- atomically replaced by the /old/ object. Neither path may refer to an
    -- existing directory. A conformant implementation need not support renaming
    -- files in all situations (e.g. renaming across different physical
    -- devices), but the constraints must be documented.
    --
    -- The operation may fail with:
    --
    -- * 'HardwareFault'
    -- A physical I\/O error has occurred.
    -- @[EIO]@
    --
    -- * 'InvalidArgument'
    -- Either operand is not a valid file name.
    -- @[ENAMETOOLONG, ELOOP]@
    --
    -- * 'isDoesNotExistError' \/ 'NoSuchThing'
    -- The original file does not exist, or there is no path to the target.
    -- @[ENOENT, ENOTDIR]@
    --
    -- * 'isPermissionError' \/ 'PermissionDenied'
    -- The process has insufficient privileges to perform the operation.
    -- @[EROFS, EACCES, EPERM]@
    --
    -- * 'ResourceExhausted'
    -- Insufficient resources are available to perform the operation.
    -- @[EDQUOT, ENOSPC, ENOMEM, EMLINK]@
    --
    -- * 'UnsatisfiedConstraints'
    -- Implementation-dependent constraints are not satisfied.
    -- @[EBUSY]@
    --
    -- * 'UnsupportedOperation'
    -- The implementation does not support renaming in this situation.
    -- @[EXDEV]@
    --
    -- * 'InappropriateType'
    -- Either path refers to an existing directory.
    -- @[ENOTDIR, EISDIR, EINVAL, EEXIST, ENOTEMPTY]@
    renameFile ::
      (MonadIO m) =>
      -- | Original location
      Path b0 File ->
      -- | New location
      Path b1 File ->
      m ()
    renameFile :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 File -> Path b1 File -> m ()
    renameFile = (FilePath -> FilePath -> IO ())
    -> Path b0 File -> Path b1 File -> m ()
    forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO ()
    D.renameFile

    -- | @'copyFile' old new@ copies the existing file from @old@ to @new@. If
    -- the @new@ file already exists, it is atomically replaced by the @old@
    -- file. Neither path may refer to an existing directory. The permissions of
    -- @old@ are copied to @new@, if possible.
    copyFile ::
      (MonadIO m) =>
      -- | Original location
      Path b0 File ->
      -- | Where to put copy
      Path b1 File ->
      m ()
    copyFile :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 File -> Path b1 File -> m ()
    copyFile = (FilePath -> FilePath -> IO ())
    -> Path b0 File -> Path b1 File -> m ()
    forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO ()
    D.copyFile

    -- | Obtain the size of a file in bytes.
    --
    -- @since 1.7.0
    getFileSize :: (MonadIO m) => Path b File -> m Integer
    getFileSize :: forall (m :: * -> *) b. MonadIO m => Path b File -> m Integer
    getFileSize = (FilePath -> IO Integer) -> Path b File -> m Integer
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO Integer
    D.getFileSize

    -- | Given an executable file name, search for such file in the directories
    -- listed in system @PATH@. The returned value is the path to the found
    -- executable or 'Nothing' if an executable with the given name was not
    -- found. For example ('findExecutable' \"ghc\") gives you the path to GHC.
    --
    -- The path returned by 'findExecutable' corresponds to the program that
    -- would be executed by 'System.Process.createProcess' when passed the same
    -- string (as a RawCommand, not a ShellCommand).
    --
    -- On Windows, 'findExecutable' calls the Win32 function 'SearchPath', which
    -- may search other places before checking the directories in @PATH@. Where
    -- it actually searches depends on registry settings, but notably includes
    -- the directory containing the current executable. See
    -- <http://msdn.microsoft.com/en-us/library/aa365527.aspx> for more details.
    findExecutable ::
      (MonadIO m) =>
      -- | Executable file name
      Path Rel File ->
      -- | Path to found executable
      m (Maybe (Path Abs File))
    findExecutable :: forall (m :: * -> *).
    MonadIO m =>
    Path Rel File -> m (Maybe (Path Abs File))
    findExecutable = (Maybe FilePath -> Maybe (Path Abs File))
    -> m (Maybe FilePath) -> m (Maybe (Path Abs File))
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Maybe FilePath
    -> (FilePath -> Maybe (Path Abs File)) -> Maybe (Path Abs File)
    forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> Maybe (Path Abs File)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
    parseAbsFile) (m (Maybe FilePath) -> m (Maybe (Path Abs File)))
    -> (Path Rel File -> m (Maybe FilePath))
    -> Path Rel File
    -> m (Maybe (Path Abs File))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (FilePath -> IO (Maybe FilePath))
    -> Path Rel File -> m (Maybe FilePath)
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO (Maybe FilePath)
    D.findExecutable

    -- | Search through the given set of directories for the given file.
    findFile ::
      (MonadIO m) =>
      -- | Set of directories to search in
      [Path b Dir] ->
      -- | Filename of interest
      Path Rel File ->
      -- | Absolute path to file (if found)
      m (Maybe (Path Abs File))
    findFile :: forall (m :: * -> *) b.
    MonadIO m =>
    [Path b Dir] -> Path Rel File -> m (Maybe (Path Abs File))
    findFile [] Path Rel File
    _ = Maybe (Path Abs File) -> m (Maybe (Path Abs File))
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Path Abs File)
    forall a. Maybe a
    Nothing
    findFile (Path b Dir
    d : [Path b Dir]
    ds) Path Rel File
    file = do
      bfile <- (Path Abs Dir -> Path Rel File -> Path Abs File
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </> Path Rel File
    file) (Path Abs Dir -> Path Abs File)
    -> m (Path Abs Dir) -> m (Path Abs File)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    d
      exist <- doesFileExist bfile
      if exist
        then return (Just bfile)
        else findFile ds file

    -- | Search through the given set of directories for the given file and
    -- return a list of paths where the given file exists.
    findFiles ::
      (MonadIO m) =>
      -- | Set of directories to search in
      [Path b Dir] ->
      -- | Filename of interest
      Path Rel File ->
      -- | Absolute paths to all found files
      m [Path Abs File]
    findFiles :: forall (m :: * -> *) b.
    MonadIO m =>
    [Path b Dir] -> Path Rel File -> m [Path Abs File]
    findFiles = (Path Abs File -> m Bool)
    -> [Path b Dir] -> Path Rel File -> m [Path Abs File]
    forall (m :: * -> *) b.
    MonadIO m =>
    (Path Abs File -> m Bool)
    -> [Path b Dir] -> Path Rel File -> m [Path Abs File]
    findFilesWith (m Bool -> Path Abs File -> m Bool
    forall a b. a -> b -> a
    const (Bool -> m Bool
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    True))

    -- | Search through the given set of directories for the given file and with
    -- the given property (usually permissions) and return a list of paths where
    -- the given file exists and has the property.
    findFilesWith ::
      (MonadIO m) =>
      -- | How to test the files
      (Path Abs File -> m Bool) ->
      -- | Set of directories to search in
      [Path b Dir] ->
      -- | Filename of interest
      Path Rel File ->
      -- | Absolute paths to all found files
      m [Path Abs File]
    findFilesWith :: forall (m :: * -> *) b.
    MonadIO m =>
    (Path Abs File -> m Bool)
    -> [Path b Dir] -> Path Rel File -> m [Path Abs File]
    findFilesWith Path Abs File -> m Bool
    _ [] Path Rel File
    _ = [Path Abs File] -> m [Path Abs File]
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
    findFilesWith Path Abs File -> m Bool
    f (Path b Dir
    d : [Path b Dir]
    ds) Path Rel File
    file = do
      bfile <- (Path Abs Dir -> Path Rel File -> Path Abs File
    forall b t. Path b Dir -> Path Rel t -> Path b t
    </> Path Rel File
    file) (Path Abs Dir -> Path Abs File)
    -> m (Path Abs Dir) -> m (Path Abs File)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    d
      exist <- doesFileExist bfile
      b <- if exist then f bfile else return False
      if b
        then (bfile :) <$> findFilesWith f ds file
        else findFilesWith f ds file

    ----------------------------------------------------------------------------
    -- Symbolic links

    -- | Create a /file/ symbolic link. The target path can be either absolute
    -- or relative and need not refer to an existing file. The order of
    -- arguments follows the POSIX convention.
    --
    -- To remove an existing file symbolic link, use 'removeFile'.
    --
    -- Although the distinction between /file/ symbolic links and /directory/
    -- symbolic links does not exist on POSIX systems, on Windows this is an
    -- intrinsic property of every symbolic link and cannot be changed without
    -- recreating the link. A file symbolic link that actually points to a
    -- directory will fail to dereference and vice versa. Moreover, creating
    -- symbolic links on Windows may require privileges unavailable to users
    -- outside the Administrators group. Portable programs that use symbolic
    -- links should take both into consideration.
    --
    -- On Windows, the function is implemented using @CreateSymbolicLink@. Since
    -- 1.3.3.0, the @SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE@ flag is
    -- included if supported by the operating system. On POSIX, the function
    -- uses @symlink@ and is therefore atomic.
    --
    -- Windows-specific errors: This operation may fail with
    -- 'System.IO.Error.permissionErrorType' if the user lacks the privileges to
    -- create symbolic links. It may also fail with
    -- 'System.IO.Error.illegalOperationErrorType' if the file system does not
    -- support symbolic links.
    --
    -- @since 1.5.0
    createFileLink ::
      (MonadIO m) =>
      -- | Path to the target file
      Path b0 File ->
      -- | Path to the link to be created
      Path b1 File ->
      m ()
    createFileLink :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 File -> Path b1 File -> m ()
    createFileLink = (FilePath -> FilePath -> IO ())
    -> Path b0 File -> Path b1 File -> m ()
    forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO ()
    D.createFileLink

    -- | Create a /directory/ symbolic link. The target path can be either
    -- absolute or relative and need not refer to an existing directory. The
    -- order of arguments follows the POSIX convention.
    --
    -- To remove an existing directory symbolic link, use 'removeDirLink'.
    --
    -- Although the distinction between /file/ symbolic links and /directory/
    -- symbolic links does not exist on POSIX systems, on Windows this is an
    -- intrinsic property of every symbolic link and cannot be changed without
    -- recreating the link. A file symbolic link that actually points to a
    -- directory will fail to dereference and vice versa. Moreover, creating
    -- symbolic links on Windows may require privileges unavailable to users
    -- outside the Administrators group. Portable programs that use symbolic
    -- links should take both into consideration.
    --
    -- On Windows, the function is implemented using @CreateSymbolicLink@ with
    -- @SYMBOLIC_LINK_FLAG_DIRECTORY@. Since 1.3.3.0, the
    -- @SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE@ flag is also included if
    -- supported by the operating system. On POSIX, this is an alias for
    -- 'createFileLink' and is therefore atomic.
    --
    -- Windows-specific errors: This operation may fail with
    -- 'System.IO.Error.permissionErrorType' if the user lacks the privileges to
    -- create symbolic links. It may also fail with
    -- 'System.IO.Error.illegalOperationErrorType' if the file system does not
    -- support symbolic links.
    --
    -- @since 1.5.0
    createDirLink ::
      (MonadIO m) =>
      -- | Path to the target directory
      Path b0 Dir ->
      -- | Path to the link to be created
      Path b1 Dir ->
      m ()
    createDirLink :: forall (m :: * -> *) b0 b1.
    MonadIO m =>
    Path b0 Dir -> Path b1 Dir -> m ()
    createDirLink Path b0 Dir
    target' Path b1 Dir
    dest' = do
      let target :: FilePath
    target = Path b0 Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path b0 Dir
    target'
          dest :: FilePath
    dest = Path b1 Dir -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath' Path b1 Dir
    dest'
      IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FilePath -> FilePath -> IO ()
    D.createDirectoryLink FilePath
    target FilePath
    dest

    -- | Remove an existing /directory/ symbolic link.
    --
    -- On Windows, this is an alias for 'removeDir'. On POSIX systems, this is
    -- an alias for 'removeFile'.
    --
    -- See also: 'removeFile', which can remove an existing /file/ symbolic link.
    --
    -- @since 1.5.0
    removeDirLink ::
      (MonadIO m) =>
      -- | Path to the link to be removed
      Path b Dir ->
      m ()
    removeDirLink :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
    removeDirLink = (FilePath -> IO ()) -> Path b Dir -> m ()
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO ()
    D.removeDirectoryLink

    -- | Retrieve the target path of either a file or directory symbolic link.
    -- The returned path may not exist, and may not even be a valid path.
    --
    -- On Windows systems, this calls @DeviceIoControl@ with
    -- @FSCTL_GET_REPARSE_POINT@. In addition to symbolic links, the function
    -- also works on junction points. On POSIX systems, this calls @readlink@.
    --
    -- Windows-specific errors: This operation may fail with
    -- 'System.IO.Error.illegalOperationErrorType' if the file system does not
    -- support symbolic links.
    --
    -- @since 1.5.0
    getSymlinkTarget ::
      (MonadIO m) =>
      -- | Symlink path
      Path b t ->
      m FilePath
    getSymlinkTarget :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m FilePath
    getSymlinkTarget = (FilePath -> IO FilePath) -> Path b t -> m FilePath
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO FilePath
    D.getSymbolicLinkTarget

    -- | Check whether the path refers to a symbolic link.  An exception is thrown
    -- if the path does not exist or is inaccessible.
    --
    -- On Windows, this checks for @FILE_ATTRIBUTE_REPARSE_POINT@.  In addition to
    -- symbolic links, the function also returns true on junction points.  On
    -- POSIX systems, this checks for @S_IFLNK@.
    --
    -- @since 1.5.0

    -- | Check if the given path is a symbolic link.
    --
    -- @since 1.3.0
    isSymlink :: (MonadIO m) => Path b t -> m Bool
    isSymlink :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
    isSymlink = (FilePath -> IO Bool) -> Path b t -> m Bool
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO Bool
    D.pathIsSymbolicLink

    ----------------------------------------------------------------------------
    -- Temporary files and directories

    -- | Use a temporary file that doesn't already exist.
    --
    -- Creates a new temporary file inside the given directory, making use of
    -- the template. The temporary file is deleted after use.
    --
    -- @since 0.2.0
    withTempFile ::
      (MonadIO m, MonadMask m) =>
      -- | Directory to create the file in
      Path b Dir ->
      -- | File name template, see 'openTempFile'
      String ->
      -- | Callback that can use the file
      (Path Abs File -> Handle -> m a) ->
      m a
    withTempFile :: forall (m :: * -> *) b a.
    (MonadIO m, MonadMask m) =>
    Path b Dir -> FilePath -> (Path Abs File -> Handle -> m a) -> m a
    withTempFile Path b Dir
    path FilePath
    t Path Abs File -> Handle -> m a
    action = do
      apath <- Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    path
      T.withTempFile (toFilePath apath) t $ \FilePath
    file Handle
    h ->
        FilePath -> m (Path Abs File)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
    parseAbsFile FilePath
    file m (Path Abs File) -> (Path Abs File -> m a) -> m a
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Path Abs File -> Handle -> m a) -> Handle -> Path Abs File -> m a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Path Abs File -> Handle -> m a
    action Handle
    h

    -- | Create and use a temporary directory.
    --
    -- Creates a new temporary directory inside the given directory, making use
    -- of the template. The temporary directory is deleted after use.
    --
    -- @since 0.2.0
    withTempDir ::
      (MonadIO m, MonadMask m) =>
      -- | Directory to create the file in
      Path b Dir ->
      -- | Directory name template, see 'openTempFile'
      String ->
      -- | Callback that can use the directory
      (Path Abs Dir -> m a) ->
      m a
    withTempDir :: forall (m :: * -> *) b a.
    (MonadIO m, MonadMask m) =>
    Path b Dir -> FilePath -> (Path Abs Dir -> m a) -> m a
    withTempDir Path b Dir
    path FilePath
    t Path Abs Dir -> m a
    action = do
      apath <- Path b Dir -> m (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    path
      T.withTempDirectory (toFilePath apath) t (parseAbsDir >=> action)

    -- | Create and use a temporary file in the system standard temporary
    -- directory.
    --
    -- Behaves exactly the same as 'withTempFile', except that the parent
    -- temporary directory will be that returned by 'getTempDir'.
    --
    -- @since 0.2.0
    withSystemTempFile ::
      (MonadIO m, MonadMask m) =>
      -- | File name template, see 'openTempFile'
      String ->
      -- | Callback that can use the file
      (Path Abs File -> Handle -> m a) ->
      m a
    withSystemTempFile :: forall (m :: * -> *) a.
    (MonadIO m, MonadMask m) =>
    FilePath -> (Path Abs File -> Handle -> m a) -> m a
    withSystemTempFile FilePath
    t Path Abs File -> Handle -> m a
    action =
      m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getTempDir m (Path Abs Dir) -> (Path Abs Dir -> m a) -> m a
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Path Abs Dir
    path ->
        Path Abs Dir -> FilePath -> (Path Abs File -> Handle -> m a) -> m a
    forall (m :: * -> *) b a.
    (MonadIO m, MonadMask m) =>
    Path b Dir -> FilePath -> (Path Abs File -> Handle -> m a) -> m a
    withTempFile Path Abs Dir
    path FilePath
    t Path Abs File -> Handle -> m a
    action

    -- | Create and use a temporary directory in the system standard temporary
    -- directory.
    --
    -- Behaves exactly the same as 'withTempDir', except that the parent
    -- temporary directory will be that returned by 'getTempDir'.
    --
    -- @since 0.2.0
    withSystemTempDir ::
      (MonadIO m, MonadMask m) =>
      -- | Directory name template, see 'openTempFile'
      String ->
      -- | Callback that can use the directory
      (Path Abs Dir -> m a) ->
      m a
    withSystemTempDir :: forall (m :: * -> *) a.
    (MonadIO m, MonadMask m) =>
    FilePath -> (Path Abs Dir -> m a) -> m a
    withSystemTempDir FilePath
    t Path Abs Dir -> m a
    action =
      m (Path Abs Dir)
    forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
    getTempDir m (Path Abs Dir) -> (Path Abs Dir -> m a) -> m a
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Path Abs Dir
    path ->
        Path Abs Dir -> FilePath -> (Path Abs Dir -> m a) -> m a
    forall (m :: * -> *) b a.
    (MonadIO m, MonadMask m) =>
    Path b Dir -> FilePath -> (Path Abs Dir -> m a) -> m a
    withTempDir Path Abs Dir
    path FilePath
    t Path Abs Dir -> m a
    action

    -- | The function creates a temporary file in @rw@ mode. The created file
    -- isn't deleted automatically, so you need to delete it manually.
    --
    -- The file is created with permissions such that only the current user can
    -- read\/write it.
    --
    -- With some exceptions (see below), the file will be created securely in
    -- the sense that an attacker should not be able to cause openTempFile to
    -- overwrite another file on the filesystem using your credentials, by
    -- putting symbolic links (on Unix) in the place where the temporary file is
    -- to be created. On Unix the @O_CREAT@ and @O_EXCL@ flags are used to
    -- prevent this attack, but note that @O_EXCL@ is sometimes not supported on
    -- NFS filesystems, so if you rely on this behaviour it is best to use local
    -- filesystems only.
    --
    -- @since 0.2.0
    openTempFile ::
      (MonadIO m) =>
      -- | Directory to create file in
      Path b Dir ->
      -- | File name template; if the template is "foo.ext" then the created
      -- file will be @\"fooXXX.ext\"@ where @XXX@ is some random number
      String ->
      -- | Name of created file and its 'Handle'
      m (Path Abs File, Handle)
    openTempFile :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> FilePath -> m (Path Abs File, Handle)
    openTempFile Path b Dir
    path FilePath
    t = IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs File, Handle) -> m (Path Abs File, Handle))
    -> IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
    forall a b. (a -> b) -> a -> b
    $ do
      apath <- Path b Dir -> IO (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    path
      (tfile, h) <- liftD2' T.openTempFile apath t
      (,h) <$> parseAbsFile tfile

    -- | Like 'openTempFile', but opens the file in binary mode. On Windows,
    -- reading a file in text mode (which is the default) will translate @CRLF@
    -- to @LF@, and writing will translate @LF@ to @CRLF@. This is usually what
    -- you want with text files. With binary files this is undesirable; also, as
    -- usual under Microsoft operating systems, text mode treats control-Z as
    -- EOF. Binary mode turns off all special treatment of end-of-line and
    -- end-of-file characters.
    --
    -- @since 0.2.0
    openBinaryTempFile ::
      (MonadIO m) =>
      -- | Directory to create file in
      Path b Dir ->
      -- | File name template, see 'openTempFile'
      String ->
      -- | Name of created file and its 'Handle'
      m (Path Abs File, Handle)
    openBinaryTempFile :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> FilePath -> m (Path Abs File, Handle)
    openBinaryTempFile Path b Dir
    path FilePath
    t = IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs File, Handle) -> m (Path Abs File, Handle))
    -> IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
    forall a b. (a -> b) -> a -> b
    $ do
      apath <- Path b Dir -> IO (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    path
      (tfile, h) <- liftD2' T.openBinaryTempFile apath t
      (,h) <$> parseAbsFile tfile

    -- | Create a temporary directory. The created directory isn't deleted
    -- automatically, so you need to delete it manually.
    --
    -- The directory is created with permissions such that only the current user
    -- can read\/write it.
    --
    -- @since 0.2.0
    createTempDir ::
      (MonadIO m) =>
      -- | Directory to create file in
      Path b Dir ->
      -- | Directory name template, see 'openTempFile'
      String ->
      -- | Name of created temporary directory
      m (Path Abs Dir)
    createTempDir :: forall (m :: * -> *) b.
    MonadIO m =>
    Path b Dir -> FilePath -> m (Path Abs Dir)
    createTempDir Path b Dir
    path FilePath
    t =
      IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
    -> IO (Path Abs Dir) -> m (Path Abs Dir)
    forall a b. (a -> b) -> a -> b
    $
        Path b Dir -> IO (AbsPath (Path b Dir))
    forall path (m :: * -> *).
    (AnyPath path, MonadIO m) =>
    path -> m (AbsPath path)
    forall (m :: * -> *).
    MonadIO m =>
    Path b Dir -> m (AbsPath (Path b Dir))
    makeAbsolute Path b Dir
    path IO (Path Abs Dir)
    -> (Path Abs Dir -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Path Abs Dir
    apath ->
          (FilePath -> FilePath -> IO FilePath)
    -> Path Abs Dir -> FilePath -> IO FilePath
    forall (m :: * -> *) v a b t.
    MonadIO m =>
    (FilePath -> v -> IO a) -> Path b t -> v -> m a
    liftD2' FilePath -> FilePath -> IO FilePath
    T.createTempDirectory Path Abs Dir
    apath FilePath
    t IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FilePath -> IO (Path Abs Dir)
    forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
    parseAbsDir

    ----------------------------------------------------------------------------
    -- Existence tests

    -- | Test whether the given path points to an existing filesystem object. If
    -- the user lacks necessary permissions to search the parent directories,
    -- this function may return false even if the file does actually exist.
    --
    -- @since 1.7.0
    doesPathExist :: (MonadIO m) => Path b t -> m Bool
    doesPathExist :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
    doesPathExist = (FilePath -> IO Bool) -> Path b t -> m Bool
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO Bool
    D.doesPathExist

    -- | The operation 'doesFileExist' returns 'True' if the argument file
    -- exists and is not a directory, and 'False' otherwise.
    doesFileExist :: (MonadIO m) => Path b File -> m Bool
    doesFileExist :: forall (m :: * -> *) b. MonadIO m => Path b File -> m Bool
    doesFileExist = (FilePath -> IO Bool) -> Path b File -> m Bool
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO Bool
    D.doesFileExist

    -- | The operation 'doesDirExist' returns 'True' if the argument file exists
    -- and is either a directory or a symbolic link to a directory, and 'False'
    -- otherwise.
    doesDirExist :: (MonadIO m) => Path b Dir -> m Bool
    doesDirExist :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m Bool
    doesDirExist = (FilePath -> IO Bool) -> Path b Dir -> m Bool
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO Bool
    D.doesDirectoryExist

    -- | Check if there is a file or directory on specified path.
    isLocationOccupied :: (MonadIO m) => Path b t -> m Bool
    isLocationOccupied :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
    isLocationOccupied Path b t
    path = do
      let fp :: FilePath
    fp = Path b t -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath Path b t
    path
      file <- IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> IO Bool
    D.doesFileExist FilePath
    fp)
      dir <- liftIO (D.doesDirectoryExist fp)
      return (file || dir)

    -- | If argument of the function throws a
    -- 'System.IO.Error.doesNotExistErrorType', 'Nothing' is returned (other
    -- exceptions propagate). Otherwise the result is returned inside a 'Just'.
    --
    -- @since 0.3.0
    forgivingAbsence :: (MonadIO m, MonadCatch m) => m a -> m (Maybe a)
    forgivingAbsence :: forall (m :: * -> *) a.
    (MonadIO m, MonadCatch m) =>
    m a -> m (Maybe a)
    forgivingAbsence m a
    f =
      (IOError -> Bool)
    -> m (Maybe a) -> (IOError -> m (Maybe a)) -> m (Maybe a)
    forall (m :: * -> *) e a.
    (HasCallStack, MonadCatch m, Exception e) =>
    (e -> Bool) -> m a -> (e -> m a) -> m a
    catchIf
        IOError -> Bool
    isDoesNotExistError
        (a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> m a -> m (Maybe a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a
    f)
        (m (Maybe a) -> IOError -> m (Maybe a)
    forall a b. a -> b -> a
    const (m (Maybe a) -> IOError -> m (Maybe a))
    -> m (Maybe a) -> IOError -> m (Maybe a)
    forall a b. (a -> b) -> a -> b
    $ Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe a
    forall a. Maybe a
    Nothing)

    -- | The same as 'forgivingAbsence', but ignores result.
    --
    -- @since 0.3.1
    ignoringAbsence :: (MonadIO m, MonadCatch m) => m a -> m ()
    ignoringAbsence :: forall (m :: * -> *) a. (MonadIO m, MonadCatch m) => m a -> m ()
    ignoringAbsence = m (Maybe a) -> m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (m (Maybe a) -> m ()) -> (m a -> m (Maybe a)) -> m a -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m a -> m (Maybe a)
    forall (m :: * -> *) a.
    (MonadIO m, MonadCatch m) =>
    m a -> m (Maybe a)
    forgivingAbsence

    ----------------------------------------------------------------------------
    -- Permissions

    -- | The 'getPermissions' operation returns the permissions for the file or
    -- directory.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' if the user is not permitted to access
    --   the permissions; or
    --
    -- * 'isDoesNotExistError' if the file or directory does not exist.
    getPermissions :: (MonadIO m) => Path b t -> m D.Permissions
    getPermissions :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Permissions
    getPermissions = (FilePath -> IO Permissions) -> Path b t -> m Permissions
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO Permissions
    D.getPermissions

    -- | The 'setPermissions' operation sets the permissions for the file or
    -- directory.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' if the user is not permitted to set
    --   the permissions; or
    --
    -- * 'isDoesNotExistError' if the file or directory does not exist.
    setPermissions :: (MonadIO m) => Path b t -> D.Permissions -> m ()
    setPermissions :: forall (m :: * -> *) b t.
    MonadIO m =>
    Path b t -> Permissions -> m ()
    setPermissions = (FilePath -> Permissions -> IO ())
    -> Path b t -> Permissions -> m ()
    forall (m :: * -> *) v a b t.
    MonadIO m =>
    (FilePath -> v -> IO a) -> Path b t -> v -> m a
    liftD2' FilePath -> Permissions -> IO ()
    D.setPermissions

    -- | Set permissions for the object found on second given path so they match
    -- permissions of the object on the first path.
    copyPermissions ::
      (MonadIO m) =>
      -- | From where to copy
      Path b0 t0 ->
      -- | What to modify
      Path b1 t1 ->
      m ()
    copyPermissions :: forall (m :: * -> *) b0 t0 b1 t1.
    MonadIO m =>
    Path b0 t0 -> Path b1 t1 -> m ()
    copyPermissions = (FilePath -> FilePath -> IO ()) -> Path b0 t0 -> Path b1 t1 -> m ()
    forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO ()
    D.copyPermissions

    ----------------------------------------------------------------------------
    -- Timestamps

    -- | Obtain the time at which the file or directory was last accessed.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' if the user is not permitted to read
    --   the access time; or
    --
    -- * 'isDoesNotExistError' if the file or directory does not exist.
    --
    -- Caveat for POSIX systems: This function returns a timestamp with
    -- sub-second resolution only if this package is compiled against
    -- @unix-2.6.0.0@ or later and the underlying filesystem supports them.
    --
    -- Note: this is a piece of conditional API, only available if
    -- @directory-1.2.3.0@ or later is used.
    getAccessTime :: (MonadIO m) => Path b t -> m UTCTime
    getAccessTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m UTCTime
    getAccessTime = (FilePath -> IO UTCTime) -> Path b t -> m UTCTime
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO UTCTime
    D.getAccessTime

    -- | Change the time at which the file or directory was last accessed.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' if the user is not permitted to alter the
    --   access time; or
    --
    -- * 'isDoesNotExistError' if the file or directory does not exist.
    --
    -- Some caveats for POSIX systems:
    --
    -- * Not all systems support @utimensat@, in which case the function can
    --   only emulate the behavior by reading the modification time and then
    --   setting both the access and modification times together. On systems
    --   where @utimensat@ is supported, the access time is set atomically with
    --   nanosecond precision.
    --
    -- * If compiled against a version of @unix@ prior to @2.7.0.0@, the
    --   function would not be able to set timestamps with sub-second
    --   resolution. In this case, there would also be loss of precision in the
    --   modification time.
    --
    -- Note: this is a piece of conditional API, only available if
    -- @directory-1.2.3.0@ or later is used.
    setAccessTime :: (MonadIO m) => Path b t -> UTCTime -> m ()
    setAccessTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> UTCTime -> m ()
    setAccessTime = (FilePath -> UTCTime -> IO ()) -> Path b t -> UTCTime -> m ()
    forall (m :: * -> *) v a b t.
    MonadIO m =>
    (FilePath -> v -> IO a) -> Path b t -> v -> m a
    liftD2' FilePath -> UTCTime -> IO ()
    D.setAccessTime

    -- | Change the time at which the file or directory was last modified.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' if the user is not permitted to alter the
    --   modification time; or
    --
    -- * 'isDoesNotExistError' if the file or directory does not exist.
    --
    -- Some caveats for POSIX systems:
    --
    -- * Not all systems support @utimensat@, in which case the function can
    --   only emulate the behavior by reading the access time and then setting
    --   both the access and modification times together. On systems where
    --   @utimensat@ is supported, the modification time is set atomically with
    --   nanosecond precision.
    --
    -- * If compiled against a version of @unix@ prior to @2.7.0.0@, the
    --   function would not be able to set timestamps with sub-second
    --   resolution. In this case, there would also be loss of precision in the
    --   access time.
    --
    -- Note: this is a piece of conditional API, only available if
    -- @directory-1.2.3.0@ or later is used.
    setModificationTime :: (MonadIO m) => Path b t -> UTCTime -> m ()
    setModificationTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> UTCTime -> m ()
    setModificationTime = (FilePath -> UTCTime -> IO ()) -> Path b t -> UTCTime -> m ()
    forall (m :: * -> *) v a b t.
    MonadIO m =>
    (FilePath -> v -> IO a) -> Path b t -> v -> m a
    liftD2' FilePath -> UTCTime -> IO ()
    D.setModificationTime

    -- | Obtain the time at which the file or directory was last modified.
    --
    -- The operation may fail with:
    --
    -- * 'isPermissionError' if the user is not permitted to read
    --   the modification time; or
    --
    -- * 'isDoesNotExistError' if the file or directory does not exist.
    --
    -- Caveat for POSIX systems: This function returns a timestamp with
    -- sub-second resolution only if this package is compiled against
    -- @unix-2.6.0.0@ or later and the underlying filesystem supports them.
    getModificationTime :: (MonadIO m) => Path b t -> m UTCTime
    getModificationTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m UTCTime
    getModificationTime = (FilePath -> IO UTCTime) -> Path b t -> m UTCTime
    forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO UTCTime
    D.getModificationTime

    ----------------------------------------------------------------------------
    -- Helpers

    -- | Lift an action in 'IO' that takes 'FilePath' into an action in slightly
    -- more abstract monad that takes 'Path'.
    liftD ::
      (MonadIO m) =>
      -- | Original action
      (FilePath -> IO a) ->
      -- | 'Path' argument
      Path b t ->
      -- | Lifted action
      m a
    liftD :: forall (m :: * -> *) a b t.
    MonadIO m =>
    (FilePath -> IO a) -> Path b t -> m a
    liftD FilePath -> IO a
    m = IO a -> m a
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO a -> m a) -> (Path b t -> IO a) -> Path b t -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO a
    m (FilePath -> IO a) -> (Path b t -> FilePath) -> Path b t -> IO a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Path b t -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath'
    {-# INLINE liftD #-}

    -- | Similar to 'liftD' but for functions with arity 2.
    liftD2 ::
      (MonadIO m) =>
      -- | Original action
      (FilePath -> FilePath -> IO a) ->
      -- | First 'Path' argument
      Path b0 t0 ->
      -- | Second 'Path' argument
      Path b1 t1 ->
      m a
    liftD2 :: forall (m :: * -> *) a b0 t0 b1 t1.
    MonadIO m =>
    (FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
    liftD2 FilePath -> FilePath -> IO a
    m Path b0 t0
    a Path b1 t1
    b = IO a -> m a
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO a -> m a) -> IO a -> m a
    forall a b. (a -> b) -> a -> b
    $ FilePath -> FilePath -> IO a
    m (Path b0 t0 -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath' Path b0 t0
    a) (Path b1 t1 -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath' Path b1 t1
    b)
    {-# INLINE liftD2 #-}

    -- | Similar to 'liftD2', but allows us to pass second argument of arbitrary
    -- type.
    liftD2' ::
      (MonadIO m) =>
      -- | Original action
      (FilePath -> v -> IO a) ->
      -- | First 'Path' argument
      Path b t ->
      -- | Second argument
      v ->
      m a
    liftD2' :: forall (m :: * -> *) v a b t.
    MonadIO m =>
    (FilePath -> v -> IO a) -> Path b t -> v -> m a
    liftD2' FilePath -> v -> IO a
    m Path b t
    a v
    v = IO a -> m a
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO a -> m a) -> IO a -> m a
    forall a b. (a -> b) -> a -> b
    $ FilePath -> v -> IO a
    m (Path b t -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath' Path b t
    a) v
    v
    {-# INLINE liftD2' #-}

    -- | Like 'toFilePath', but also drops the trailing path separator.
    toFilePath' :: Path b t -> FilePath
    toFilePath' :: forall b t. Path b t -> FilePath
    toFilePath' = FilePath -> FilePath
    F.dropTrailingPathSeparator (FilePath -> FilePath)
    -> (Path b t -> FilePath) -> Path b t -> FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Path b t -> FilePath
    forall b t. Path b t -> FilePath
    toFilePath

    -- | Perform an action ignoring IO exceptions it may throw.
    ignoringIOErrors :: IO () -> IO ()
    ignoringIOErrors :: IO () -> IO ()
    ignoringIOErrors IO ()
    ioe = IO ()
    ioe IO () -> (IOError -> IO ()) -> IO ()
    forall e a.
    (HasCallStack, Exception e) =>
    IO a -> (e -> IO a) -> IO a
    forall (m :: * -> *) e a.
    (MonadCatch m, HasCallStack, Exception e) =>
    m a -> (e -> m a) -> m a
    `catch` IOError -> IO ()
    forall (m :: * -> *). Monad m => IOError -> m ()
    handler
      where
        handler :: (Monad m) => IOError -> m ()
        handler :: forall (m :: * -> *). Monad m => IOError -> m ()
    handler = m () -> IOError -> m ()
    forall a b. a -> b -> a
    const (() -> m ()
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ())