module HaskellWorks.Polysemy.System.Directory
  ( D.XdgDirectory(..),
    D.XdgDirectoryList(..),

    -- * Actions on directories
    createDirectory,
    createDirectoryIfMissing,
    removeDirectory,
    removeDirectoryRecursive,
    removePathForcibly,
    renameDirectory,
    listDirectory,
    getDirectoryContents,

    -- ** Current working directory
    getCurrentDirectory,
    setCurrentDirectory,
    withCurrentDirectory,

    -- * Pre-defined directories
    getHomeDirectory,
    getXdgDirectory,
    getXdgDirectoryList,
    getAppUserDataDirectory,
    getUserDocumentsDirectory,
    getTemporaryDirectory,

    -- * Actions on files
    removeFile,
    renameFile,
    renamePath,
    copyFile,
    copyFileWithMetadata,
    getFileSize,

    canonicalizePath,
    makeAbsolute,
    makeRelativeToCurrentDirectory,

    -- * Existence tests
    doesPathExist,
    doesFileExist,
    doesDirectoryExist,

    findExecutable,
    findExecutables,
    findExecutablesInDirectories,
    findFile,
    findFiles,
    findFileWith,
    findFilesWith,
    D.exeExtension,

    -- * Symbolic links
    createFileLink,
    createDirectoryLink,
    removeDirectoryLink,
    pathIsSymbolicLink,
    getSymbolicLinkTarget,

    -- -- * 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,
    getModificationTime,
    setAccessTime,
    setModificationTime,

    -- -- * Deprecated
    --   isSymbolicLink,
  ) where

import qualified Control.Exception             as CE
import qualified GHC.Stack                     as GHC
import           HaskellWorks.Polysemy.Prelude

import           Data.Time.Clock               (UTCTime)
import           Polysemy
import           Polysemy.Error
import           Polysemy.Log
import           Polysemy.Resource
import qualified System.Directory              as D
import           System.Directory              (XdgDirectory (..),
                                                XdgDirectoryList (..))

createDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
createDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
createDirectory FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: createDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.createDirectory FilePath
fp)

createDirectoryIfMissing :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => Bool
  -> FilePath
  -> Sem r ()
createDirectoryIfMissing :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
Bool -> FilePath -> Sem r ()
createDirectoryIfMissing Bool
includeParents FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: createDirectoryIfMissing " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ Bool -> FilePath -> IO ()
D.createDirectoryIfMissing Bool
includeParents FilePath
fp)

removeDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
removeDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
removeDirectory FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: removeDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.removeDirectory FilePath
fp)

removeDirectoryRecursive :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
removeDirectoryRecursive :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
removeDirectoryRecursive FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: removeDirectoryRecursive " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.removeDirectoryRecursive FilePath
fp)

removePathForcibly :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
removePathForcibly :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
removePathForcibly FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: removePathForcibly " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.removePathForcibly FilePath
fp)

renameDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
renameDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
renameDirectory FilePath
old FilePath
new = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: renameDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
old Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
new

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.renameDirectory FilePath
old FilePath
new)

listDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r [FilePath]
listDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r [FilePath]
listDirectory FilePath
fp = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: listDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ FilePath -> IO [FilePath]
D.listDirectory FilePath
fp)

getDirectoryContents :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r [FilePath]
getDirectoryContents :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r [FilePath]
getDirectoryContents FilePath
fp = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: getDirectoryContents " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ FilePath -> IO [FilePath]
D.getDirectoryContents FilePath
fp)

getCurrentDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => Sem r FilePath
getCurrentDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
Sem r FilePath
getCurrentDirectory = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getCurrentDirectory"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException IO FilePath
D.getCurrentDirectory)

setCurrentDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
setCurrentDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
setCurrentDirectory FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: setCurrentDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.setCurrentDirectory FilePath
fp)

withCurrentDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Resource r
  => Member Log r
  => FilePath
  -> Sem r ()
  -> Sem r ()
withCurrentDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Resource r, Member Log r) =>
FilePath -> Sem r () -> Sem r ()
withCurrentDirectory FilePath
fp Sem r ()
f = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: withCurrentDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Sem r FilePath
-> (FilePath -> Sem r ()) -> (FilePath -> Sem r ()) -> Sem r ()
forall (r :: EffectRow) a c b.
Member Resource r =>
Sem r a -> (a -> Sem r c) -> (a -> Sem r b) -> Sem r b
bracket Sem r FilePath
forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
Sem r FilePath
getCurrentDirectory FilePath -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
setCurrentDirectory ((FilePath -> Sem r ()) -> Sem r ())
-> (FilePath -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Sem r () -> FilePath -> Sem r ()
forall a b. a -> b -> a
const (Sem r () -> FilePath -> Sem r ())
-> Sem r () -> FilePath -> Sem r ()
forall a b. (a -> b) -> a -> b
$ FilePath -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
setCurrentDirectory FilePath
fp Sem r () -> Sem r () -> Sem r ()
forall a b. Sem r a -> Sem r b -> Sem r b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Sem r ()
f

getHomeDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => Sem r FilePath
getHomeDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
Sem r FilePath
getHomeDirectory = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getHomeDirectory"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException IO FilePath
D.getHomeDirectory)

getXdgDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => XdgDirectory
  -> FilePath
  -> Sem r FilePath
getXdgDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
XdgDirectory -> FilePath -> Sem r FilePath
getXdgDirectory XdgDirectory
dir FilePath
fp = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: getXdgDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> XdgDirectory -> Text
forall a. Show a => a -> Text
tshow XdgDirectory
dir

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO FilePath -> IO (Either IOException FilePath))
-> IO FilePath -> IO (Either IOException FilePath)
forall a b. (a -> b) -> a -> b
$ XdgDirectory -> FilePath -> IO FilePath
D.getXdgDirectory XdgDirectory
dir FilePath
fp)

getXdgDirectoryList :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => XdgDirectoryList
  -> Sem r [FilePath]
getXdgDirectoryList :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
XdgDirectoryList -> Sem r [FilePath]
getXdgDirectoryList XdgDirectoryList
list = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: getXdgDirectoryList " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> XdgDirectoryList -> Text
forall a. Show a => a -> Text
tshow XdgDirectoryList
list

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ XdgDirectoryList -> IO [FilePath]
D.getXdgDirectoryList XdgDirectoryList
list)

getAppUserDataDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r FilePath
getAppUserDataDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r FilePath
getAppUserDataDirectory FilePath
fp = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info (Text -> Sem r ()) -> Text -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text
"Calling: getAppUserDataDirectory " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> FilePath -> Text
forall a. Show a => a -> Text
tshow FilePath
fp

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO FilePath -> IO (Either IOException FilePath))
-> IO FilePath -> IO (Either IOException FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.getAppUserDataDirectory FilePath
fp)

getUserDocumentsDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => Sem r FilePath
getUserDocumentsDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
Sem r FilePath
getUserDocumentsDirectory = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getUserDocumentsDirectory"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException IO FilePath
D.getUserDocumentsDirectory)

getTemporaryDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => Sem r FilePath
getTemporaryDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
Sem r FilePath
getTemporaryDirectory = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getTemporaryDirectory"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException IO FilePath
D.getTemporaryDirectory)

removeFile :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
removeFile :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
removeFile FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: removeFile"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.removeFile FilePath
fp)

renameFile :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
renameFile :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
renameFile FilePath
old FilePath
new = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: renameFile"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.renameFile FilePath
old FilePath
new)

renamePath :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
renamePath :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
renamePath FilePath
old FilePath
new = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: renamePath"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.renamePath FilePath
old FilePath
new)

copyFile :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
copyFile :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
copyFile FilePath
src FilePath
dst = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: copyFile"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.copyFile FilePath
src FilePath
dst)

copyFileWithMetadata :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
copyFileWithMetadata :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
copyFileWithMetadata FilePath
src FilePath
dst = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: copyFileWithMetadata"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.copyFileWithMetadata FilePath
src FilePath
dst)

