{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ImpredicativeTypes #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE TypeFamilyDependencies #-}
{-# LANGUAGE NoMonomorphismRestriction #-}

module Path.Tagged.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
  PredefinedDir (..),
  WithPredefined,
  Cwd,
  Home,
  AppUserData,
  UserDocs,
  TempDir,
  getHomeDir,
  getAppUserDataDir,
  getUserDocsDir,
  getTempDir,
  XdgDirectory (..),
  XdgData,
  XdgConfig,
  XdgCache,
  WithXdg,
  KnownXdgDirectory (),
  getXdgBaseDir,
  getXdgDir,
  getXdgDataDirs,
  getXdgConfigDirs,

  -- * Path transformation
  AnyPathTo (..),
  RelPathTo,
  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
  Permissions (..),
  emptyPermissions,
  getPermissions,
  setPermissions,
  copyPermissions,

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

import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow)
import Control.Monad.IO.Class (MonadIO)
import Data.Coerce (coerce)
import Data.Functor ((<&>))
import Data.Kind (Constraint, Type)
import Data.Time (UTCTime)
import GHC.Exts (Proxy#, proxy#)
import GHC.Generics (Generic)
import Path.IO (Permissions (..), XdgDirectory (..), emptyPermissions, forgivingAbsence, ignoringAbsence)
import qualified Path.IO as P
import Path.Tagged
import System.IO (Handle)

createDir :: (MonadIO m) => PathTo e b Dir -> m ()
createDir :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m ()
createDir = Path Any Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
P.createDir (Path Any Dir -> m ())
-> (PathTo e b Dir -> Path Any Dir) -> PathTo e b Dir -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path Any Dir
forall a b. Coercible a b => a -> b
coerce

createDirIfMissing :: (MonadIO m) => Bool -> PathTo e b Dir -> m ()
createDirIfMissing :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
Bool -> PathTo e b Dir -> m ()
createDirIfMissing Bool
p = Bool -> Path Any Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
P.createDirIfMissing Bool
p (Path Any Dir -> m ())
-> (PathTo e b Dir -> Path Any Dir) -> PathTo e b Dir -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path Any Dir
forall a b. Coercible a b => a -> b
coerce

ensureDir :: (MonadIO m) => PathTo e b Dir -> m ()
ensureDir :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m ()
ensureDir = Path Any Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
P.ensureDir (Path Any Dir -> m ())
-> (PathTo e b Dir -> Path Any Dir) -> PathTo e b Dir -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path Any Dir
forall a b. Coercible a b => a -> b
coerce

removeDir :: (MonadIO m) => PathTo entity b Dir -> m ()
removeDir :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m ()
removeDir = Path (Untag b) Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
P.removeDir (Path (Untag b) Dir -> m ())
-> (PathTo entity b Dir -> Path (Untag b) Dir)
-> PathTo entity b Dir
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo entity b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

removeDirRecur :: (MonadIO m) => PathTo entity b Dir -> m ()
removeDirRecur :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m ()
removeDirRecur = Path (Untag b) Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
P.removeDirRecur (Path (Untag b) Dir -> m ())
-> (PathTo entity b Dir -> Path (Untag b) Dir)
-> PathTo entity b Dir
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo entity b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

removePathForcibly :: (MonadIO m) => PathTo e b t -> m ()
removePathForcibly :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> m ()
removePathForcibly = Path (Untag b) t -> m ()
forall (m :: * -> *) b t. MonadIO m => Path b t -> m ()
P.removePathForcibly (Path (Untag b) t -> m ())
-> (PathTo e b t -> Path (Untag b) t) -> PathTo e b t -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

renameDir :: (MonadIO m) => PathTo e b Dir -> PathTo e b' Dir -> m ()
renameDir :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) (b' :: Base k).
MonadIO m =>
PathTo e b Dir -> PathTo e b' Dir -> m ()
renameDir (PathTo Path (Untag b) Dir
old) (PathTo Path (Untag b') Dir
new) = Path (Untag b) Dir -> Path (Untag b') Dir -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
P.renameDir Path (Untag b) Dir
old Path (Untag b') Dir
new

renamePath :: (MonadIO m) => PathTo e b t -> PathTo e b' t -> m ()
renamePath :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t (b' :: Base k).
MonadIO m =>
PathTo e b t -> PathTo e b' t -> m ()
renamePath (PathTo Path (Untag b) t
old) (PathTo Path (Untag b') t
new) = Path (Untag b) t -> Path (Untag b') t -> m ()
forall (m :: * -> *) b0 t b1.
MonadIO m =>
Path b0 t -> Path b1 t -> m ()
P.renamePath Path (Untag b) t
old Path (Untag b') t
new

listDir ::
  (MonadIO m) =>
  PathTo e b Dir ->
  m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
listDir :: forall {k} {k} {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir
-> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
listDir = (([Path Abs Dir], [Path Abs File])
 -> ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File]))
-> m ([Path Abs Dir], [Path Abs File])
-> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Path Abs Dir], [Path Abs File])
-> ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
forall a b. Coercible a b => a -> b
coerce (m ([Path Abs Dir], [Path Abs File])
 -> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File]))
-> (PathTo e b Dir -> m ([Path Abs Dir], [Path Abs File]))
-> PathTo e b Dir
-> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
P.listDir (Path (Untag b) Dir -> m ([Path Abs Dir], [Path Abs File]))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m ([Path Abs Dir], [Path Abs File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

listDirRel ::
  (MonadIO m) =>
  PathTo e b Dir ->
  m ([PathTo Unknown (RelTo e) Dir], [PathTo Unknown (RelTo e) File])
listDirRel :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir
-> m ([PathTo Unknown (RelTo e) Dir],
      [PathTo Unknown (RelTo e) File])
listDirRel = (([Path Rel Dir], [Path Rel File])
 -> ([PathTo Unknown (RelTo e) Dir],
     [PathTo Unknown (RelTo e) File]))
-> m ([Path Rel Dir], [Path Rel File])
-> m ([PathTo Unknown (RelTo e) Dir],
      [PathTo Unknown (RelTo e) File])
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Path Rel Dir], [Path Rel File])
-> ([PathTo Unknown (RelTo e) Dir],
    [PathTo Unknown (RelTo e) File])
forall a b. Coercible a b => a -> b
coerce (m ([Path Rel Dir], [Path Rel File])
 -> m ([PathTo Unknown (RelTo e) Dir],
       [PathTo Unknown (RelTo e) File]))
-> (PathTo e b Dir -> m ([Path Rel Dir], [Path Rel File]))
-> PathTo e b Dir
-> m ([PathTo Unknown (RelTo e) Dir],
      [PathTo Unknown (RelTo e) File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m ([Path Rel Dir], [Path Rel File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Rel Dir], [Path Rel File])
P.listDirRel (Path (Untag b) Dir -> m ([Path Rel Dir], [Path Rel File]))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m ([Path Rel Dir], [Path Rel File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

listDirRecur ::
  (MonadIO m) =>
  PathTo e b Dir ->
  m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
listDirRecur :: forall {k} {k} {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir
-> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
listDirRecur = (([Path Abs Dir], [Path Abs File])
 -> ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File]))
-> m ([Path Abs Dir], [Path Abs File])
-> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Path Abs Dir], [Path Abs File])
-> ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
forall a b. Coercible a b => a -> b
coerce (m ([Path Abs Dir], [Path Abs File])
 -> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File]))
-> (PathTo e b Dir -> m ([Path Abs Dir], [Path Abs File]))
-> PathTo e b Dir
-> m ([PathTo Unknown Abs Dir], [PathTo Unknown Abs File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
P.listDirRecur (Path (Untag b) Dir -> m ([Path Abs Dir], [Path Abs File]))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m ([Path Abs Dir], [Path Abs File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

listDirRecurRel ::
  (MonadIO m) =>
  PathTo e b Dir ->
  m ([PathTo Unknown (RelTo e) Dir], [PathTo Unknown (RelTo e) File])
listDirRecurRel :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir
-> m ([PathTo Unknown (RelTo e) Dir],
      [PathTo Unknown (RelTo e) File])
listDirRecurRel = (([Path Rel Dir], [Path Rel File])
 -> ([PathTo Unknown (RelTo e) Dir],
     [PathTo Unknown (RelTo e) File]))
-> m ([Path Rel Dir], [Path Rel File])
-> m ([PathTo Unknown (RelTo e) Dir],
      [PathTo Unknown (RelTo e) File])
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Path Rel Dir], [Path Rel File])
-> ([PathTo Unknown (RelTo e) Dir],
    [PathTo Unknown (RelTo e) File])
forall a b. Coercible a b => a -> b
coerce (m ([Path Rel Dir], [Path Rel File])
 -> m ([PathTo Unknown (RelTo e) Dir],
       [PathTo Unknown (RelTo e) File]))
-> (PathTo e b Dir -> m ([Path Rel Dir], [Path Rel File]))
-> PathTo e b Dir
-> m ([PathTo Unknown (RelTo e) Dir],
      [PathTo Unknown (RelTo e) File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m ([Path Rel Dir], [Path Rel File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Rel Dir], [Path Rel File])
P.listDirRecurRel (Path (Untag b) Dir -> m ([Path Rel Dir], [Path Rel File]))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m ([Path Rel Dir], [Path Rel File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

copyDirRecur ::
  (MonadIO m, MonadCatch m) =>
  PathTo e0 b0 Dir ->
  PathTo e1 b1 Dir ->
  m ()
copyDirRecur :: forall {k} {k} (m :: * -> *) (e0 :: k) (b0 :: Base k) (e1 :: k)
       (b1 :: Base k).
(MonadIO m, MonadCatch m) =>
PathTo e0 b0 Dir -> PathTo e1 b1 Dir -> m ()
copyDirRecur (PathTo Path (Untag b0) Dir
p) (PathTo Path (Untag b1) Dir
l) = Path (Untag b0) Dir -> Path (Untag b1) Dir -> m ()
forall (m :: * -> *) b0 b1.
(MonadIO m, MonadCatch m) =>
Path b0 Dir -> Path b1 Dir -> m ()
P.copyDirRecur Path (Untag b0) Dir
p Path (Untag b1) Dir
l

copyDirRecur' ::
  (MonadIO m, MonadCatch m) =>
  PathTo e0 b0 Dir ->
  PathTo e1 b1 Dir ->
  m ()
copyDirRecur' :: forall {k} {k} (m :: * -> *) (e0 :: k) (b0 :: Base k) (e1 :: k)
       (b1 :: Base k).
(MonadIO m, MonadCatch m) =>
PathTo e0 b0 Dir -> PathTo e1 b1 Dir -> m ()
copyDirRecur' (PathTo Path (Untag b0) Dir
p) (PathTo Path (Untag b1) Dir
l) = Path (Untag b0) Dir -> Path (Untag b1) Dir -> m ()
forall (m :: * -> *) b0 b1.
(MonadIO m, MonadCatch m) =>
Path b0 Dir -> Path b1 Dir -> m ()
P.copyDirRecur' Path (Untag b0) Dir
p Path (Untag b1) Dir
l

data WalkAction b = WalkFinish | WalkExclude [PathTo Unknown b Dir]
  deriving (Int -> WalkAction b -> ShowS
[WalkAction b] -> ShowS
WalkAction b -> String
(Int -> WalkAction b -> ShowS)
-> (WalkAction b -> String)
-> ([WalkAction b] -> ShowS)
-> Show (WalkAction b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (b :: Base k). Int -> WalkAction b -> ShowS
forall k (b :: Base k). [WalkAction b] -> ShowS
forall k (b :: Base k). WalkAction b -> String
$cshowsPrec :: forall k (b :: Base k). Int -> WalkAction b -> ShowS
showsPrec :: Int -> WalkAction b -> ShowS
$cshow :: forall k (b :: Base k). WalkAction b -> String
show :: WalkAction b -> String
$cshowList :: forall k (b :: Base k). [WalkAction b] -> ShowS
showList :: [WalkAction b] -> ShowS
Show, WalkAction b -> WalkAction b -> Bool
(WalkAction b -> WalkAction b -> Bool)
-> (WalkAction b -> WalkAction b -> Bool) -> Eq (WalkAction b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
$c== :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
== :: WalkAction b -> WalkAction b -> Bool
$c/= :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
/= :: WalkAction b -> WalkAction b -> Bool
Eq, Eq (WalkAction b)
Eq (WalkAction b) =>
(WalkAction b -> WalkAction b -> Ordering)
-> (WalkAction b -> WalkAction b -> Bool)
-> (WalkAction b -> WalkAction b -> Bool)
-> (WalkAction b -> WalkAction b -> Bool)
-> (WalkAction b -> WalkAction b -> Bool)
-> (WalkAction b -> WalkAction b -> WalkAction b)
-> (WalkAction b -> WalkAction b -> WalkAction b)
-> Ord (WalkAction b)
WalkAction b -> WalkAction b -> Bool
WalkAction b -> WalkAction b -> Ordering
WalkAction b -> WalkAction b -> WalkAction b
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k (b :: Base k). Eq (WalkAction b)
forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
forall k (b :: Base k). WalkAction b -> WalkAction b -> Ordering
forall k (b :: Base k).
WalkAction b -> WalkAction b -> WalkAction b
$ccompare :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Ordering
compare :: WalkAction b -> WalkAction b -> Ordering
$c< :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
< :: WalkAction b -> WalkAction b -> Bool
$c<= :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
<= :: WalkAction b -> WalkAction b -> Bool
$c> :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
> :: WalkAction b -> WalkAction b -> Bool
$c>= :: forall k (b :: Base k). WalkAction b -> WalkAction b -> Bool
>= :: WalkAction b -> WalkAction b -> Bool
$cmax :: forall k (b :: Base k).
WalkAction b -> WalkAction b -> WalkAction b
max :: WalkAction b -> WalkAction b -> WalkAction b
$cmin :: forall k (b :: Base k).
WalkAction b -> WalkAction b -> WalkAction b
min :: WalkAction b -> WalkAction b -> WalkAction b
Ord)

toUntaggedAct :: WalkAction b -> P.WalkAction (Untag b)
{-# INLINE toUntaggedAct #-}
toUntaggedAct :: forall {k} (b :: Base k). WalkAction b -> WalkAction (Untag b)
toUntaggedAct WalkAction b
WalkFinish = WalkAction (Untag b)
forall b. WalkAction b
P.WalkFinish
toUntaggedAct (WalkExclude [PathTo Unknown b Dir]
excs) = [Path (Untag b) Dir] -> WalkAction (Untag b)
forall b. [Path b Dir] -> WalkAction b
P.WalkExclude ([Path (Untag b) Dir] -> WalkAction (Untag b))
-> [Path (Untag b) Dir] -> WalkAction (Untag b)
forall a b. (a -> b) -> a -> b
$ [PathTo Unknown b Dir] -> [Path (Untag b) Dir]
forall a b. Coercible a b => a -> b
coerce [PathTo Unknown b Dir]
excs

walkDir ::
  (MonadIO m) =>
  ( forall dir.
    PathTo dir Abs Dir ->
    [PathTo Unknown Abs Dir] ->
    [PathTo Unknown Abs File] ->
    m (WalkAction Abs)
  ) ->
  PathTo e b Dir ->
  m ()
walkDir :: forall {k} {k} {k} {k} {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
(forall (dir :: k).
 PathTo dir Abs Dir
 -> [PathTo Unknown Abs Dir]
 -> [PathTo Unknown Abs File]
 -> m (WalkAction Abs))
-> PathTo e b Dir -> m ()
walkDir forall (dir :: k).
PathTo dir Abs Dir
-> [PathTo Unknown Abs Dir]
-> [PathTo Unknown Abs File]
-> m (WalkAction Abs)
f PathTo e b Dir
p =
  (Path Abs Dir
 -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> Path (Untag b) Dir -> m ()
forall (m :: * -> *) b.
MonadIO m =>
(Path Abs Dir
 -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> Path b Dir -> m ()
P.walkDir
    ( \Path Abs Dir
dir [Path Abs Dir]
subdir [Path Abs File]
subfile -> WalkAction Abs -> WalkAction (Untag Abs)
forall {k} (b :: Base k). WalkAction b -> WalkAction (Untag b)
toUntaggedAct (WalkAction Abs -> WalkAction (Untag Abs))
-> m (WalkAction Abs) -> m (WalkAction (Untag Abs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PathTo Any Abs Dir
-> [PathTo Unknown Abs Dir]
-> [PathTo Unknown Abs File]
-> m (WalkAction Abs)
forall (dir :: k).
PathTo dir Abs Dir
-> [PathTo Unknown Abs Dir]
-> [PathTo Unknown Abs File]
-> m (WalkAction Abs)
f (Path (Untag Abs) Dir -> PathTo Any Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo Path Abs Dir
Path (Untag Abs) Dir
dir) (Path (Untag Abs) Dir -> PathTo Unknown Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo Unknown Abs Dir)
-> [Path (Untag Abs) Dir] -> [PathTo Unknown Abs Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Abs Dir]
[Path (Untag Abs) Dir]
subdir) (Path (Untag Abs) File -> PathTo Unknown Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) File -> PathTo Unknown Abs File)
-> [Path (Untag Abs) File] -> [PathTo Unknown Abs File]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Abs File]
[Path (Untag Abs) File]
subfile)
    )
    (PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath PathTo e b Dir
p)

walkDirRel ::
  (MonadIO m) =>
  ( forall dir.
    PathTo dir (RelTo e) Dir ->
    [PathTo Unknown (RelTo dir) Dir] ->
    [PathTo Unknown (RelTo dir) File] ->
    m (WalkAction (RelTo dir))
  ) ->
  PathTo e b Dir ->
  m ()
walkDirRel :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
(forall (dir :: k).
 PathTo dir (RelTo e) Dir
 -> [PathTo Unknown (RelTo dir) Dir]
 -> [PathTo Unknown (RelTo dir) File]
 -> m (WalkAction (RelTo dir)))
-> PathTo e b Dir -> m ()
walkDirRel forall (dir :: k).
PathTo dir (RelTo e) Dir
-> [PathTo Unknown (RelTo dir) Dir]
-> [PathTo Unknown (RelTo dir) File]
-> m (WalkAction (RelTo dir))
f PathTo e b Dir
p =
  (Path Rel Dir
 -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> Path (Untag b) Dir -> m ()
forall (m :: * -> *) b.
MonadIO m =>
(Path Rel Dir
 -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> Path b Dir -> m ()
P.walkDirRel
    ( \Path Rel Dir
dir [Path Rel Dir]
subdir [Path Rel File]
subfile -> WalkAction (RelTo Any) -> WalkAction (Untag (RelTo Any))
forall {k} (b :: Base k). WalkAction b -> WalkAction (Untag b)
toUntaggedAct (WalkAction (RelTo Any) -> WalkAction (Untag (RelTo Any)))
-> m (WalkAction (RelTo Any)) -> m (WalkAction (Untag (RelTo Any)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PathTo Any (RelTo e) Dir
-> [PathTo Unknown (RelTo Any) Dir]
-> [PathTo Unknown (RelTo Any) File]
-> m (WalkAction (RelTo Any))
forall (dir :: k).
PathTo dir (RelTo e) Dir
-> [PathTo Unknown (RelTo dir) Dir]
-> [PathTo Unknown (RelTo dir) File]
-> m (WalkAction (RelTo dir))
f (Path (Untag (RelTo e)) Dir -> PathTo Any (RelTo e) Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo Path Rel Dir
Path (Untag (RelTo e)) Dir
dir) (Path (Untag (RelTo Any)) Dir -> PathTo Unknown (RelTo Any) Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag (RelTo Any)) Dir -> PathTo Unknown (RelTo Any) Dir)
-> [Path (Untag (RelTo Any)) Dir]
-> [PathTo Unknown (RelTo Any) Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel Dir]
[Path (Untag (RelTo Any)) Dir]
subdir) (Path (Untag (RelTo Any)) File -> PathTo Unknown (RelTo Any) File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag (RelTo Any)) File -> PathTo Unknown (RelTo Any) File)
-> [Path (Untag (RelTo Any)) File]
-> [PathTo Unknown (RelTo Any) File]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel File]
[Path (Untag (RelTo Any)) File]
subfile)
    )
    (PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath PathTo e b Dir
p)

walkDirAccum ::
  (MonadIO m, Monoid o) =>
  Maybe
    ( forall dir.
      PathTo dir Abs Dir ->
      [PathTo Unknown Abs Dir] ->
      [PathTo Unknown Abs File] ->
      m (WalkAction Abs)
    ) ->
  ( forall dir.
    PathTo dir Abs Dir ->
    [PathTo Unknown Abs Dir] ->
    [PathTo Unknown Abs File] ->
    m o
  ) ->
  PathTo e b Dir ->
  m o
walkDirAccum :: forall {k} {k} {k} {k} {k} {k} {k} {k} (m :: * -> *) o (e :: k)
       (b :: Base k).
(MonadIO m, Monoid o) =>
Maybe
  (forall (dir :: k).
   PathTo dir Abs Dir
   -> [PathTo Unknown Abs Dir]
   -> [PathTo Unknown Abs File]
   -> m (WalkAction Abs))
-> (forall (dir :: k).
    PathTo dir Abs Dir
    -> [PathTo Unknown Abs Dir] -> [PathTo Unknown Abs File] -> m o)
-> PathTo e b Dir
-> m o
walkDirAccum Maybe
  (forall (dir :: k).
   PathTo dir Abs Dir
   -> [PathTo Unknown Abs Dir]
   -> [PathTo Unknown Abs File]
   -> m (WalkAction Abs))
mf forall (dir :: k).
PathTo dir Abs Dir
-> [PathTo Unknown Abs Dir] -> [PathTo Unknown Abs File] -> m o
g PathTo e b Dir
p =
  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 (Untag b) Dir
-> m o
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
P.walkDirAccum
    ( Maybe
  (forall (dir :: k).
   PathTo dir Abs Dir
   -> [PathTo Unknown Abs Dir]
   -> [PathTo Unknown Abs File]
   -> m (WalkAction Abs))
mf Maybe
  (forall (dir :: k).
   PathTo dir Abs Dir
   -> [PathTo Unknown Abs Dir]
   -> [PathTo Unknown Abs File]
   -> m (WalkAction Abs))
-> ((forall (dir :: k).
     PathTo dir Abs Dir
     -> [PathTo Unknown Abs Dir]
     -> [PathTo Unknown Abs File]
     -> m (WalkAction Abs))
    -> 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 (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \forall (dir :: k).
PathTo dir Abs Dir
-> [PathTo Unknown Abs Dir]
-> [PathTo Unknown Abs File]
-> m (WalkAction Abs)
f Path Abs Dir
dir [Path Abs Dir]
subdir [Path Abs File]
subfile -> WalkAction Abs -> WalkAction (Untag Abs)
forall {k} (b :: Base k). WalkAction b -> WalkAction (Untag b)
toUntaggedAct (WalkAction Abs -> WalkAction (Untag Abs))
-> m (WalkAction Abs) -> m (WalkAction (Untag Abs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PathTo Any Abs Dir
-> [PathTo Unknown Abs Dir]
-> [PathTo Unknown Abs File]
-> m (WalkAction Abs)
forall (dir :: k).
PathTo dir Abs Dir
-> [PathTo Unknown Abs Dir]
-> [PathTo Unknown Abs File]
-> m (WalkAction Abs)
f (Path (Untag Abs) Dir -> PathTo Any Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo Path Abs Dir
Path (Untag Abs) Dir
dir) ([Path Abs Dir] -> [PathTo Unknown Abs Dir]
forall a b. Coercible a b => a -> b
coerce [Path Abs Dir]
subdir) ([Path Abs File] -> [PathTo Unknown Abs File]
forall a b. Coercible a b => a -> b
coerce [Path Abs File]
subfile)
    )
    (\Path Abs Dir
dir [Path Abs Dir]
subdir [Path Abs File]
subfile -> PathTo Any Abs Dir
-> [PathTo Unknown Abs Dir] -> [PathTo Unknown Abs File] -> m o
forall (dir :: k).
PathTo dir Abs Dir
-> [PathTo Unknown Abs Dir] -> [PathTo Unknown Abs File] -> m o
g (Path (Untag Abs) Dir -> PathTo Any Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo Path Abs Dir
Path (Untag Abs) Dir
dir) ([Path Abs Dir] -> [PathTo Unknown Abs Dir]
forall a b. Coercible a b => a -> b
coerce [Path Abs Dir]
subdir) ([Path Abs File] -> [PathTo Unknown Abs File]
forall a b. Coercible a b => a -> b
coerce [Path Abs File]
subfile))
    (PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath PathTo e b Dir
p)

walkDirAccumRel ::
  (MonadIO m, Monoid o) =>
  Maybe
    ( forall dir.
      PathTo dir (RelTo e) Dir ->
      [PathTo Unknown (RelTo dir) Dir] ->
      [PathTo Unknown (RelTo dir) File] ->
      m (WalkAction (RelTo dir))
    ) ->
  ( forall dir.
    PathTo dir (RelTo e) Dir ->
    [PathTo Unknown (RelTo dir) Dir] ->
    [PathTo Unknown (RelTo dir) File] ->
    m o
  ) ->
  PathTo e b Dir ->
  m o
walkDirAccumRel :: forall {k} (m :: * -> *) o (e :: k) (b :: Base k).
(MonadIO m, Monoid o) =>
Maybe
  (forall (dir :: k).
   PathTo dir (RelTo e) Dir
   -> [PathTo Unknown (RelTo dir) Dir]
   -> [PathTo Unknown (RelTo dir) File]
   -> m (WalkAction (RelTo dir)))
-> (forall (dir :: k).
    PathTo dir (RelTo e) Dir
    -> [PathTo Unknown (RelTo dir) Dir]
    -> [PathTo Unknown (RelTo dir) File]
    -> m o)
-> PathTo e b Dir
-> m o
walkDirAccumRel Maybe
  (forall (dir :: k).
   PathTo dir (RelTo e) Dir
   -> [PathTo Unknown (RelTo dir) Dir]
   -> [PathTo Unknown (RelTo dir) File]
   -> m (WalkAction (RelTo dir)))
mf forall (dir :: k).
PathTo dir (RelTo e) Dir
-> [PathTo Unknown (RelTo dir) Dir]
-> [PathTo Unknown (RelTo dir) File]
-> m o
g PathTo e b Dir
p =
  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 (Untag b) Dir
-> m o
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
P.walkDirAccumRel
    ( Maybe
  (forall (dir :: k).
   PathTo dir (RelTo e) Dir
   -> [PathTo Unknown (RelTo dir) Dir]
   -> [PathTo Unknown (RelTo dir) File]
   -> m (WalkAction (RelTo dir)))
mf Maybe
  (forall (dir :: k).
   PathTo dir (RelTo e) Dir
   -> [PathTo Unknown (RelTo dir) Dir]
   -> [PathTo Unknown (RelTo dir) File]
   -> m (WalkAction (RelTo dir)))
-> ((forall (dir :: k).
     PathTo dir (RelTo e) Dir
     -> [PathTo Unknown (RelTo dir) Dir]
     -> [PathTo Unknown (RelTo dir) File]
     -> m (WalkAction (RelTo dir)))
    -> 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 (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \forall (dir :: k).
PathTo dir (RelTo e) Dir
-> [PathTo Unknown (RelTo dir) Dir]
-> [PathTo Unknown (RelTo dir) File]
-> m (WalkAction (RelTo dir))
f Path Rel Dir
dir [Path Rel Dir]
subdir [Path Rel File]
subfile -> WalkAction (RelTo Any) -> WalkAction (Untag (RelTo Any))
forall {k} (b :: Base k). WalkAction b -> WalkAction (Untag b)
toUntaggedAct (WalkAction (RelTo Any) -> WalkAction (Untag (RelTo Any)))
-> m (WalkAction (RelTo Any)) -> m (WalkAction (Untag (RelTo Any)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PathTo Any (RelTo e) Dir
-> [PathTo Unknown (RelTo Any) Dir]
-> [PathTo Unknown (RelTo Any) File]
-> m (WalkAction (RelTo Any))
forall (dir :: k).
PathTo dir (RelTo e) Dir
-> [PathTo Unknown (RelTo dir) Dir]
-> [PathTo Unknown (RelTo dir) File]
-> m (WalkAction (RelTo dir))
f (Path (Untag (RelTo e)) Dir -> PathTo Any (RelTo e) Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo Path Rel Dir
Path (Untag (RelTo e)) Dir
dir) ([Path Rel Dir] -> [PathTo Unknown (RelTo Any) Dir]
forall a b. Coercible a b => a -> b
coerce [Path Rel Dir]
subdir) ([Path Rel File] -> [PathTo Unknown (RelTo Any) File]
forall a b. Coercible a b => a -> b
coerce [Path Rel File]
subfile)
    )
    (\Path Rel Dir
dir [Path Rel Dir]
subdir [Path Rel File]
subfile -> PathTo Any (RelTo e) Dir
-> [PathTo Unknown (RelTo Any) Dir]
-> [PathTo Unknown (RelTo Any) File]
-> m o
forall (dir :: k).
PathTo dir (RelTo e) Dir
-> [PathTo Unknown (RelTo dir) Dir]
-> [PathTo Unknown (RelTo dir) File]
-> m o
g (Path (Untag (RelTo e)) Dir -> PathTo Any (RelTo e) Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo Path Rel Dir
Path (Untag (RelTo e)) Dir
dir) ([Path Rel Dir] -> [PathTo Unknown (RelTo Any) Dir]
forall a b. Coercible a b => a -> b
coerce [Path Rel Dir]
subdir) ([Path Rel File] -> [PathTo Unknown (RelTo Any) File]
forall a b. Coercible a b => a -> b
coerce [Path Rel File]
subfile))
    (PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath PathTo e b Dir
p)

getCurrentDir :: forall m. (MonadIO m) => m (PathTo Cwd Abs Dir)
getCurrentDir :: forall {k} (m :: * -> *). MonadIO m => m (PathTo Cwd Abs Dir)
getCurrentDir = Path (Untag Abs) Dir -> PathTo Cwd Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo Cwd Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo Cwd Abs Dir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Path Abs Dir)
m (Path (Untag Abs) Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
P.getCurrentDir

setCurrentDir :: (MonadIO m) => PathTo e b Dir -> m ()
setCurrentDir :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m ()
setCurrentDir = Path Any Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
P.setCurrentDir (Path Any Dir -> m ())
-> (PathTo e b Dir -> Path Any Dir) -> PathTo e b Dir -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path Any Dir
forall a b. Coercible a b => a -> b
coerce

withCurrentDir :: (MonadIO m, MonadMask m) => PathTo e b Dir -> m a -> m a
withCurrentDir :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) a.
(MonadIO m, MonadMask m) =>
PathTo e b Dir -> m a -> m a
withCurrentDir = Path Any Dir -> m a -> m a
forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> m a -> m a
P.withCurrentDir (Path Any Dir -> m a -> m a)
-> (PathTo e b Dir -> Path Any Dir) -> PathTo e b Dir -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path Any Dir
forall a b. Coercible a b => a -> b
coerce

type WithPredefined :: PredefinedDir -> k
type family WithPredefined p = w | w -> p where

data PredefinedDir
  = Home
  | AppUserData
  | UserDocs
  | TempDir
  | Cwd
  deriving (Int -> PredefinedDir -> ShowS
[PredefinedDir] -> ShowS
PredefinedDir -> String
(Int -> PredefinedDir -> ShowS)
-> (PredefinedDir -> String)
-> ([PredefinedDir] -> ShowS)
-> Show PredefinedDir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PredefinedDir -> ShowS
showsPrec :: Int -> PredefinedDir -> ShowS
$cshow :: PredefinedDir -> String
show :: PredefinedDir -> String
$cshowList :: [PredefinedDir] -> ShowS
showList :: [PredefinedDir] -> ShowS
Show, PredefinedDir -> PredefinedDir -> Bool
(PredefinedDir -> PredefinedDir -> Bool)
-> (PredefinedDir -> PredefinedDir -> Bool) -> Eq PredefinedDir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PredefinedDir -> PredefinedDir -> Bool
== :: PredefinedDir -> PredefinedDir -> Bool
$c/= :: PredefinedDir -> PredefinedDir -> Bool
/= :: PredefinedDir -> PredefinedDir -> Bool
Eq, Eq PredefinedDir
Eq PredefinedDir =>
(PredefinedDir -> PredefinedDir -> Ordering)
-> (PredefinedDir -> PredefinedDir -> Bool)
-> (PredefinedDir -> PredefinedDir -> Bool)
-> (PredefinedDir -> PredefinedDir -> Bool)
-> (PredefinedDir -> PredefinedDir -> Bool)
-> (PredefinedDir -> PredefinedDir -> PredefinedDir)
-> (PredefinedDir -> PredefinedDir -> PredefinedDir)
-> Ord PredefinedDir
PredefinedDir -> PredefinedDir -> Bool
PredefinedDir -> PredefinedDir -> Ordering
PredefinedDir -> PredefinedDir -> PredefinedDir
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PredefinedDir -> PredefinedDir -> Ordering
compare :: PredefinedDir -> PredefinedDir -> Ordering
$c< :: PredefinedDir -> PredefinedDir -> Bool
< :: PredefinedDir -> PredefinedDir -> Bool
$c<= :: PredefinedDir -> PredefinedDir -> Bool
<= :: PredefinedDir -> PredefinedDir -> Bool
$c> :: PredefinedDir -> PredefinedDir -> Bool
> :: PredefinedDir -> PredefinedDir -> Bool
$c>= :: PredefinedDir -> PredefinedDir -> Bool
>= :: PredefinedDir -> PredefinedDir -> Bool
$cmax :: PredefinedDir -> PredefinedDir -> PredefinedDir
max :: PredefinedDir -> PredefinedDir -> PredefinedDir
$cmin :: PredefinedDir -> PredefinedDir -> PredefinedDir
min :: PredefinedDir -> PredefinedDir -> PredefinedDir
Ord, (forall x. PredefinedDir -> Rep PredefinedDir x)
-> (forall x. Rep PredefinedDir x -> PredefinedDir)
-> Generic PredefinedDir
forall x. Rep PredefinedDir x -> PredefinedDir
forall x. PredefinedDir -> Rep PredefinedDir x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PredefinedDir -> Rep PredefinedDir x
from :: forall x. PredefinedDir -> Rep PredefinedDir x
$cto :: forall x. Rep PredefinedDir x -> PredefinedDir
to :: forall x. Rep PredefinedDir x -> PredefinedDir
Generic)

type Cwd = WithPredefined 'Cwd

type Home = WithPredefined 'Home

type AppUserData = WithPredefined 'AppUserData

type UserDocs = WithPredefined 'UserDocs

type TempDir = WithPredefined 'TempDir

getHomeDir :: (MonadIO m) => m (PathTo Home Abs Dir)
getHomeDir :: forall {k} (m :: * -> *). MonadIO m => m (PathTo Home Abs Dir)
getHomeDir = Path (Untag Abs) Dir -> PathTo Home Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo Home Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo Home Abs Dir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Path Abs Dir)
m (Path (Untag Abs) Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
P.getHomeDir

getAppUserDataDir :: (MonadIO m) => String -> m (PathTo AppUserData Abs Dir)
getAppUserDataDir :: forall {k} (m :: * -> *).
MonadIO m =>
String -> m (PathTo AppUserData Abs Dir)
getAppUserDataDir = (Path (Untag Abs) Dir -> PathTo AppUserData Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo AppUserData Abs Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) Dir -> PathTo AppUserData Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) Dir) -> m (PathTo AppUserData Abs Dir))
-> (String -> m (Path (Untag Abs) Dir))
-> String
-> m (PathTo AppUserData Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> m (Path Abs Dir)
String -> m (Path (Untag Abs) Dir)
forall (m :: * -> *). MonadIO m => String -> m (Path Abs Dir)
P.getAppUserDataDir

getUserDocsDir :: (MonadIO m) => m (PathTo UserDocs Abs Dir)
getUserDocsDir :: forall {k} (m :: * -> *). MonadIO m => m (PathTo UserDocs Abs Dir)
getUserDocsDir = Path (Untag Abs) Dir -> PathTo UserDocs Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo UserDocs Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo UserDocs Abs Dir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Path Abs Dir)
m (Path (Untag Abs) Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
P.getUserDocsDir

getTempDir :: (MonadIO m) => m (PathTo TempDir Abs Dir)
getTempDir :: forall {k} (m :: * -> *). MonadIO m => m (PathTo TempDir Abs Dir)
getTempDir = Path (Untag Abs) Dir -> PathTo TempDir Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo TempDir Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo TempDir Abs Dir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Path Abs Dir)
m (Path (Untag Abs) Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
P.getTempDir

type WithXdg :: forall {k}. XdgDirectory -> k
type family WithXdg xdg = p | p -> xdg where

type XdgData = WithXdg 'XdgData

type XdgConfig = WithXdg 'XdgConfig

type XdgCache = WithXdg 'XdgCache

type KnownXdgDirectory :: XdgDirectory -> Constraint
class KnownXdgDirectory xdg where
  xdgDirectory# :: Proxy# xdg -> XdgDirectory

instance KnownXdgDirectory 'XdgData where
  xdgDirectory# :: Proxy# 'XdgData -> XdgDirectory
xdgDirectory# Proxy# 'XdgData
_ = XdgDirectory
XdgData

instance KnownXdgDirectory 'XdgConfig where
  xdgDirectory# :: Proxy# 'XdgConfig -> XdgDirectory
xdgDirectory# Proxy# 'XdgConfig
_ = XdgDirectory
XdgConfig

instance KnownXdgDirectory 'XdgCache where
  xdgDirectory# :: Proxy# 'XdgCache -> XdgDirectory
xdgDirectory# Proxy# 'XdgCache
_ = XdgDirectory
XdgCache

getXdgBaseDir ::
  forall xdg m.
  (KnownXdgDirectory xdg, MonadIO m) =>
  m (PathTo xdg Abs Dir)
getXdgBaseDir :: forall (xdg :: XdgDirectory) (m :: * -> *).
(KnownXdgDirectory xdg, MonadIO m) =>
m (PathTo xdg Abs Dir)
getXdgBaseDir = Path (Untag Abs) Dir -> PathTo xdg Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo xdg Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo xdg Abs Dir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> XdgDirectory -> Maybe (Path Rel Dir) -> m (Path Abs Dir)
forall (m :: * -> *).
MonadIO m =>
XdgDirectory -> Maybe (Path Rel Dir) -> m (Path Abs Dir)
P.getXdgDir (Proxy# xdg -> XdgDirectory
forall (xdg :: XdgDirectory).
KnownXdgDirectory xdg =>
Proxy# xdg -> XdgDirectory
xdgDirectory# (Proxy# xdg
forall {k} (a :: k). Proxy# a
proxy# :: Proxy# xdg)) Maybe (Path Rel Dir)
forall a. Maybe a
Nothing

getXdgDir ::
  forall xdg e m.
  (KnownXdgDirectory xdg, MonadIO m) =>
  PathTo e (RelTo (WithXdg xdg)) Dir ->
  m (PathTo e Abs Dir)
getXdgDir :: forall {k} (xdg :: XdgDirectory) (e :: k) (m :: * -> *).
(KnownXdgDirectory xdg, MonadIO m) =>
PathTo e (RelTo (WithXdg xdg)) Dir -> m (PathTo e Abs Dir)
getXdgDir (PathTo Path (Untag (RelTo (WithXdg xdg))) Dir
p) =
  Path (Untag Abs) Dir -> PathTo e Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (Path (Untag Abs) Dir -> PathTo e Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> XdgDirectory -> Maybe (Path Rel Dir) -> m (Path Abs Dir)
forall (m :: * -> *).
MonadIO m =>
XdgDirectory -> Maybe (Path Rel Dir) -> m (Path Abs Dir)
P.getXdgDir (Proxy# xdg -> XdgDirectory
forall (xdg :: XdgDirectory).
KnownXdgDirectory xdg =>
Proxy# xdg -> XdgDirectory
xdgDirectory# (Proxy# xdg
forall {k} (a :: k). Proxy# a
proxy# :: Proxy# xdg)) (Path (Untag (RelTo (WithXdg xdg))) Dir
-> Maybe (Path (Untag (RelTo (WithXdg xdg))) Dir)
forall a. a -> Maybe a
Just Path (Untag (RelTo (WithXdg xdg))) Dir
p)

getXdgDataDirs :: (MonadIO m) => m [PathTo XdgData Abs Dir]
getXdgDataDirs :: forall {k} (m :: * -> *). MonadIO m => m [PathTo XdgData Abs Dir]
getXdgDataDirs = [Path Abs Dir] -> [PathTo (WithXdg 'XdgData) Abs Dir]
forall a b. Coercible a b => a -> b
coerce ([Path Abs Dir] -> [PathTo (WithXdg 'XdgData) Abs Dir])
-> m [Path Abs Dir] -> m [PathTo (WithXdg 'XdgData) Abs Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> XdgDirectoryList -> m [Path Abs Dir]
forall (m :: * -> *).
MonadIO m =>
XdgDirectoryList -> m [Path Abs Dir]
P.getXdgDirList XdgDirectoryList
P.XdgDataDirs

getXdgConfigDirs :: (MonadIO m) => m [PathTo XdgConfig Abs Dir]
getXdgConfigDirs :: forall {k} (m :: * -> *). MonadIO m => m [PathTo XdgConfig Abs Dir]
getXdgConfigDirs = [Path Abs Dir] -> [PathTo (WithXdg 'XdgConfig) Abs Dir]
forall a b. Coercible a b => a -> b
coerce ([Path Abs Dir] -> [PathTo (WithXdg 'XdgConfig) Abs Dir])
-> m [Path Abs Dir] -> m [PathTo (WithXdg 'XdgConfig) Abs Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> XdgDirectoryList -> m [Path Abs Dir]
forall (m :: * -> *).
MonadIO m =>
XdgDirectoryList -> m [Path Abs Dir]
P.getXdgDirList XdgDirectoryList
P.XdgConfigDirs

type RelPathTo :: forall {k}. k -> Type -> Type
type RelPathTo (e :: k) path = RelPathTo' k e path

class AnyPathTo path where
  type PathTag path :: Type
  type AbsPath path :: Type
  type RelPathTo' k (e :: k) path :: Type
  canonicalizePath :: (MonadIO m) => path -> m (AbsPath path)
  makeAbsolute :: (MonadIO m) => path -> m (AbsPath path)
  makeRelative :: (MonadThrow m) => PathTo (e :: PathTag path) Abs Dir -> path -> m (RelPathTo e path)
  makeRelativeToCurrentDir :: (MonadIO m) => path -> m (RelPathTo' (PathTag path) Cwd path)

instance AnyPathTo (SomeBase (e :: k) b Dir) where
  type PathTag (SomeBase (e :: k) b Dir) = k
  type AbsPath (SomeBase e b Dir) = PathTo e Abs Dir
  type RelPathTo' k e' (SomeBase e b Dir) = PathTo e (RelTo e') Dir
  canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
SomeBase e b Dir -> m (AbsPath (SomeBase e b Dir))
canonicalizePath = \case
    IsAbs PathTo e Abs Dir
fp -> PathTo e Abs Dir -> m (AbsPath (PathTo e Abs Dir))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e Abs Dir -> m (AbsPath (PathTo e Abs Dir))
canonicalizePath PathTo e Abs Dir
fp
    IsRel PathTo e (RelTo b) Dir
fp -> PathTo e (RelTo b) Dir -> m (AbsPath (PathTo e (RelTo b) Dir))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e (RelTo b) Dir -> m (AbsPath (PathTo e (RelTo b) Dir))
canonicalizePath PathTo e (RelTo b) Dir
fp
  makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
SomeBase e b Dir -> m (AbsPath (SomeBase e b Dir))
makeAbsolute = \case
    IsAbs PathTo e Abs Dir
fp -> PathTo e Abs Dir -> m (AbsPath (PathTo e Abs Dir))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e Abs Dir -> m (AbsPath (PathTo e Abs Dir))
makeAbsolute PathTo e Abs Dir
fp
    IsRel PathTo e (RelTo b) Dir
fp -> PathTo e (RelTo b) Dir -> m (AbsPath (PathTo e (RelTo b) Dir))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e (RelTo b) Dir -> m (AbsPath (PathTo e (RelTo b) Dir))
makeAbsolute PathTo e (RelTo b) Dir
fp
  makeRelative :: forall (m :: * -> *) (e :: PathTag (SomeBase e b Dir)).
MonadThrow m =>
PathTo e Abs Dir
-> SomeBase e b Dir -> m (RelPathTo e (SomeBase e b Dir))
makeRelative PathTo e Abs Dir
b = \case
    IsAbs PathTo e Abs Dir
fp -> PathTo e Abs Dir
-> PathTo e Abs Dir -> m (RelPathTo e (PathTo e Abs Dir))
forall path (m :: * -> *) (e :: PathTag path).
(AnyPathTo path, MonadThrow m) =>
PathTo e Abs Dir -> path -> m (RelPathTo e path)
forall (m :: * -> *) (e :: PathTag (PathTo e Abs Dir)).
MonadThrow m =>
PathTo e Abs Dir
-> PathTo e Abs Dir -> m (RelPathTo e (PathTo e Abs Dir))
makeRelative PathTo e Abs Dir
PathTo e Abs Dir
b PathTo e Abs Dir
fp
    IsRel PathTo e (RelTo b) Dir
fp -> PathTo e Abs Dir
-> PathTo e (RelTo b) Dir
-> m (RelPathTo e (PathTo e (RelTo b) Dir))
forall path (m :: * -> *) (e :: PathTag path).
(AnyPathTo path, MonadThrow m) =>
PathTo e Abs Dir -> path -> m (RelPathTo e path)
forall (m :: * -> *) (e :: PathTag (PathTo e (RelTo b) Dir)).
MonadThrow m =>
PathTo e Abs Dir
-> PathTo e (RelTo b) Dir
-> m (RelPathTo e (PathTo e (RelTo b) Dir))
makeRelative PathTo e Abs Dir
PathTo e Abs Dir
b PathTo e (RelTo b) Dir
fp
  makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
SomeBase e b Dir
-> m (RelPathTo'
        (PathTag (SomeBase e b Dir)) Cwd (SomeBase e b Dir))
makeRelativeToCurrentDir = \case
    IsAbs PathTo e Abs Dir
fp -> PathTo e Abs Dir
-> m (RelPathTo'
        (PathTag (PathTo e Abs Dir)) Cwd (PathTo e Abs Dir))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (RelPathTo' (PathTag path) Cwd path)
forall (m :: * -> *).
MonadIO m =>
PathTo e Abs Dir
-> m (RelPathTo'
        (PathTag (PathTo e Abs Dir)) Cwd (PathTo e Abs Dir))
makeRelativeToCurrentDir PathTo e Abs Dir
fp
    IsRel PathTo e (RelTo b) Dir
fp -> PathTo e (RelTo b) Dir
-> m (RelPathTo'
        (PathTag (PathTo e (RelTo b) Dir)) Cwd (PathTo e (RelTo b) Dir))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (RelPathTo' (PathTag path) Cwd path)
forall (m :: * -> *).
MonadIO m =>
PathTo e (RelTo b) Dir
-> m (RelPathTo'
        (PathTag (PathTo e (RelTo b) Dir)) Cwd (PathTo e (RelTo b) Dir))
makeRelativeToCurrentDir PathTo e (RelTo b) Dir
fp

instance AnyPathTo (SomeBase (e :: k) b File) where
  type PathTag (SomeBase (e :: k) b File) = k
  type AbsPath (SomeBase e b File) = PathTo e Abs File
  type RelPathTo' k e' (SomeBase e b File) = PathTo e (RelTo e') File
  canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
SomeBase e b File -> m (AbsPath (SomeBase e b File))
canonicalizePath = \case
    IsAbs PathTo e Abs File
fp -> PathTo e Abs File -> m (AbsPath (PathTo e Abs File))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e Abs File -> m (AbsPath (PathTo e Abs File))
canonicalizePath PathTo e Abs File
fp
    IsRel PathTo e (RelTo b) File
fp -> PathTo e (RelTo b) File -> m (AbsPath (PathTo e (RelTo b) File))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e (RelTo b) File -> m (AbsPath (PathTo e (RelTo b) File))
canonicalizePath PathTo e (RelTo b) File
fp
  makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
SomeBase e b File -> m (AbsPath (SomeBase e b File))
makeAbsolute = \case
    IsAbs PathTo e Abs File
fp -> PathTo e Abs File -> m (AbsPath (PathTo e Abs File))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e Abs File -> m (AbsPath (PathTo e Abs File))
makeAbsolute PathTo e Abs File
fp
    IsRel PathTo e (RelTo b) File
fp -> PathTo e (RelTo b) File -> m (AbsPath (PathTo e (RelTo b) File))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
PathTo e (RelTo b) File -> m (AbsPath (PathTo e (RelTo b) File))
makeAbsolute PathTo e (RelTo b) File
fp
  makeRelative :: forall (m :: * -> *) (e :: PathTag (SomeBase e b File)).
MonadThrow m =>
PathTo e Abs Dir
-> SomeBase e b File -> m (RelPathTo e (SomeBase e b File))
makeRelative PathTo e Abs Dir
b = \case
    IsAbs PathTo e Abs File
fp -> PathTo e Abs Dir
-> PathTo e Abs File -> m (RelPathTo e (PathTo e Abs File))
forall path (m :: * -> *) (e :: PathTag path).
(AnyPathTo path, MonadThrow m) =>
PathTo e Abs Dir -> path -> m (RelPathTo e path)
forall (m :: * -> *) (e :: PathTag (PathTo e Abs File)).
MonadThrow m =>
PathTo e Abs Dir
-> PathTo e Abs File -> m (RelPathTo e (PathTo e Abs File))
makeRelative PathTo e Abs Dir
PathTo e Abs Dir
b PathTo e Abs File
fp
    IsRel PathTo e (RelTo b) File
fp -> PathTo e Abs Dir
-> PathTo e (RelTo b) File
-> m (RelPathTo e (PathTo e (RelTo b) File))
forall path (m :: * -> *) (e :: PathTag path).
(AnyPathTo path, MonadThrow m) =>
PathTo e Abs Dir -> path -> m (RelPathTo e path)
forall (m :: * -> *) (e :: PathTag (PathTo e (RelTo b) File)).
MonadThrow m =>
PathTo e Abs Dir
-> PathTo e (RelTo b) File
-> m (RelPathTo e (PathTo e (RelTo b) File))
makeRelative PathTo e Abs Dir
PathTo e Abs Dir
b PathTo e (RelTo b) File
fp
  makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
SomeBase e b File
-> m (RelPathTo'
        (PathTag (SomeBase e b File)) Cwd (SomeBase e b File))
makeRelativeToCurrentDir = \case
    IsAbs PathTo e Abs File
fp -> PathTo e Abs File
-> m (RelPathTo'
        (PathTag (PathTo e Abs File)) Cwd (PathTo e Abs File))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (RelPathTo' (PathTag path) Cwd path)
forall (m :: * -> *).
MonadIO m =>
PathTo e Abs File
-> m (RelPathTo'
        (PathTag (PathTo e Abs File)) Cwd (PathTo e Abs File))
makeRelativeToCurrentDir PathTo e Abs File
fp
    IsRel PathTo e (RelTo b) File
fp -> PathTo e (RelTo b) File
-> m (RelPathTo'
        (PathTag (PathTo e (RelTo b) File)) Cwd (PathTo e (RelTo b) File))
forall path (m :: * -> *).
(AnyPathTo path, MonadIO m) =>
path -> m (RelPathTo' (PathTag path) Cwd path)
forall (m :: * -> *).
MonadIO m =>
PathTo e (RelTo b) File
-> m (RelPathTo'
        (PathTag (PathTo e (RelTo b) File)) Cwd (PathTo e (RelTo b) File))
makeRelativeToCurrentDir PathTo e (RelTo b) File
fp

instance AnyPathTo (PathTo (e :: k) b File) where
  type PathTag (PathTo (e :: k) b File) = k
  type AbsPath (PathTo e b File) = PathTo e Abs File
  type RelPathTo' k e' (PathTo e b File) = PathTo e (RelTo e') File
  canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
PathTo e b File -> m (AbsPath (PathTo e b File))
canonicalizePath = (Path (Untag Abs) File -> PathTo e Abs File)
-> m (Path (Untag Abs) File) -> m (PathTo e Abs File)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) File -> PathTo e Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) File) -> m (PathTo e Abs File))
-> (PathTo e b File -> m (Path (Untag Abs) File))
-> PathTo e b File
-> m (PathTo e Abs File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) File -> m (AbsPath (Path (Untag b) File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path (Untag b) File -> m (AbsPath (Path (Untag b) File))
P.canonicalizePath (Path (Untag b) File -> m (AbsPath (Path (Untag b) File)))
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m (AbsPath (Path (Untag b) File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath
  makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
PathTo e b File -> m (AbsPath (PathTo e b File))
makeAbsolute = (Path (Untag Abs) File -> PathTo e Abs File)
-> m (Path (Untag Abs) File) -> m (PathTo e Abs File)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) File -> PathTo e Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) File) -> m (PathTo e Abs File))
-> (PathTo e b File -> m (Path (Untag Abs) File))
-> PathTo e b File
-> m (PathTo e Abs File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) File -> m (AbsPath (Path (Untag b) File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path (Untag b) File -> m (AbsPath (Path (Untag b) File))
P.makeAbsolute (Path (Untag b) File -> m (AbsPath (Path (Untag b) File)))
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m (AbsPath (Path (Untag b) File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath
  makeRelative :: forall (m :: * -> *) (e :: PathTag (PathTo e b File)).
MonadThrow m =>
PathTo e Abs Dir
-> PathTo e b File -> m (RelPathTo e (PathTo e b File))
makeRelative (PathTo Path (Untag Abs) Dir
p) = (Path (Untag (RelTo e)) File -> PathTo e (RelTo e) File)
-> m (Path (Untag (RelTo e)) File) -> m (PathTo e (RelTo e) File)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag (RelTo e)) File -> PathTo e (RelTo e) File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag (RelTo e)) File) -> m (PathTo e (RelTo e) File))
-> (PathTo e b File -> m (Path (Untag (RelTo e)) File))
-> PathTo e b File
-> m (PathTo e (RelTo e) File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir
-> Path (Untag b) File -> m (RelPath (Path (Untag b) File))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir
-> Path (Untag b) File -> m (RelPath (Path (Untag b) File))
P.makeRelative Path Abs Dir
Path (Untag Abs) Dir
p (Path (Untag b) File -> m (RelPath (Path (Untag b) File)))
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m (RelPath (Path (Untag b) File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath
  makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
PathTo e b File
-> m (RelPathTo' (PathTag (PathTo e b File)) Cwd (PathTo e b File))
makeRelativeToCurrentDir = (Path (Untag (RelTo (WithPredefined 'Cwd))) File
 -> PathTo e (RelTo (WithPredefined 'Cwd)) File)
-> m (Path (Untag (RelTo (WithPredefined 'Cwd))) File)
-> m (PathTo e (RelTo (WithPredefined 'Cwd)) File)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag (RelTo (WithPredefined 'Cwd))) File
-> PathTo e (RelTo (WithPredefined 'Cwd)) File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag (RelTo (WithPredefined 'Cwd))) File)
 -> m (PathTo e (RelTo (WithPredefined 'Cwd)) File))
-> (PathTo e b File
    -> m (Path (Untag (RelTo (WithPredefined 'Cwd))) File))
-> PathTo e b File
-> m (PathTo e (RelTo (WithPredefined 'Cwd)) File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) File -> m (RelPath (Path (Untag b) File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (RelPath path)
forall (m :: * -> *).
MonadIO m =>
Path (Untag b) File -> m (RelPath (Path (Untag b) File))
P.makeRelativeToCurrentDir (Path (Untag b) File -> m (RelPath (Path (Untag b) File)))
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m (RelPath (Path (Untag b) File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

instance AnyPathTo (PathTo (e :: k) b Dir) where
  type PathTag (PathTo (e :: k) b Dir) = k
  type AbsPath (PathTo e b Dir) = PathTo e Abs Dir
  type RelPathTo' k e' (PathTo e b Dir) = PathTo e (RelTo e') Dir
  canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
PathTo e b Dir -> m (AbsPath (PathTo e b Dir))
canonicalizePath = (Path (Untag Abs) Dir -> PathTo e Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) Dir -> PathTo e Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir))
-> (PathTo e b Dir -> m (Path (Untag Abs) Dir))
-> PathTo e b Dir
-> m (PathTo e Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m (AbsPath (Path (Untag b) Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path (Untag b) Dir -> m (AbsPath (Path (Untag b) Dir))
P.canonicalizePath (Path (Untag b) Dir -> m (AbsPath (Path (Untag b) Dir)))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m (AbsPath (Path (Untag b) Dir))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath
  makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
PathTo e b Dir -> m (AbsPath (PathTo e b Dir))
makeAbsolute = (Path (Untag Abs) Dir -> PathTo e Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) Dir -> PathTo e Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir))
-> (PathTo e b Dir -> m (Path (Untag Abs) Dir))
-> PathTo e b Dir
-> m (PathTo e Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m (AbsPath (Path (Untag b) Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path (Untag b) Dir -> m (AbsPath (Path (Untag b) Dir))
P.makeAbsolute (Path (Untag b) Dir -> m (AbsPath (Path (Untag b) Dir)))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m (AbsPath (Path (Untag b) Dir))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath
  makeRelative :: forall (m :: * -> *) (e :: PathTag (PathTo e b Dir)).
MonadThrow m =>
PathTo e Abs Dir
-> PathTo e b Dir -> m (RelPathTo e (PathTo e b Dir))
makeRelative (PathTo Path (Untag Abs) Dir
p) = (Path (Untag (RelTo e)) Dir -> PathTo e (RelTo e) Dir)
-> m (Path (Untag (RelTo e)) Dir) -> m (PathTo e (RelTo e) Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag (RelTo e)) Dir -> PathTo e (RelTo e) Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag (RelTo e)) Dir) -> m (PathTo e (RelTo e) Dir))
-> (PathTo e b Dir -> m (Path (Untag (RelTo e)) Dir))
-> PathTo e b Dir
-> m (PathTo e (RelTo e) Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir
-> Path (Untag b) Dir -> m (RelPath (Path (Untag b) Dir))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir
-> Path (Untag b) Dir -> m (RelPath (Path (Untag b) Dir))
P.makeRelative Path Abs Dir
Path (Untag Abs) Dir
p (Path (Untag b) Dir -> m (RelPath (Path (Untag b) Dir)))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m (RelPath (Path (Untag b) Dir))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath
  makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
PathTo e b Dir
-> m (RelPathTo' (PathTag (PathTo e b Dir)) Cwd (PathTo e b Dir))
makeRelativeToCurrentDir = (Path (Untag (RelTo (WithPredefined 'Cwd))) Dir
 -> PathTo e (RelTo (WithPredefined 'Cwd)) Dir)
-> m (Path (Untag (RelTo (WithPredefined 'Cwd))) Dir)
-> m (PathTo e (RelTo (WithPredefined 'Cwd)) Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag (RelTo (WithPredefined 'Cwd))) Dir
-> PathTo e (RelTo (WithPredefined 'Cwd)) Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag (RelTo (WithPredefined 'Cwd))) Dir)
 -> m (PathTo e (RelTo (WithPredefined 'Cwd)) Dir))
-> (PathTo e b Dir
    -> m (Path (Untag (RelTo (WithPredefined 'Cwd))) Dir))
-> PathTo e b Dir
-> m (PathTo e (RelTo (WithPredefined 'Cwd)) Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> m (RelPath (Path (Untag b) Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (RelPath path)
forall (m :: * -> *).
MonadIO m =>
Path (Untag b) Dir -> m (RelPath (Path (Untag b) Dir))
P.makeRelativeToCurrentDir (Path (Untag b) Dir -> m (RelPath (Path (Untag b) Dir)))
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m (RelPath (Path (Untag b) Dir))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

resolveFile ::
  forall e e0 m.
  (MonadIO m) =>
  PathTo e0 Abs Dir ->
  FilePath ->
  m (PathTo e Abs File)
resolveFile :: forall {k} {k} (e :: k) (e0 :: k) (m :: * -> *).
MonadIO m =>
PathTo e0 Abs Dir -> String -> m (PathTo e Abs File)
resolveFile = (m (Path (Untag 'Abs) File) -> m (PathTo e 'Abs File))
-> (String -> m (Path (Untag 'Abs) File))
-> String
-> m (PathTo e 'Abs File)
forall a b. (a -> b) -> (String -> a) -> String -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Path (Untag 'Abs) File -> PathTo e 'Abs File)
-> m (Path (Untag 'Abs) File) -> m (PathTo e 'Abs File)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag 'Abs) File -> PathTo e 'Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo) ((String -> m (Path (Untag 'Abs) File))
 -> String -> m (PathTo e 'Abs File))
-> (PathTo e0 Abs Dir -> String -> m (Path (Untag 'Abs) File))
-> PathTo e0 Abs Dir
-> String
-> m (PathTo e 'Abs File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir -> String -> m (Path Abs File)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> String -> m (Path Abs File)
P.resolveFile (Path Abs Dir -> String -> m (Path Abs File))
-> (PathTo e0 Abs Dir -> Path Abs Dir)
-> PathTo e0 Abs Dir
-> String
-> m (Path Abs File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e0 Abs Dir -> Path Abs Dir
PathTo e0 Abs Dir -> Path (Untag Abs) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

resolveFile' :: forall e m. (MonadIO m) => FilePath -> m (PathTo e Abs File)
resolveFile' :: forall {k} (e :: k) (m :: * -> *).
MonadIO m =>
String -> m (PathTo e Abs File)
resolveFile' = (Path (Untag Abs) File -> PathTo e Abs File)
-> m (Path (Untag Abs) File) -> m (PathTo e Abs File)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) File -> PathTo e Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) File) -> m (PathTo e Abs File))
-> (String -> m (Path (Untag Abs) File))
-> String
-> m (PathTo e Abs File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> m (Path Abs File)
String -> m (Path (Untag Abs) File)
forall (m :: * -> *). MonadIO m => String -> m (Path Abs File)
P.resolveFile'

resolveDir ::
  forall e e0 m.
  (MonadIO m) =>
  PathTo e0 Abs Dir ->
  FilePath ->
  m (PathTo e Abs Dir)
resolveDir :: forall {k} {k} (e :: k) (e0 :: k) (m :: * -> *).
MonadIO m =>
PathTo e0 Abs Dir -> String -> m (PathTo e Abs Dir)
resolveDir = (m (Path (Untag 'Abs) Dir) -> m (PathTo e 'Abs Dir))
-> (String -> m (Path (Untag 'Abs) Dir))
-> String
-> m (PathTo e 'Abs Dir)
forall a b. (a -> b) -> (String -> a) -> String -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Path (Untag 'Abs) Dir -> PathTo e 'Abs Dir)
-> m (Path (Untag 'Abs) Dir) -> m (PathTo e 'Abs Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag 'Abs) Dir -> PathTo e 'Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo) ((String -> m (Path (Untag 'Abs) Dir))
 -> String -> m (PathTo e 'Abs Dir))
-> (PathTo e0 Abs Dir -> String -> m (Path (Untag 'Abs) Dir))
-> PathTo e0 Abs Dir
-> String
-> m (PathTo e 'Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir -> String -> m (Path Abs Dir)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> String -> m (Path Abs Dir)
P.resolveDir (Path Abs Dir -> String -> m (Path Abs Dir))
-> (PathTo e0 Abs Dir -> Path Abs Dir)
-> PathTo e0 Abs Dir
-> String
-> m (Path Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e0 Abs Dir -> Path Abs Dir
PathTo e0 Abs Dir -> Path (Untag Abs) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

resolveDir' :: forall e m. (MonadIO m) => FilePath -> m (PathTo e Abs Dir)
resolveDir' :: forall {k} (e :: k) (m :: * -> *).
MonadIO m =>
String -> m (PathTo e Abs Dir)
resolveDir' = (Path (Untag Abs) Dir -> PathTo e Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) Dir -> PathTo e Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) Dir) -> m (PathTo e Abs Dir))
-> (String -> m (Path (Untag Abs) Dir))
-> String
-> m (PathTo e Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> m (Path Abs Dir)
String -> m (Path (Untag Abs) Dir)
forall (m :: * -> *). MonadIO m => String -> m (Path Abs Dir)
P.resolveDir'

removeFile :: (MonadIO m) => PathTo e b File -> m ()
removeFile :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b File -> m ()
removeFile = Path (Untag b) File -> m ()
forall (m :: * -> *) b. MonadIO m => Path b File -> m ()
P.removeFile (Path (Untag b) File -> m ())
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

renameFile :: (MonadIO m) => PathTo e b0 File -> PathTo e b1 File -> m ()
renameFile :: forall {k} (m :: * -> *) (e :: k) (b0 :: Base k) (b1 :: Base k).
MonadIO m =>
PathTo e b0 File -> PathTo e b1 File -> m ()
renameFile (PathTo Path (Untag b0) File
p) = Path (Untag b0) File -> Path (Untag b1) File -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
P.renameFile Path (Untag b0) File
p (Path (Untag b1) File -> m ())
-> (PathTo e b1 File -> Path (Untag b1) File)
-> PathTo e b1 File
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b1 File -> Path (Untag b1) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

copyFile :: (MonadIO m) => PathTo e0 b0 File -> PathTo e1 b1 File -> m ()
copyFile :: forall {k} {k} (m :: * -> *) (e0 :: k) (b0 :: Base k) (e1 :: k)
       (b1 :: Base k).
MonadIO m =>
PathTo e0 b0 File -> PathTo e1 b1 File -> m ()
copyFile (PathTo Path (Untag b0) File
p) = Path (Untag b0) File -> Path (Untag b1) File -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
P.copyFile Path (Untag b0) File
p (Path (Untag b1) File -> m ())
-> (PathTo e1 b1 File -> Path (Untag b1) File)
-> PathTo e1 b1 File
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e1 b1 File -> Path (Untag b1) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

getFileSize :: (MonadIO m) => PathTo e b File -> m Integer
getFileSize :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b File -> m Integer
getFileSize = Path (Untag b) File -> m Integer
forall (m :: * -> *) b. MonadIO m => Path b File -> m Integer
P.getFileSize (Path (Untag b) File -> m Integer)
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

findExecutable :: (MonadIO m) => PathTo e (RelTo b) File -> m (Maybe (PathTo e Abs File))
findExecutable :: forall {k} (m :: * -> *) (e :: k) (b :: k).
MonadIO m =>
PathTo e (RelTo b) File -> m (Maybe (PathTo e Abs File))
findExecutable = (Maybe (Path Abs File) -> Maybe (PathTo e Abs File))
-> m (Maybe (Path Abs File)) -> m (Maybe (PathTo e 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 (Path Abs File) -> Maybe (PathTo e Abs File)
forall a b. Coercible a b => a -> b
coerce (m (Maybe (Path Abs File)) -> m (Maybe (PathTo e Abs File)))
-> (PathTo e (RelTo b) File -> m (Maybe (Path Abs File)))
-> PathTo e (RelTo b) File
-> m (Maybe (PathTo e Abs File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Rel File -> m (Maybe (Path Abs File))
forall (m :: * -> *).
MonadIO m =>
Path Rel File -> m (Maybe (Path Abs File))
P.findExecutable (Path Rel File -> m (Maybe (Path Abs File)))
-> (PathTo e (RelTo b) File -> Path Rel File)
-> PathTo e (RelTo b) File
-> m (Maybe (Path Abs File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e (RelTo b) File -> Path Rel File
PathTo e (RelTo b) File -> Path (Untag (RelTo b)) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

findFile ::
  (MonadIO m) =>
  [PathTo dir b Dir] ->
  PathTo e (RelTo dir) File ->
  m (Maybe (PathTo e Abs File))
findFile :: forall {k} (m :: * -> *) (dir :: k) (b :: Base k) (e :: k).
MonadIO m =>
[PathTo dir b Dir]
-> PathTo e (RelTo dir) File -> m (Maybe (PathTo e Abs File))
findFile [PathTo dir b Dir]
dirs = (Maybe (Path Abs File) -> Maybe (PathTo e Abs File))
-> m (Maybe (Path Abs File)) -> m (Maybe (PathTo e 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 (Path Abs File) -> Maybe (PathTo e Abs File)
forall a b. Coercible a b => a -> b
coerce (m (Maybe (Path Abs File)) -> m (Maybe (PathTo e Abs File)))
-> (PathTo e (RelTo dir) File -> m (Maybe (Path Abs File)))
-> PathTo e (RelTo dir) File
-> m (Maybe (PathTo e Abs File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Path Any Dir] -> Path Rel File -> m (Maybe (Path Abs File))
forall (m :: * -> *) b.
MonadIO m =>
[Path b Dir] -> Path Rel File -> m (Maybe (Path Abs File))
P.findFile ([PathTo dir b Dir] -> [Path Any Dir]
forall a b. Coercible a b => a -> b
coerce [PathTo dir b Dir]
dirs) (Path Rel File -> m (Maybe (Path Abs File)))
-> (PathTo e (RelTo dir) File -> Path Rel File)
-> PathTo e (RelTo dir) File
-> m (Maybe (Path Abs File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e (RelTo dir) File -> Path Rel File
PathTo e (RelTo dir) File -> Path (Untag (RelTo dir)) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

findFiles ::
  (MonadIO m) =>
  [PathTo dir b Dir] ->
  PathTo e (RelTo dir) File ->
  m [PathTo e Abs File]
findFiles :: forall {k} (m :: * -> *) (dir :: k) (b :: Base k) (e :: k).
MonadIO m =>
[PathTo dir b Dir]
-> PathTo e (RelTo dir) File -> m [PathTo e Abs File]
findFiles [PathTo dir b Dir]
dirs = ([Path Abs File] -> [PathTo e Abs File])
-> m [Path Abs File] -> m [PathTo e Abs File]
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Path Abs File] -> [PathTo e Abs File]
forall a b. Coercible a b => a -> b
coerce (m [Path Abs File] -> m [PathTo e Abs File])
-> (PathTo e (RelTo dir) File -> m [Path Abs File])
-> PathTo e (RelTo dir) File
-> m [PathTo e Abs File]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Path Any Dir] -> Path Rel File -> m [Path Abs File]
forall (m :: * -> *) b.
MonadIO m =>
[Path b Dir] -> Path Rel File -> m [Path Abs File]
P.findFiles ([PathTo dir b Dir] -> [Path Any Dir]
forall a b. Coercible a b => a -> b
coerce [PathTo dir b Dir]
dirs) (Path Rel File -> m [Path Abs File])
-> (PathTo e (RelTo dir) File -> Path Rel File)
-> PathTo e (RelTo dir) File
-> m [Path Abs File]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e (RelTo dir) File -> Path Rel File
PathTo e (RelTo dir) File -> Path (Untag (RelTo dir)) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

findFilesWith ::
  (MonadIO m) =>
  (PathTo e Abs File -> m Bool) ->
  [PathTo dir b Dir] ->
  PathTo e (RelTo dir) File ->
  m [PathTo e Abs File]
findFilesWith :: forall {k} (m :: * -> *) (e :: k) (dir :: k) (b :: Base k).
MonadIO m =>
(PathTo e Abs File -> m Bool)
-> [PathTo dir b Dir]
-> PathTo e (RelTo dir) File
-> m [PathTo e Abs File]
findFilesWith PathTo e Abs File -> m Bool
p [PathTo dir b Dir]
dirs =
  ([Path Abs File] -> [PathTo e Abs File])
-> m [Path Abs File] -> m [PathTo e Abs File]
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Path Abs File] -> [PathTo e Abs File]
forall a b. Coercible a b => a -> b
coerce (m [Path Abs File] -> m [PathTo e Abs File])
-> (PathTo e (RelTo dir) File -> m [Path Abs File])
-> PathTo e (RelTo dir) File
-> m [PathTo e Abs File]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Path Abs File -> m Bool)
-> [Path Any 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]
P.findFilesWith (PathTo e Abs File -> m Bool
p (PathTo e Abs File -> m Bool)
-> (Path (Untag Abs) File -> PathTo e Abs File)
-> Path (Untag Abs) File
-> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag Abs) File -> PathTo e Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo) ([PathTo dir b Dir] -> [Path Any Dir]
forall a b. Coercible a b => a -> b
coerce [PathTo dir b Dir]
dirs) (Path Rel File -> m [Path Abs File])
-> (PathTo e (RelTo dir) File -> Path Rel File)
-> PathTo e (RelTo dir) File
-> m [Path Abs File]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e (RelTo dir) File -> Path Rel File
PathTo e (RelTo dir) File -> Path (Untag (RelTo dir)) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

createFileLink :: (MonadIO m) => PathTo e b0 File -> PathTo e b1 File -> m ()
createFileLink :: forall {k} (m :: * -> *) (e :: k) (b0 :: Base k) (b1 :: Base k).
MonadIO m =>
PathTo e b0 File -> PathTo e b1 File -> m ()
createFileLink (PathTo Path (Untag b0) File
p) = Path (Untag b0) File -> Path (Untag b1) File -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
P.createFileLink Path (Untag b0) File
p (Path (Untag b1) File -> m ())
-> (PathTo e b1 File -> Path (Untag b1) File)
-> PathTo e b1 File
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b1 File -> Path (Untag b1) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

createDirLink :: (MonadIO m) => PathTo e b0 Dir -> PathTo e b1 Dir -> m ()
createDirLink :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) (b' :: Base k).
MonadIO m =>
PathTo e b Dir -> PathTo e b' Dir -> m ()
createDirLink (PathTo Path (Untag b0) Dir
p) = Path (Untag b0) Dir -> Path (Untag b1) Dir -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
P.createDirLink Path (Untag b0) Dir
p (Path (Untag b1) Dir -> m ())
-> (PathTo e b1 Dir -> Path (Untag b1) Dir)
-> PathTo e b1 Dir
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b1 Dir -> Path (Untag b1) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

removeDirLink :: (MonadIO m) => PathTo e b0 Dir -> m ()
removeDirLink :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m ()
removeDirLink = Path (Untag b0) Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
P.removeDirLink (Path (Untag b0) Dir -> m ())
-> (PathTo e b0 Dir -> Path (Untag b0) Dir)
-> PathTo e b0 Dir
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b0 Dir -> Path (Untag b0) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

getSymlinkTarget :: (MonadIO m) => PathTo e b t -> m FilePath
getSymlinkTarget :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> m String
getSymlinkTarget = Path (Untag b) t -> m String
forall (m :: * -> *) b t. MonadIO m => Path b t -> m String
P.getSymlinkTarget (Path (Untag b) t -> m String)
-> (PathTo e b t -> Path (Untag b) t) -> PathTo e b t -> m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

isSymlink :: (MonadIO m) => PathTo e b t -> m Bool
isSymlink :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> m Bool
isSymlink = Path (Untag b) t -> m Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
P.isSymlink (Path (Untag b) t -> m Bool)
-> (PathTo e b t -> Path (Untag b) t) -> PathTo e b t -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

withTempFile ::
  forall e e0 b m a.
  (MonadIO m, MonadMask m) =>
  PathTo e0 b Dir ->
  String ->
  (PathTo e Abs File -> Handle -> m a) ->
  m a
withTempFile :: forall {k} {k} (e :: k) (e0 :: k) (b :: Base k) (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
PathTo e0 b Dir
-> String -> (PathTo e Abs File -> Handle -> m a) -> m a
withTempFile (PathTo Path (Untag b) Dir
d) String
name PathTo e Abs File -> Handle -> m a
act = Path (Untag b) Dir
-> String -> (Path Abs File -> Handle -> m a) -> m a
forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> String -> (Path Abs File -> Handle -> m a) -> m a
P.withTempFile Path (Untag b) Dir
d String
name ((Path Abs File -> Handle -> m a) -> m a)
-> (Path Abs File -> Handle -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ PathTo e Abs File -> Handle -> m a
act (PathTo e Abs File -> Handle -> m a)
-> (Path (Untag Abs) File -> PathTo e Abs File)
-> Path (Untag Abs) File
-> Handle
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag Abs) File -> PathTo e Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo

withTempDir ::
  (MonadIO m, MonadMask m) =>
  PathTo e b Dir ->
  String ->
  (PathTo TempDir Abs Dir -> m a) ->
  m a
withTempDir :: forall {k} {k} (m :: * -> *) (e :: k) (b :: Base k) a.
(MonadIO m, MonadMask m) =>
PathTo e b Dir -> String -> (PathTo TempDir Abs Dir -> m a) -> m a
withTempDir (PathTo Path (Untag b) Dir
d) String
name PathTo TempDir Abs Dir -> m a
act = Path (Untag b) Dir -> String -> (Path Abs Dir -> m a) -> m a
forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> String -> (Path Abs Dir -> m a) -> m a
P.withTempDir Path (Untag b) Dir
d String
name ((Path Abs Dir -> m a) -> m a) -> (Path Abs Dir -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ PathTo TempDir Abs Dir -> m a
act (PathTo TempDir Abs Dir -> m a)
-> (Path (Untag Abs) Dir -> PathTo TempDir Abs Dir)
-> Path (Untag Abs) Dir
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag Abs) Dir -> PathTo TempDir Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo

withSystemTempFile ::
  forall e m a.
  (MonadIO m, MonadMask m) =>
  String ->
  (PathTo e Abs File -> Handle -> m a) ->
  m a
withSystemTempFile :: forall {k} (e :: k) (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
String -> (PathTo e Abs File -> Handle -> m a) -> m a
withSystemTempFile String
name PathTo e Abs File -> Handle -> m a
act = String -> (Path Abs File -> Handle -> m a) -> m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
String -> (Path Abs File -> Handle -> m a) -> m a
P.withSystemTempFile String
name ((Path Abs File -> Handle -> m a) -> m a)
-> (Path Abs File -> Handle -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ PathTo e Abs File -> Handle -> m a
act (PathTo e Abs File -> Handle -> m a)
-> (Path (Untag Abs) File -> PathTo e Abs File)
-> Path (Untag Abs) File
-> Handle
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag Abs) File -> PathTo e Abs File
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo

withSystemTempDir ::
  (MonadIO m, MonadMask m) =>
  String ->
  (PathTo TempDir Abs Dir -> m a) ->
  m a
withSystemTempDir :: forall {k} (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
String -> (PathTo TempDir Abs Dir -> m a) -> m a
withSystemTempDir String
name PathTo TempDir Abs Dir -> m a
act = String -> (Path Abs Dir -> m a) -> m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
String -> (Path Abs Dir -> m a) -> m a
P.withSystemTempDir String
name ((Path Abs Dir -> m a) -> m a) -> (Path Abs Dir -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ PathTo TempDir Abs Dir -> m a
act (PathTo TempDir Abs Dir -> m a)
-> (Path (Untag Abs) Dir -> PathTo TempDir Abs Dir)
-> Path (Untag Abs) Dir
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag Abs) Dir -> PathTo TempDir Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo

openTempFile ::
  forall e e0 b m.
  (MonadIO m) =>
  PathTo e0 b Dir ->
  String ->
  m (PathTo e Abs File, Handle)
openTempFile :: forall {k} {k} (e :: k) (e0 :: k) (b :: Base k) (m :: * -> *).
MonadIO m =>
PathTo e0 b Dir -> String -> m (PathTo e Abs File, Handle)
openTempFile (PathTo Path (Untag b) Dir
p) = ((Path Abs File, Handle) -> (PathTo e Abs File, Handle))
-> m (Path Abs File, Handle) -> m (PathTo e Abs File, Handle)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Path Abs File, Handle) -> (PathTo e Abs File, Handle)
forall a b. Coercible a b => a -> b
coerce (m (Path Abs File, Handle) -> m (PathTo e Abs File, Handle))
-> (String -> m (Path Abs File, Handle))
-> String
-> m (PathTo e Abs File, Handle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> String -> m (Path Abs File, Handle)
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> String -> m (Path Abs File, Handle)
P.openTempFile Path (Untag b) Dir
p

openBinaryTempFile ::
  forall e e0 b m.
  (MonadIO m) =>
  PathTo e0 b Dir ->
  String ->
  m (PathTo e Abs File, Handle)
openBinaryTempFile :: forall {k} {k} (e :: k) (e0 :: k) (b :: Base k) (m :: * -> *).
MonadIO m =>
PathTo e0 b Dir -> String -> m (PathTo e Abs File, Handle)
openBinaryTempFile (PathTo Path (Untag b) Dir
p) = ((Path Abs File, Handle) -> (PathTo e Abs File, Handle))
-> m (Path Abs File, Handle) -> m (PathTo e Abs File, Handle)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Path Abs File, Handle) -> (PathTo e Abs File, Handle)
forall a b. Coercible a b => a -> b
coerce (m (Path Abs File, Handle) -> m (PathTo e Abs File, Handle))
-> (String -> m (Path Abs File, Handle))
-> String
-> m (PathTo e Abs File, Handle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> String -> m (Path Abs File, Handle)
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> String -> m (Path Abs File, Handle)
P.openBinaryTempFile Path (Untag b) Dir
p

createTempDir :: (MonadIO m) => PathTo e b Dir -> String -> m (PathTo TempDir Abs Dir)
createTempDir :: forall {k} {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> String -> m (PathTo TempDir Abs Dir)
createTempDir (PathTo Path (Untag b) Dir
p) = (Path (Untag Abs) Dir -> PathTo TempDir Abs Dir)
-> m (Path (Untag Abs) Dir) -> m (PathTo TempDir Abs Dir)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path (Untag Abs) Dir -> PathTo TempDir Abs Dir
forall {k} (entity :: k) (pk :: Base k) t.
Path (Untag pk) t -> PathTo entity pk t
PathTo (m (Path (Untag Abs) Dir) -> m (PathTo TempDir Abs Dir))
-> (String -> m (Path (Untag Abs) Dir))
-> String
-> m (PathTo TempDir Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path (Untag b) Dir -> String -> m (Path Abs Dir)
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> String -> m (Path Abs Dir)
P.createTempDir Path (Untag b) Dir
p

doesPathExist :: (MonadIO m) => PathTo e b t -> m Bool
doesPathExist :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> m Bool
doesPathExist = Path (Untag b) t -> m Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
P.doesPathExist (Path (Untag b) t -> m Bool)
-> (PathTo e b t -> Path (Untag b) t) -> PathTo e b t -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

doesFileExist :: (MonadIO m) => PathTo e b File -> m Bool
doesFileExist :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b File -> m Bool
doesFileExist = Path (Untag b) File -> m Bool
forall (m :: * -> *) b. MonadIO m => Path b File -> m Bool
P.doesFileExist (Path (Untag b) File -> m Bool)
-> (PathTo e b File -> Path (Untag b) File)
-> PathTo e b File
-> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b File -> Path (Untag b) File
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

doesDirExist :: (MonadIO m) => PathTo e b Dir -> m Bool
doesDirExist :: forall {k} (m :: * -> *) (e :: k) (b :: Base k).
MonadIO m =>
PathTo e b Dir -> m Bool
doesDirExist = Path (Untag b) Dir -> m Bool
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m Bool
P.doesDirExist (Path (Untag b) Dir -> m Bool)
-> (PathTo e b Dir -> Path (Untag b) Dir)
-> PathTo e b Dir
-> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b Dir -> Path (Untag b) Dir
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

isLocationOccupied :: (MonadIO m) => PathTo e b t -> m Bool
isLocationOccupied :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> m Bool
isLocationOccupied = Path (Untag b) t -> m Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
P.isLocationOccupied (Path (Untag b) t -> m Bool)
-> (PathTo e b t -> Path (Untag b) t) -> PathTo e b t -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

getPermissions :: (MonadIO m) => PathTo e b t -> m Permissions
getPermissions :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> m Permissions
getPermissions = Path (Untag b) t -> m Permissions
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Permissions
P.getPermissions (Path (Untag b) t -> m Permissions)
-> (PathTo e b t -> Path (Untag b) t)
-> PathTo e b t
-> m Permissions
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

setPermissions :: (MonadIO m) => PathTo e b t -> Permissions -> m ()
setPermissions :: forall {k} (m :: * -> *) (e :: k) (b :: Base k) t.
MonadIO m =>
PathTo e b t -> Permissions -> m ()
setPermissions = Path (Untag b) t -> Permissions -> m ()
forall (m :: * -> *) b t.
MonadIO m =>
Path b t -> Permissions -> m ()
P.setPermissions (Path (Untag b) t -> Permissions -> m ())
-> (PathTo e b t -> Path (Untag b) t)
-> PathTo e b t
-> Permissions
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e b t -> Path (Untag b) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

copyPermissions :: (MonadIO m) => PathTo e0 b0 t0 -> PathTo e1 b1 t1 -> m ()
copyPermissions :: forall {k} {k} (m :: * -> *) (e0 :: k) (b0 :: Base k) t0 (e1 :: k)
       (b1 :: Base k) t1.
MonadIO m =>
PathTo e0 b0 t0 -> PathTo e1 b1 t1 -> m ()
copyPermissions (PathTo Path (Untag b0) t0
p) = Path (Untag b0) t0 -> Path (Untag b1) t1 -> m ()
forall (m :: * -> *) b0 t0 b1 t1.
MonadIO m =>
Path b0 t0 -> Path b1 t1 -> m ()
P.copyPermissions Path (Untag b0) t0
p (Path (Untag b1) t1 -> m ())
-> (PathTo e1 b1 t1 -> Path (Untag b1) t1)
-> PathTo e1 b1 t1
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo e1 b1 t1 -> Path (Untag b1) t1
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

getAccessTime :: (MonadIO m) => PathTo entity pk t -> m UTCTime
getAccessTime :: forall {k} (m :: * -> *) (entity :: k) (pk :: Base k) t.
MonadIO m =>
PathTo entity pk t -> m UTCTime
getAccessTime = Path (Untag pk) t -> m UTCTime
forall (m :: * -> *) b t. MonadIO m => Path b t -> m UTCTime
P.getAccessTime (Path (Untag pk) t -> m UTCTime)
-> (PathTo entity pk t -> Path (Untag pk) t)
-> PathTo entity pk t
-> m UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo entity pk t -> Path (Untag pk) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

setAccessTime :: (MonadIO m) => PathTo entity pk t -> UTCTime -> m ()
setAccessTime :: forall {k} (m :: * -> *) (entity :: k) (pk :: Base k) t.
MonadIO m =>
PathTo entity pk t -> UTCTime -> m ()
setAccessTime = Path (Untag pk) t -> UTCTime -> m ()
forall (m :: * -> *) b t. MonadIO m => Path b t -> UTCTime -> m ()
P.setAccessTime (Path (Untag pk) t -> UTCTime -> m ())
-> (PathTo entity pk t -> Path (Untag pk) t)
-> PathTo entity pk t
-> UTCTime
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo entity pk t -> Path (Untag pk) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

getModificationTime :: (MonadIO m) => PathTo entity pk t -> m UTCTime
getModificationTime :: forall {k} (m :: * -> *) (entity :: k) (pk :: Base k) t.
MonadIO m =>
PathTo entity pk t -> m UTCTime
getModificationTime = Path (Untag pk) t -> m UTCTime
forall (m :: * -> *) b t. MonadIO m => Path b t -> m UTCTime
P.getModificationTime (Path (Untag pk) t -> m UTCTime)
-> (PathTo entity pk t -> Path (Untag pk) t)
-> PathTo entity pk t
-> m UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo entity pk t -> Path (Untag pk) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath

setModificationTime :: (MonadIO m) => PathTo entity pk t -> UTCTime -> m ()
setModificationTime :: forall {k} (m :: * -> *) (entity :: k) (pk :: Base k) t.
MonadIO m =>
PathTo entity pk t -> UTCTime -> m ()
setModificationTime = Path (Untag pk) t -> UTCTime -> m ()
forall (m :: * -> *) b t. MonadIO m => Path b t -> UTCTime -> m ()
P.setModificationTime (Path (Untag pk) t -> UTCTime -> m ())
-> (PathTo entity pk t -> Path (Untag pk) t)
-> PathTo entity pk t
-> UTCTime
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTo entity pk t -> Path (Untag pk) t
forall {k} (entity :: k) (pk :: Base k) t.
PathTo entity pk t -> Path (Untag pk) t
untagPath