getFileSize :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r Integer
getFileSize :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r Integer
getFileSize FilePath
fp = (HasCallStack => Sem r Integer) -> Sem r Integer
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r Integer) -> Sem r Integer)
-> (HasCallStack => Sem r Integer) -> Sem r Integer
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getFileSize"

  Either IOException Integer -> Sem r Integer
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException Integer -> Sem r Integer)
-> Sem r (Either IOException Integer) -> Sem r Integer
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException Integer)
-> Sem r (Either IOException Integer)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO Integer -> IO (Either IOException Integer))
-> IO Integer -> IO (Either IOException Integer)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Integer
D.getFileSize FilePath
fp)

canonicalizePath :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r FilePath
canonicalizePath :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r FilePath
canonicalizePath FilePath
fp = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: canonicalizePath"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO FilePath -> IO (Either IOException FilePath))
-> IO FilePath -> IO (Either IOException FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.canonicalizePath FilePath
fp)

makeAbsolute :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r FilePath
makeAbsolute :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r FilePath
makeAbsolute FilePath
fp = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: makeAbsolute"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO FilePath -> IO (Either IOException FilePath))
-> IO FilePath -> IO (Either IOException FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.makeAbsolute FilePath
fp)

makeRelativeToCurrentDirectory :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r FilePath
makeRelativeToCurrentDirectory :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r FilePath
makeRelativeToCurrentDirectory FilePath
fp = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: makeRelativeToCurrentDirectory"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO FilePath -> IO (Either IOException FilePath))
-> IO FilePath -> IO (Either IOException FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.makeRelativeToCurrentDirectory FilePath
fp)

doesPathExist :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r Bool
doesPathExist :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r Bool
doesPathExist FilePath
fp = (HasCallStack => Sem r Bool) -> Sem r Bool
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r Bool) -> Sem r Bool)
-> (HasCallStack => Sem r Bool) -> Sem r Bool
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: doesPathExist"

  Either IOException Bool -> Sem r Bool
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException Bool -> Sem r Bool)
-> Sem r (Either IOException Bool) -> Sem r Bool
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException Bool) -> Sem r (Either IOException Bool)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO Bool -> IO (Either IOException Bool))
-> IO Bool -> IO (Either IOException Bool)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Bool
D.doesPathExist FilePath
fp)

doesFileExist :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r Bool
doesFileExist :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r Bool
doesFileExist FilePath
fp = (HasCallStack => Sem r Bool) -> Sem r Bool
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r Bool) -> Sem r Bool)
-> (HasCallStack => Sem r Bool) -> Sem r Bool
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: doesFileExist"

  Either IOException Bool -> Sem r Bool
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException Bool -> Sem r Bool)
-> Sem r (Either IOException Bool) -> Sem r Bool
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException Bool) -> Sem r (Either IOException Bool)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO Bool -> IO (Either IOException Bool))
-> IO Bool -> IO (Either IOException Bool)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Bool
D.doesFileExist FilePath
fp)

doesDirectoryExist :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r Bool
doesDirectoryExist :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r Bool
doesDirectoryExist FilePath
fp = (HasCallStack => Sem r Bool) -> Sem r Bool
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r Bool) -> Sem r Bool)
-> (HasCallStack => Sem r Bool) -> Sem r Bool
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: doesDirectoryExist"

  Either IOException Bool -> Sem r Bool
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException Bool -> Sem r Bool)
-> Sem r (Either IOException Bool) -> Sem r Bool
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException Bool) -> Sem r (Either IOException Bool)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO Bool -> IO (Either IOException Bool))
-> IO Bool -> IO (Either IOException Bool)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Bool
D.doesDirectoryExist FilePath
fp)

findExecutable :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => String
  -> Sem r (Maybe FilePath)
findExecutable :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r (Maybe FilePath)
findExecutable FilePath
fp = (HasCallStack => Sem r (Maybe FilePath)) -> Sem r (Maybe FilePath)
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r (Maybe FilePath))
 -> Sem r (Maybe FilePath))
-> (HasCallStack => Sem r (Maybe FilePath))
-> Sem r (Maybe FilePath)
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findExecutable"

  Either IOException (Maybe FilePath) -> Sem r (Maybe FilePath)
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException (Maybe FilePath) -> Sem r (Maybe FilePath))
-> Sem r (Either IOException (Maybe FilePath))
-> Sem r (Maybe FilePath)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException (Maybe FilePath))
-> Sem r (Either IOException (Maybe FilePath))
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO (Maybe FilePath) -> IO (Either IOException (Maybe FilePath)))
-> IO (Maybe FilePath) -> IO (Either IOException (Maybe FilePath))
forall a b. (a -> b) -> a -> b
$ FilePath -> IO (Maybe FilePath)
D.findExecutable FilePath
fp)

findExecutables :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => String
  -> Sem r [FilePath]
findExecutables :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r [FilePath]
findExecutables FilePath
fp = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findExecutables"

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ FilePath -> IO [FilePath]
D.findExecutables FilePath
fp)

findExecutablesInDirectories :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => [FilePath]
  -> String
  -> Sem r [FilePath]
findExecutablesInDirectories :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
[FilePath] -> FilePath -> Sem r [FilePath]
findExecutablesInDirectories [FilePath]
fps FilePath
fp = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findExecutablesInDirectories"

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ [FilePath] -> FilePath -> IO [FilePath]
D.findExecutablesInDirectories [FilePath]
fps FilePath
fp)

findFile :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => [FilePath]
  -> String
  -> Sem r (Maybe FilePath)
findFile :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
[FilePath] -> FilePath -> Sem r (Maybe FilePath)
findFile [FilePath]
fps FilePath
fp = (HasCallStack => Sem r (Maybe FilePath)) -> Sem r (Maybe FilePath)
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r (Maybe FilePath))
 -> Sem r (Maybe FilePath))
-> (HasCallStack => Sem r (Maybe FilePath))
-> Sem r (Maybe FilePath)
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findFile"

  Either IOException (Maybe FilePath) -> Sem r (Maybe FilePath)
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException (Maybe FilePath) -> Sem r (Maybe FilePath))
-> Sem r (Either IOException (Maybe FilePath))
-> Sem r (Maybe FilePath)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException (Maybe FilePath))
-> Sem r (Either IOException (Maybe FilePath))
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO (Maybe FilePath) -> IO (Either IOException (Maybe FilePath)))
-> IO (Maybe FilePath) -> IO (Either IOException (Maybe FilePath))
forall a b. (a -> b) -> a -> b
$ [FilePath] -> FilePath -> IO (Maybe FilePath)
D.findFile [FilePath]
fps FilePath
fp)

findFiles :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => [FilePath]
  -> String
  -> Sem r [FilePath]
findFiles :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
[FilePath] -> FilePath -> Sem r [FilePath]
findFiles [FilePath]
fps FilePath
fp = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findFiles"

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ [FilePath] -> FilePath -> IO [FilePath]
D.findFiles [FilePath]
fps FilePath
fp)

findFileWith :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => (FilePath -> IO Bool)
  -> [FilePath]
  -> String
  -> Sem r (Maybe FilePath)
findFileWith :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
(FilePath -> IO Bool)
-> [FilePath] -> FilePath -> Sem r (Maybe FilePath)
findFileWith FilePath -> IO Bool
p [FilePath]
fps FilePath
fp = (HasCallStack => Sem r (Maybe FilePath)) -> Sem r (Maybe FilePath)
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r (Maybe FilePath))
 -> Sem r (Maybe FilePath))
-> (HasCallStack => Sem r (Maybe FilePath))
-> Sem r (Maybe FilePath)
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findFileWith"

  Either IOException (Maybe FilePath) -> Sem r (Maybe FilePath)
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException (Maybe FilePath) -> Sem r (Maybe FilePath))
-> Sem r (Either IOException (Maybe FilePath))
-> Sem r (Maybe FilePath)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException (Maybe FilePath))
-> Sem r (Either IOException (Maybe FilePath))
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO (Maybe FilePath) -> IO (Either IOException (Maybe FilePath)))
-> IO (Maybe FilePath) -> IO (Either IOException (Maybe FilePath))
forall a b. (a -> b) -> a -> b
$ (FilePath -> IO Bool)
-> [FilePath] -> FilePath -> IO (Maybe FilePath)
D.findFileWith FilePath -> IO Bool
p [FilePath]
fps FilePath
fp)

findFilesWith :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => (FilePath -> IO Bool)
  -> [FilePath]
  -> String
  -> Sem r [FilePath]
findFilesWith :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
(FilePath -> IO Bool) -> [FilePath] -> FilePath -> Sem r [FilePath]
findFilesWith FilePath -> IO Bool
p [FilePath]
fps FilePath
fp = (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r [FilePath]) -> Sem r [FilePath])
-> (HasCallStack => Sem r [FilePath]) -> Sem r [FilePath]
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: findFilesWith"

  Either IOException [FilePath] -> Sem r [FilePath]
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException [FilePath] -> Sem r [FilePath])
-> Sem r (Either IOException [FilePath]) -> Sem r [FilePath]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException [FilePath])
-> Sem r (Either IOException [FilePath])
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO [FilePath] -> IO (Either IOException [FilePath]))
-> IO [FilePath] -> IO (Either IOException [FilePath])
forall a b. (a -> b) -> a -> b
$ (FilePath -> IO Bool) -> [FilePath] -> FilePath -> IO [FilePath]
D.findFilesWith FilePath -> IO Bool
p [FilePath]
fps FilePath
fp)

createFileLink :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
createFileLink :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
createFileLink FilePath
old FilePath
new = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: createFileLink"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.createFileLink FilePath
old FilePath
new)

createDirectoryLink :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
createDirectoryLink :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
createDirectoryLink FilePath
old FilePath
new = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: createDirectoryLink"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.createDirectoryLink FilePath
old FilePath
new)

removeDirectoryLink :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r ()
removeDirectoryLink :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r ()
removeDirectoryLink FilePath
fp = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: removeDirectoryLink"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> IO ()
D.removeDirectoryLink FilePath
fp)

pathIsSymbolicLink :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r Bool
pathIsSymbolicLink :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r Bool
pathIsSymbolicLink FilePath
fp = (HasCallStack => Sem r Bool) -> Sem r Bool
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r Bool) -> Sem r Bool)
-> (HasCallStack => Sem r Bool) -> Sem r Bool
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: pathIsSymbolicLink"

  Either IOException Bool -> Sem r Bool
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException Bool -> Sem r Bool)
-> Sem r (Either IOException Bool) -> Sem r Bool
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException Bool) -> Sem r (Either IOException Bool)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO Bool -> IO (Either IOException Bool))
-> IO Bool -> IO (Either IOException Bool)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Bool
D.pathIsSymbolicLink FilePath
fp)

getSymbolicLinkTarget :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r FilePath
getSymbolicLinkTarget :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r FilePath
getSymbolicLinkTarget FilePath
fp = (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r FilePath) -> Sem r FilePath)
-> (HasCallStack => Sem r FilePath) -> Sem r FilePath
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getSymbolicLinkTarget"

  Either IOException FilePath -> Sem r FilePath
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException FilePath -> Sem r FilePath)
-> Sem r (Either IOException FilePath) -> Sem r FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException FilePath)
-> Sem r (Either IOException FilePath)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO FilePath -> IO (Either IOException FilePath))
-> IO FilePath -> IO (Either IOException FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.getSymbolicLinkTarget FilePath
fp)

getPermissions :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r D.Permissions
getPermissions :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r Permissions
getPermissions FilePath
fp = (HasCallStack => Sem r Permissions) -> Sem r Permissions
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r Permissions) -> Sem r Permissions)
-> (HasCallStack => Sem r Permissions) -> Sem r Permissions
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getPermissions"

  Either IOException Permissions -> Sem r Permissions
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException Permissions -> Sem r Permissions)
-> Sem r (Either IOException Permissions) -> Sem r Permissions
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException Permissions)
-> Sem r (Either IOException Permissions)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO Permissions -> IO (Either IOException Permissions))
-> IO Permissions -> IO (Either IOException Permissions)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Permissions
D.getPermissions FilePath
fp)

setPermissions :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> D.Permissions
  -> Sem r ()
setPermissions :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Permissions -> Sem r ()
setPermissions FilePath
fp Permissions
p = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: setPermissions"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> Permissions -> IO ()
D.setPermissions FilePath
fp Permissions
p)

copyPermissions :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> FilePath
  -> Sem r ()
copyPermissions :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> FilePath -> Sem r ()
copyPermissions FilePath
src FilePath
dst = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: copyPermissions"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.copyPermissions FilePath
src FilePath
dst)

getAccessTime :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r UTCTime
getAccessTime :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r UTCTime
getAccessTime FilePath
fp = (HasCallStack => Sem r UTCTime) -> Sem r UTCTime
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r UTCTime) -> Sem r UTCTime)
-> (HasCallStack => Sem r UTCTime) -> Sem r UTCTime
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getAccessTime"

  Either IOException UTCTime -> Sem r UTCTime
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException UTCTime -> Sem r UTCTime)
-> Sem r (Either IOException UTCTime) -> Sem r UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException UTCTime)
-> Sem r (Either IOException UTCTime)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO UTCTime -> IO (Either IOException UTCTime))
-> IO UTCTime -> IO (Either IOException UTCTime)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO UTCTime
D.getAccessTime FilePath
fp)

getModificationTime :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> Sem r UTCTime
getModificationTime :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> Sem r UTCTime
getModificationTime FilePath
fp = (HasCallStack => Sem r UTCTime) -> Sem r UTCTime
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r UTCTime) -> Sem r UTCTime)
-> (HasCallStack => Sem r UTCTime) -> Sem r UTCTime
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: getModificationTime"

  Either IOException UTCTime -> Sem r UTCTime
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException UTCTime -> Sem r UTCTime)
-> Sem r (Either IOException UTCTime) -> Sem r UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException UTCTime)
-> Sem r (Either IOException UTCTime)
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO UTCTime -> IO (Either IOException UTCTime))
-> IO UTCTime -> IO (Either IOException UTCTime)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO UTCTime
D.getModificationTime FilePath
fp)

setAccessTime :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> UTCTime
  -> Sem r ()
setAccessTime :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> UTCTime -> Sem r ()
setAccessTime FilePath
fp UTCTime
t = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: setAccessTime"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> UTCTime -> IO ()
D.setAccessTime FilePath
fp UTCTime
t)

setModificationTime :: ()
  => GHC.HasCallStack
  => Member (Error IOException) r
  => Member (Embed IO) r
  => Member Log r
  => FilePath
  -> UTCTime
  -> Sem r ()
setModificationTime :: forall (r :: EffectRow).
(HasCallStack, Member (Error IOException) r, Member (Embed IO) r,
 Member Log r) =>
FilePath -> UTCTime -> Sem r ()
setModificationTime FilePath
fp UTCTime
t = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
info Text
"Calling: setModificationTime"

  Either IOException () -> Sem r ()
forall e (r :: EffectRow) a.
Member (Error e) r =>
Either e a -> Sem r a
fromEither (Either IOException () -> Sem r ())
-> Sem r (Either IOException ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Either IOException ()) -> Sem r (Either IOException ())
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (forall e a. Exception e => IO a -> IO (Either e a)
CE.try @IOException (IO () -> IO (Either IOException ()))
-> IO () -> IO (Either IOException ())
forall a b. (a -> b) -> a -> b
$ FilePath -> UTCTime -> IO ()
D.setModificationTime FilePath
fp UTCTime
t)