{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveLift #-}

module StrongPath.Internal
  ( Path (..),
    RelPathPrefix (..),
    Abs,
    Rel,
    Dir,
    File,
    Posix,
    Windows,
    System,
    Path',
    File',
    Dir',
    Rel',
    parseRelFileFP,
    parseRelDirFP,
    impossible,
    prefixNumParentDirs,
    relPathNumParentDirs,
    relPathPrefix,
    extractRelPathPrefix,
  )
where

import Control.Monad.Catch (MonadThrow, throwM)
import Data.Data (Data)
import Language.Haskell.TH.Syntax (Lift)
import qualified Path as P
import qualified Path.Posix as PP
import qualified Path.Windows as PW

-- | Strongly typed file path. Central type of the "StrongPath".
--
--   [@s@]: __Standard__: Posix or windows. Can be fixed ('Posix', 'Windows') or determined by the system ('System').
--
--   [@b@]: __Base__: Absolute ('Abs') or relative ('Rel').
--
--   [@t@]: __Type__: File ('File') or directory ('Dir').
--
-- Some examples:
--
-- > Path System (Rel HomeDir) (File FooFile)
-- > Path System Abs (Dir HomeDir)
-- > Path Posix (Rel ProjectRoot) (File ())
data Path s b t
  = -- NOTE: Relative paths can be sometimes be tricky when being reasoned about in the internal library code,
    --   when reconstructing them and working with them, due to RelPathPrefix and edge cases like ".", "..".
    --
    --   For example if original relative path was "..", we will parse it into RelDir "." ParentDir 1.
    --   Then it is important to be aware that this should be regarded as "..", and not "../.".
    --   In some functions like `basename` it is important to be aware of this.
    --
    --   Also, Path.Path can't hold empty path, so we can count on paths not to be empty.
    --
    --   And Path.Path can't store "." as file, only as dir, so that is also good to know.
    --
    --   I wonder if we could find a better way to represent path internaly, a way which would encode
    --   tricky situations explicitly, or maybe some kind of lower-level interface around it that would encode
    --   things like "paths can't be empty", "dir can be '.' but file can't", and similar.
    --   But maybe the solution would just be too complicated.
    -- System
    RelDir (P.Path P.Rel P.Dir) RelPathPrefix
  | RelFile (P.Path P.Rel P.File) RelPathPrefix
  | AbsDir (P.Path P.Abs P.Dir)
  | AbsFile (P.Path P.Abs P.File)
  | -- Windows
    RelDirW (PW.Path PW.Rel PW.Dir) RelPathPrefix
  | RelFileW (PW.Path PW.Rel PW.File) RelPathPrefix
  | AbsDirW (PW.Path PW.Abs PW.Dir)
  | AbsFileW (PW.Path PW.Abs PW.File)
  | -- Posix
    RelDirP (PP.Path PP.Rel PP.Dir) RelPathPrefix
  | RelFileP (PP.Path PP.Rel PP.File) RelPathPrefix
  | AbsDirP (PP.Path PP.Abs PP.Dir)
  | AbsFileP (PP.Path PP.Abs PP.File)
  deriving (Int -> Path s b t -> ShowS
[Path s b t] -> ShowS
Path s b t -> [Char]
(Int -> Path s b t -> ShowS)
-> (Path s b t -> [Char])
-> ([Path s b t] -> ShowS)
-> Show (Path s b t)
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
forall s b t. Int -> Path s b t -> ShowS
forall s b t. [Path s b t] -> ShowS
forall s b t. Path s b t -> [Char]
$cshowsPrec :: forall s b t. Int -> Path s b t -> ShowS
showsPrec :: Int -> Path s b t -> ShowS
$cshow :: forall s b t. Path s b t -> [Char]
show :: Path s b t -> [Char]
$cshowList :: forall s b t. [Path s b t] -> ShowS
showList :: [Path s b t] -> ShowS
Show, Path s b t -> Path s b t -> Bool
(Path s b t -> Path s b t -> Bool)
-> (Path s b t -> Path s b t -> Bool) -> Eq (Path s b t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall s b t. Path s b t -> Path s b t -> Bool
$c== :: forall s b t. Path s b t -> Path s b t -> Bool
== :: Path s b t -> Path s b t -> Bool
$c/= :: forall s b t. Path s b t -> Path s b t -> Bool
/= :: Path s b t -> Path s b t -> Bool
Eq, (forall (m :: * -> *). Quote m => Path s b t -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    Path s b t -> Code m (Path s b t))
-> Lift (Path s b t)
forall s b t (m :: * -> *). Quote m => Path s b t -> m Exp
forall s b t (m :: * -> *).
Quote m =>
Path s b t -> Code m (Path s b t)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Path s b t -> m Exp
forall (m :: * -> *). Quote m => Path s b t -> Code m (Path s b t)
$clift :: forall s b t (m :: * -> *). Quote m => Path s b t -> m Exp
lift :: forall (m :: * -> *). Quote m => Path s b t -> m Exp
$cliftTyped :: forall s b t (m :: * -> *).
Quote m =>
Path s b t -> Code m (Path s b t)
liftTyped :: forall (m :: * -> *). Quote m => Path s b t -> Code m (Path s b t)
Lift, Typeable (Path s b t)
Typeable (Path s b t) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Path s b t -> c (Path s b t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Path s b t))
-> (Path s b t -> Constr)
-> (Path s b t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Path s b t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Path s b t)))
-> ((forall b. Data b => b -> b) -> Path s b t -> Path s b t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Path s b t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Path s b t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Path s b t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Path s b t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t))
-> Data (Path s b t)
Path s b t -> Constr
Path s b t -> DataType
(forall b. Data b => b -> b) -> Path s b t -> Path s b t
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Path s b t -> u
forall u. (forall d. Data d => d -> u) -> Path s b t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
forall s b t. (Data s, Data b, Data t) => Typeable (Path s b t)
forall s b t. (Data s, Data b, Data t) => Path s b t -> Constr
forall s b t. (Data s, Data b, Data t) => Path s b t -> DataType
forall s b t.
(Data s, Data b, Data t) =>
(forall b. Data b => b -> b) -> Path s b t -> Path s b t
forall s b t u.
(Data s, Data b, Data t) =>
Int -> (forall d. Data d => d -> u) -> Path s b t -> u
forall s b t u.
(Data s, Data b, Data t) =>
(forall d. Data d => d -> u) -> Path s b t -> [u]
forall s b t r r'.
(Data s, Data b, Data t) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
forall s b t r r'.
(Data s, Data b, Data t) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
forall s b t (m :: * -> *).
(Data s, Data b, Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
forall s b t (m :: * -> *).
(Data s, Data b, Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
forall s b t (c :: * -> *).
(Data s, Data b, Data t) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Path s b t)
forall s b t (c :: * -> *).
(Data s, Data b, Data t) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Path s b t -> c (Path s b t)
forall s b t (t :: * -> *) (c :: * -> *).
(Data s, Data b, Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Path s b t))
forall s b t (t :: * -> * -> *) (c :: * -> *).
(Data s, Data b, Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Path s b t))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Path s b t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Path s b t -> c (Path s b t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Path s b t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Path s b t))
$cgfoldl :: forall s b t (c :: * -> *).
(Data s, Data b, Data t) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Path s b t -> c (Path s b t)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Path s b t -> c (Path s b t)
$cgunfold :: forall s b t (c :: * -> *).
(Data s, Data b, Data t) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Path s b t)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Path s b t)
$ctoConstr :: forall s b t. (Data s, Data b, Data t) => Path s b t -> Constr
toConstr :: Path s b t -> Constr
$cdataTypeOf :: forall s b t. (Data s, Data b, Data t) => Path s b t -> DataType
dataTypeOf :: Path s b t -> DataType
$cdataCast1 :: forall s b t (t :: * -> *) (c :: * -> *).
(Data s, Data b, Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Path s b t))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Path s b t))
$cdataCast2 :: forall s b t (t :: * -> * -> *) (c :: * -> *).
(Data s, Data b, Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Path s b t))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Path s b t))
$cgmapT :: forall s b t.
(Data s, Data b, Data t) =>
(forall b. Data b => b -> b) -> Path s b t -> Path s b t
gmapT :: (forall b. Data b => b -> b) -> Path s b t -> Path s b t
$cgmapQl :: forall s b t r r'.
(Data s, Data b, Data t) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
$cgmapQr :: forall s b t r r'.
(Data s, Data b, Data t) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Path s b t -> r
$cgmapQ :: forall s b t u.
(Data s, Data b, Data t) =>
(forall d. Data d => d -> u) -> Path s b t -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Path s b t -> [u]
$cgmapQi :: forall s b t u.
(Data s, Data b, Data t) =>
Int -> (forall d. Data d => d -> u) -> Path s b t -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Path s b t -> u
$cgmapM :: forall s b t (m :: * -> *).
(Data s, Data b, Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
$cgmapMp :: forall s b t (m :: * -> *).
(Data s, Data b, Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
$cgmapMo :: forall s b t (m :: * -> *).
(Data s, Data b, Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Path s b t -> m (Path s b t)
Data)

data RelPathPrefix
  = -- | ../, Int saying how many times it repeats.
    ParentDir Int
  | NoPrefix
  deriving (Int -> RelPathPrefix -> ShowS
[RelPathPrefix] -> ShowS
RelPathPrefix -> [Char]
(Int -> RelPathPrefix -> ShowS)
-> (RelPathPrefix -> [Char])
-> ([RelPathPrefix] -> ShowS)
-> Show RelPathPrefix
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelPathPrefix -> ShowS
showsPrec :: Int -> RelPathPrefix -> ShowS
$cshow :: RelPathPrefix -> [Char]
show :: RelPathPrefix -> [Char]
$cshowList :: [RelPathPrefix] -> ShowS
showList :: [RelPathPrefix] -> ShowS
Show, RelPathPrefix -> RelPathPrefix -> Bool
(RelPathPrefix -> RelPathPrefix -> Bool)
-> (RelPathPrefix -> RelPathPrefix -> Bool) -> Eq RelPathPrefix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelPathPrefix -> RelPathPrefix -> Bool
== :: RelPathPrefix -> RelPathPrefix -> Bool
$c/= :: RelPathPrefix -> RelPathPrefix -> Bool
/= :: RelPathPrefix -> RelPathPrefix -> Bool
Eq, (forall (m :: * -> *). Quote m => RelPathPrefix -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    RelPathPrefix -> Code m RelPathPrefix)
-> Lift RelPathPrefix
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => RelPathPrefix -> m Exp
forall (m :: * -> *).
Quote m =>
RelPathPrefix -> Code m RelPathPrefix
$clift :: forall (m :: * -> *). Quote m => RelPathPrefix -> m Exp
lift :: forall (m :: * -> *). Quote m => RelPathPrefix -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
RelPathPrefix -> Code m RelPathPrefix
liftTyped :: forall (m :: * -> *).
Quote m =>
RelPathPrefix -> Code m RelPathPrefix
Lift, Typeable RelPathPrefix
Typeable RelPathPrefix =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RelPathPrefix -> c RelPathPrefix)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RelPathPrefix)
-> (RelPathPrefix -> Constr)
-> (RelPathPrefix -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RelPathPrefix))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RelPathPrefix))
-> ((forall b. Data b => b -> b) -> RelPathPrefix -> RelPathPrefix)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r)
-> (forall u. (forall d. Data d => d -> u) -> RelPathPrefix -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RelPathPrefix -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix)
-> Data RelPathPrefix
RelPathPrefix -> Constr
RelPathPrefix -> DataType
(forall b. Data b => b -> b) -> RelPathPrefix -> RelPathPrefix
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RelPathPrefix -> u
forall u. (forall d. Data d => d -> u) -> RelPathPrefix -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelPathPrefix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelPathPrefix -> c RelPathPrefix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelPathPrefix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RelPathPrefix)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelPathPrefix -> c RelPathPrefix
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelPathPrefix -> c RelPathPrefix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelPathPrefix
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelPathPrefix
$ctoConstr :: RelPathPrefix -> Constr
toConstr :: RelPathPrefix -> Constr
$cdataTypeOf :: RelPathPrefix -> DataType
dataTypeOf :: RelPathPrefix -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelPathPrefix)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelPathPrefix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RelPathPrefix)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RelPathPrefix)
$cgmapT :: (forall b. Data b => b -> b) -> RelPathPrefix -> RelPathPrefix
gmapT :: (forall b. Data b => b -> b) -> RelPathPrefix -> RelPathPrefix
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RelPathPrefix -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RelPathPrefix -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RelPathPrefix -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RelPathPrefix -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RelPathPrefix -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelPathPrefix -> m RelPathPrefix
Data)

-- | Describes 'Path' base as absolute.
data Abs deriving ((forall (m :: * -> *). Quote m => Abs -> m Exp)
-> (forall (m :: * -> *). Quote m => Abs -> Code m Abs) -> Lift Abs
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Abs -> m Exp
forall (m :: * -> *). Quote m => Abs -> Code m Abs
$clift :: forall (m :: * -> *). Quote m => Abs -> m Exp
lift :: forall (m :: * -> *). Quote m => Abs -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Abs -> Code m Abs
liftTyped :: forall (m :: * -> *). Quote m => Abs -> Code m Abs
Lift, Typeable Abs
Typeable Abs =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Abs -> c Abs)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Abs)
-> (Abs -> Constr)
-> (Abs -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Abs))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Abs))
-> ((forall b. Data b => b -> b) -> Abs -> Abs)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r)
-> (forall u. (forall d. Data d => d -> u) -> Abs -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Abs -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Abs -> m Abs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Abs -> m Abs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Abs -> m Abs)
-> Data Abs
Abs -> Constr
Abs -> DataType
(forall b. Data b => b -> b) -> Abs -> Abs
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Abs -> u
forall u. (forall d. Data d => d -> u) -> Abs -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abs -> c Abs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Abs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Abs)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abs -> c Abs
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abs -> c Abs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abs
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abs
$ctoConstr :: Abs -> Constr
toConstr :: Abs -> Constr
$cdataTypeOf :: Abs -> DataType
dataTypeOf :: Abs -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Abs)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Abs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Abs)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Abs)
$cgmapT :: (forall b. Data b => b -> b) -> Abs -> Abs
gmapT :: (forall b. Data b => b -> b) -> Abs -> Abs
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Abs -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Abs -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Abs -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Abs -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Abs -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abs -> m Abs
Data)

-- | Describes 'Path' base as relative to the directory @dir@.
data Rel dir deriving ((forall (m :: * -> *). Quote m => Rel dir -> m Exp)
-> (forall (m :: * -> *). Quote m => Rel dir -> Code m (Rel dir))
-> Lift (Rel dir)
forall dir (m :: * -> *). Quote m => Rel dir -> m Exp
forall dir (m :: * -> *). Quote m => Rel dir -> Code m (Rel dir)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Rel dir -> m Exp
forall (m :: * -> *). Quote m => Rel dir -> Code m (Rel dir)
$clift :: forall dir (m :: * -> *). Quote m => Rel dir -> m Exp
lift :: forall (m :: * -> *). Quote m => Rel dir -> m Exp
$cliftTyped :: forall dir (m :: * -> *). Quote m => Rel dir -> Code m (Rel dir)
liftTyped :: forall (m :: * -> *). Quote m => Rel dir -> Code m (Rel dir)
Lift, Typeable (Rel dir)
Typeable (Rel dir) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Rel dir -> c (Rel dir))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rel dir))
-> (Rel dir -> Constr)
-> (Rel dir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rel dir)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rel dir)))
-> ((forall b. Data b => b -> b) -> Rel dir -> Rel dir)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Rel dir -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Rel dir -> r)
-> (forall u. (forall d. Data d => d -> u) -> Rel dir -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Rel dir -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir))
-> Data (Rel dir)
Rel dir -> Constr
Rel dir -> DataType
(forall b. Data b => b -> b) -> Rel dir -> Rel dir
forall dir. Data dir => Typeable (Rel dir)
forall dir. Data dir => Rel dir -> Constr
forall dir. Data dir => Rel dir -> DataType
forall dir.
Data dir =>
(forall b. Data b => b -> b) -> Rel dir -> Rel dir
forall dir u.
Data dir =>
Int -> (forall d. Data d => d -> u) -> Rel dir -> u
forall dir u.
Data dir =>
(forall d. Data d => d -> u) -> Rel dir -> [u]
forall dir r r'.
Data dir =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
forall dir r r'.
Data dir =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
forall dir (m :: * -> *).
(Data dir, Monad m) =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
forall dir (m :: * -> *).
(Data dir, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
forall dir (c :: * -> *).
Data dir =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rel dir)
forall dir (c :: * -> *).
Data dir =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rel dir -> c (Rel dir)
forall dir (t :: * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Rel dir))
forall dir (t :: * -> * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rel dir))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Rel dir -> u
forall u. (forall d. Data d => d -> u) -> Rel dir -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rel dir)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rel dir -> c (Rel dir)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Rel dir))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rel dir))
$cgfoldl :: forall dir (c :: * -> *).
Data dir =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rel dir -> c (Rel dir)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rel dir -> c (Rel dir)
$cgunfold :: forall dir (c :: * -> *).
Data dir =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rel dir)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rel dir)
$ctoConstr :: forall dir. Data dir => Rel dir -> Constr
toConstr :: Rel dir -> Constr
$cdataTypeOf :: forall dir. Data dir => Rel dir -> DataType
dataTypeOf :: Rel dir -> DataType
$cdataCast1 :: forall dir (t :: * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Rel dir))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Rel dir))
$cdataCast2 :: forall dir (t :: * -> * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rel dir))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rel dir))
$cgmapT :: forall dir.
Data dir =>
(forall b. Data b => b -> b) -> Rel dir -> Rel dir
gmapT :: (forall b. Data b => b -> b) -> Rel dir -> Rel dir
$cgmapQl :: forall dir r r'.
Data dir =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
$cgmapQr :: forall dir r r'.
Data dir =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Rel dir -> r
$cgmapQ :: forall dir u.
Data dir =>
(forall d. Data d => d -> u) -> Rel dir -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Rel dir -> [u]
$cgmapQi :: forall dir u.
Data dir =>
Int -> (forall d. Data d => d -> u) -> Rel dir -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rel dir -> u
$cgmapM :: forall dir (m :: * -> *).
(Data dir, Monad m) =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
$cgmapMp :: forall dir (m :: * -> *).
(Data dir, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
$cgmapMo :: forall dir (m :: * -> *).
(Data dir, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rel dir -> m (Rel dir)
Data)

-- | Means that path points to a directory @dir@.
-- To use as a type in place of @dir@, we recommend creating an empty
-- data type representing the specific directory, e.g. @data ProjectRootDir@.
data Dir dir deriving ((forall (m :: * -> *). Quote m => Dir dir -> m Exp)
-> (forall (m :: * -> *). Quote m => Dir dir -> Code m (Dir dir))
-> Lift (Dir dir)
forall dir (m :: * -> *). Quote m => Dir dir -> m Exp
forall dir (m :: * -> *). Quote m => Dir dir -> Code m (Dir dir)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Dir dir -> m Exp
forall (m :: * -> *). Quote m => Dir dir -> Code m (Dir dir)
$clift :: forall dir (m :: * -> *). Quote m => Dir dir -> m Exp
lift :: forall (m :: * -> *). Quote m => Dir dir -> m Exp
$cliftTyped :: forall dir (m :: * -> *). Quote m => Dir dir -> Code m (Dir dir)
liftTyped :: forall (m :: * -> *). Quote m => Dir dir -> Code m (Dir dir)
Lift, Typeable (Dir dir)
Typeable (Dir dir) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Dir dir -> c (Dir dir))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Dir dir))
-> (Dir dir -> Constr)
-> (Dir dir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Dir dir)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dir dir)))
-> ((forall b. Data b => b -> b) -> Dir dir -> Dir dir)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Dir dir -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Dir dir -> r)
-> (forall u. (forall d. Data d => d -> u) -> Dir dir -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Dir dir -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir))
-> Data (Dir dir)
Dir dir -> Constr
Dir dir -> DataType
(forall b. Data b => b -> b) -> Dir dir -> Dir dir
forall dir. Data dir => Typeable (Dir dir)
forall dir. Data dir => Dir dir -> Constr
forall dir. Data dir => Dir dir -> DataType
forall dir.
Data dir =>
(forall b. Data b => b -> b) -> Dir dir -> Dir dir
forall dir u.
Data dir =>
Int -> (forall d. Data d => d -> u) -> Dir dir -> u
forall dir u.
Data dir =>
(forall d. Data d => d -> u) -> Dir dir -> [u]
forall dir r r'.
Data dir =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
forall dir r r'.
Data dir =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
forall dir (m :: * -> *).
(Data dir, Monad m) =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
forall dir (m :: * -> *).
(Data dir, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
forall dir (c :: * -> *).
Data dir =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dir dir)
forall dir (c :: * -> *).
Data dir =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir dir -> c (Dir dir)
forall dir (t :: * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Dir dir))
forall dir (t :: * -> * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dir dir))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Dir dir -> u
forall u. (forall d. Data d => d -> u) -> Dir dir -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dir dir)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir dir -> c (Dir dir)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Dir dir))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dir dir))
$cgfoldl :: forall dir (c :: * -> *).
Data dir =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir dir -> c (Dir dir)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir dir -> c (Dir dir)
$cgunfold :: forall dir (c :: * -> *).
Data dir =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dir dir)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Dir dir)
$ctoConstr :: forall dir. Data dir => Dir dir -> Constr
toConstr :: Dir dir -> Constr
$cdataTypeOf :: forall dir. Data dir => Dir dir -> DataType
dataTypeOf :: Dir dir -> DataType
$cdataCast1 :: forall dir (t :: * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Dir dir))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Dir dir))
$cdataCast2 :: forall dir (t :: * -> * -> *) (c :: * -> *).
(Data dir, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dir dir))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dir dir))
$cgmapT :: forall dir.
Data dir =>
(forall b. Data b => b -> b) -> Dir dir -> Dir dir
gmapT :: (forall b. Data b => b -> b) -> Dir dir -> Dir dir
$cgmapQl :: forall dir r r'.
Data dir =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
$cgmapQr :: forall dir r r'.
Data dir =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Dir dir -> r
$cgmapQ :: forall dir u.
Data dir =>
(forall d. Data d => d -> u) -> Dir dir -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Dir dir -> [u]
$cgmapQi :: forall dir u.
Data dir =>
Int -> (forall d. Data d => d -> u) -> Dir dir -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Dir dir -> u
$cgmapM :: forall dir (m :: * -> *).
(Data dir, Monad m) =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
$cgmapMp :: forall dir (m :: * -> *).
(Data dir, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
$cgmapMo :: forall dir (m :: * -> *).
(Data dir, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir dir -> m (Dir dir)
Data)

-- | Means that path points to a file @file@.
-- To use as a type in place of @file@, we recommend creating an empty
-- data type representing the specific file, e.g. @data ProjectManifestFile@.
data File file deriving ((forall (m :: * -> *). Quote m => File file -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    File file -> Code m (File file))
-> Lift (File file)
forall file (m :: * -> *). Quote m => File file -> m Exp
forall file (m :: * -> *).
Quote m =>
File file -> Code m (File file)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => File file -> m Exp
forall (m :: * -> *). Quote m => File file -> Code m (File file)
$clift :: forall file (m :: * -> *). Quote m => File file -> m Exp
lift :: forall (m :: * -> *). Quote m => File file -> m Exp
$cliftTyped :: forall file (m :: * -> *).
Quote m =>
File file -> Code m (File file)
liftTyped :: forall (m :: * -> *). Quote m => File file -> Code m (File file)
Lift, Typeable (File file)
Typeable (File file) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> File file -> c (File file))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (File file))
-> (File file -> Constr)
-> (File file -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (File file)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (File file)))
-> ((forall b. Data b => b -> b) -> File file -> File file)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> File file -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> File file -> r)
-> (forall u. (forall d. Data d => d -> u) -> File file -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> File file -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> File file -> m (File file))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File file -> m (File file))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File file -> m (File file))
-> Data (File file)
File file -> Constr
File file -> DataType
(forall b. Data b => b -> b) -> File file -> File file
forall file. Data file => Typeable (File file)
forall file. Data file => File file -> Constr
forall file. Data file => File file -> DataType
forall file.
Data file =>
(forall b. Data b => b -> b) -> File file -> File file
forall file u.
Data file =>
Int -> (forall d. Data d => d -> u) -> File file -> u
forall file u.
Data file =>
(forall d. Data d => d -> u) -> File file -> [u]
forall file r r'.
Data file =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
forall file r r'.
Data file =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
forall file (m :: * -> *).
(Data file, Monad m) =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
forall file (m :: * -> *).
(Data file, MonadPlus m) =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
forall file (c :: * -> *).
Data file =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (File file)
forall file (c :: * -> *).
Data file =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File file -> c (File file)
forall file (t :: * -> *) (c :: * -> *).
(Data file, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (File file))
forall file (t :: * -> * -> *) (c :: * -> *).
(Data file, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (File file))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> File file -> u
forall u. (forall d. Data d => d -> u) -> File file -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (File file)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File file -> c (File file)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (File file))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (File file))
$cgfoldl :: forall file (c :: * -> *).
Data file =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File file -> c (File file)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File file -> c (File file)
$cgunfold :: forall file (c :: * -> *).
Data file =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (File file)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (File file)
$ctoConstr :: forall file. Data file => File file -> Constr
toConstr :: File file -> Constr
$cdataTypeOf :: forall file. Data file => File file -> DataType
dataTypeOf :: File file -> DataType
$cdataCast1 :: forall file (t :: * -> *) (c :: * -> *).
(Data file, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (File file))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (File file))
$cdataCast2 :: forall file (t :: * -> * -> *) (c :: * -> *).
(Data file, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (File file))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (File file))
$cgmapT :: forall file.
Data file =>
(forall b. Data b => b -> b) -> File file -> File file
gmapT :: (forall b. Data b => b -> b) -> File file -> File file
$cgmapQl :: forall file r r'.
Data file =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
$cgmapQr :: forall file r r'.
Data file =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> File file -> r
$cgmapQ :: forall file u.
Data file =>
(forall d. Data d => d -> u) -> File file -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> File file -> [u]
$cgmapQi :: forall file u.
Data file =>
Int -> (forall d. Data d => d -> u) -> File file -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File file -> u
$cgmapM :: forall file (m :: * -> *).
(Data file, Monad m) =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
$cgmapMp :: forall file (m :: * -> *).
(Data file, MonadPlus m) =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
$cgmapMo :: forall file (m :: * -> *).
(Data file, MonadPlus m) =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File file -> m (File file)
Data)

-- | Describes 'Path' standard as posix (e.g. @\/path\/to\/foobar@).
-- This makes 'Path' behave in system-independent fashion: code behaves the same
-- regardless of the system it is running on.
-- You will normally want to use it when dealing with paths from some external source,
-- or with paths that have explicitely fixed standard.
-- For example, if you are running your Haskell program on Windows and parsing logs which
-- were obtained from the Linux server, or maybe you are parsing Javascript import statements,
-- you will want to use 'Posix'.
data Posix deriving ((forall (m :: * -> *). Quote m => Posix -> m Exp)
-> (forall (m :: * -> *). Quote m => Posix -> Code m Posix)
-> Lift Posix
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Posix -> m Exp
forall (m :: * -> *). Quote m => Posix -> Code m Posix
$clift :: forall (m :: * -> *). Quote m => Posix -> m Exp
lift :: forall (m :: * -> *). Quote m => Posix -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Posix -> Code m Posix
liftTyped :: forall (m :: * -> *). Quote m => Posix -> Code m Posix
Lift, Typeable Posix
Typeable Posix =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Posix -> c Posix)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Posix)
-> (Posix -> Constr)
-> (Posix -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Posix))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Posix))
-> ((forall b. Data b => b -> b) -> Posix -> Posix)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r)
-> (forall u. (forall d. Data d => d -> u) -> Posix -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Posix -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Posix -> m Posix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Posix -> m Posix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Posix -> m Posix)
-> Data Posix
Posix -> Constr
Posix -> DataType
(forall b. Data b => b -> b) -> Posix -> Posix
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Posix -> u
forall u. (forall d. Data d => d -> u) -> Posix -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Posix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Posix -> c Posix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Posix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Posix)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Posix -> c Posix
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Posix -> c Posix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Posix
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Posix
$ctoConstr :: Posix -> Constr
toConstr :: Posix -> Constr
$cdataTypeOf :: Posix -> DataType
dataTypeOf :: Posix -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Posix)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Posix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Posix)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Posix)
$cgmapT :: (forall b. Data b => b -> b) -> Posix -> Posix
gmapT :: (forall b. Data b => b -> b) -> Posix -> Posix
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Posix -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Posix -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Posix -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Posix -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Posix -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Posix -> m Posix
Data)

-- | Describes 'Path' standard as windows (e.g. @C:\\path\\to\\foobar@).
-- Check 'Posix' for more details, everything is analogous.
data Windows deriving ((forall (m :: * -> *). Quote m => Windows -> m Exp)
-> (forall (m :: * -> *). Quote m => Windows -> Code m Windows)
-> Lift Windows
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Windows -> m Exp
forall (m :: * -> *). Quote m => Windows -> Code m Windows
$clift :: forall (m :: * -> *). Quote m => Windows -> m Exp
lift :: forall (m :: * -> *). Quote m => Windows -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Windows -> Code m Windows
liftTyped :: forall (m :: * -> *). Quote m => Windows -> Code m Windows
Lift, Typeable Windows
Typeable Windows =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Windows -> c Windows)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Windows)
-> (Windows -> Constr)
-> (Windows -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Windows))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Windows))
-> ((forall b. Data b => b -> b) -> Windows -> Windows)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Windows -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Windows -> r)
-> (forall u. (forall d. Data d => d -> u) -> Windows -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Windows -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Windows -> m Windows)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Windows -> m Windows)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Windows -> m Windows)
-> Data Windows
Windows -> Constr
Windows -> DataType
(forall b. Data b => b -> b) -> Windows -> Windows
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Windows -> u
forall u. (forall d. Data d => d -> u) -> Windows -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Windows -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Windows -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Windows
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Windows -> c Windows
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Windows)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Windows)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Windows -> c Windows
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Windows -> c Windows
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Windows
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Windows
$ctoConstr :: Windows -> Constr
toConstr :: Windows -> Constr
$cdataTypeOf :: Windows -> DataType
dataTypeOf :: Windows -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Windows)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Windows)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Windows)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Windows)
$cgmapT :: (forall b. Data b => b -> b) -> Windows -> Windows
gmapT :: (forall b. Data b => b -> b) -> Windows -> Windows
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Windows -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Windows -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Windows -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Windows -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Windows -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Windows -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Windows -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Windows -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Windows -> m Windows
Data)

-- | Describes 'Path' standard to be determined by the system/OS.
--
-- If the system is Windows, it will resolve to 'Windows' internally, and if not,
-- it will resolve to 'Posix'.
--
-- However, keep in mind that even if running on Windows, @Path Windows b t@
-- and @Path System b t@ are still considered to be different types,
-- even though @Path System b t @ internally uses Windows standard.
--
-- You will normally want to use 'System' if you are dealing with the paths on the disk of the host OS
-- (where your code is running), for example if user is providing you with the path to the file on the disk
-- that you will be doing something with.
-- Keep in mind that 'System' causes the behaviour of 'Path' to be system/platform-dependant.
data System deriving ((forall (m :: * -> *). Quote m => System -> m Exp)
-> (forall (m :: * -> *). Quote m => System -> Code m System)
-> Lift System
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => System -> m Exp
forall (m :: * -> *). Quote m => System -> Code m System
$clift :: forall (m :: * -> *). Quote m => System -> m Exp
lift :: forall (m :: * -> *). Quote m => System -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => System -> Code m System
liftTyped :: forall (m :: * -> *). Quote m => System -> Code m System
Lift, Typeable System
Typeable System =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> System -> c System)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c System)
-> (System -> Constr)
-> (System -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c System))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System))
-> ((forall b. Data b => b -> b) -> System -> System)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> System -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> System -> r)
-> (forall u. (forall d. Data d => d -> u) -> System -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> System -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> System -> m System)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System)
-> Data System
System -> Constr
System -> DataType
(forall b. Data b => b -> b) -> System -> System
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> System -> u
forall u. (forall d. Data d => d -> u) -> System -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> System -> m System
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> System -> m System
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c System
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> System -> c System
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c System)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> System -> c System
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> System -> c System
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c System
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c System
$ctoConstr :: System -> Constr
toConstr :: System -> Constr
$cdataTypeOf :: System -> DataType
dataTypeOf :: System -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c System)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c System)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System)
$cgmapT :: (forall b. Data b => b -> b) -> System -> System
gmapT :: (forall b. Data b => b -> b) -> System -> System
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> System -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> System -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> System -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> System -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> System -> m System
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> System -> m System
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> System -> m System
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> System -> m System
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> System -> m System
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> System -> m System
Data) -- Depends on the platform, it is either Posix or Windows.

-- | 'System' is the most commonly used standard, so we provide you with a type alias for it.
type Path' = Path System

-- | When you don't want your path to be relative to anything specific,
-- it is convenient to use unit @()@.
type Rel' = Rel ()

-- | When you don't want your directory path to be named,
-- it is convenient to use unit @()@.
type Dir' = Dir ()

-- | When you don't want your file path to be named,
-- it is convenient to use unit @()@.
type File' = File ()

-- TODO: Extract `parseRelFileFP`, `parseRelDirFP`, `parseRelFP` and `extractRelPathPrefix` into StrongPath.FilePath.Internals?

parseRelFileFP ::
  MonadThrow m =>
  (p -> RelPathPrefix -> Path s (Rel d) (File f)) ->
  [Char] ->
  (FilePath -> m p) ->
  FilePath ->
  m (Path s (Rel d) (File f))
parseRelFileFP :: forall (m :: * -> *) p s d f.
MonadThrow m =>
(p -> RelPathPrefix -> Path s (Rel d) (File f))
-> [Char]
-> ([Char] -> m p)
-> [Char]
-> m (Path s (Rel d) (File f))
parseRelFileFP p -> RelPathPrefix -> Path s (Rel d) (File f)
_ [Char]
_ [Char] -> m p
_ [Char]
"" = PathException -> m (Path s (Rel d) (File f))
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM ([Char] -> PathException
P.InvalidRelFile [Char]
"")
parseRelFileFP p -> RelPathPrefix -> Path s (Rel d) (File f)
constructor [Char]
validSeparators [Char] -> m p
pathParser [Char]
fp = (p -> RelPathPrefix -> Path s (Rel d) (File f))
-> [Char]
-> ([Char] -> m p)
-> [Char]
-> m (Path s (Rel d) (File f))
forall (m :: * -> *) p s d1 t.
MonadThrow m =>
(p -> RelPathPrefix -> Path s (Rel d1) t)
-> [Char] -> ([Char] -> m p) -> [Char] -> m (Path s (Rel d1) t)
parseRelFP p -> RelPathPrefix -> Path s (Rel d) (File f)
constructor [Char]
validSeparators [Char] -> m p
pathParser [Char]
fp

parseRelDirFP ::
  MonadThrow m =>
  (p -> RelPathPrefix -> Path s (Rel d1) (Dir d2)) ->
  [Char] ->
  (FilePath -> m p) ->
  FilePath ->
  m (Path s (Rel d1) (Dir d2))
parseRelDirFP :: forall (m :: * -> *) p s d1 d2.
MonadThrow m =>
(p -> RelPathPrefix -> Path s (Rel d1) (Dir d2))
-> [Char]
-> ([Char] -> m p)
-> [Char]
-> m (Path s (Rel d1) (Dir d2))
parseRelDirFP p -> RelPathPrefix -> Path s (Rel d1) (Dir d2)
_ [Char]
_ [Char] -> m p
_ [Char]
"" = PathException -> m (Path s (Rel d1) (Dir d2))
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM ([Char] -> PathException
P.InvalidRelDir [Char]
"")
parseRelDirFP p -> RelPathPrefix -> Path s (Rel d1) (Dir d2)
constructor [Char]
validSeparators [Char] -> m p
pathParser [Char]
fp = (p -> RelPathPrefix -> Path s (Rel d1) (Dir d2))
-> [Char]
-> ([Char] -> m p)
-> [Char]
-> m (Path s (Rel d1) (Dir d2))
forall (m :: * -> *) p s d1 t.
MonadThrow m =>
(p -> RelPathPrefix -> Path s (Rel d1) t)
-> [Char] -> ([Char] -> m p) -> [Char] -> m (Path s (Rel d1) t)
parseRelFP p -> RelPathPrefix -> Path s (Rel d1) (Dir d2)
constructor [Char]
validSeparators [Char] -> m p
pathParser [Char]
fp

-- Helper function for the parseRelFileFP and parseRelDirFP, should not be used called directly but only
-- by parseRelFileFP and parseRelDirFP.
parseRelFP ::
  MonadThrow m =>
  (p -> RelPathPrefix -> Path s (Rel d1) t) ->
  [Char] ->
  (FilePath -> m p) ->
  FilePath ->
  m (Path s (Rel d1) t)
parseRelFP :: forall (m :: * -> *) p s d1 t.
MonadThrow m =>
(p -> RelPathPrefix -> Path s (Rel d1) t)
-> [Char] -> ([Char] -> m p) -> [Char] -> m (Path s (Rel d1) t)
parseRelFP p -> RelPathPrefix -> Path s (Rel d1) t
_ [Char]
_ [Char] -> m p
_ [Char]
"" = [Char] -> m (Path s (Rel d1) t)
forall a. HasCallStack => [Char] -> a
error [Char]
"can't parse empty path"
parseRelFP p -> RelPathPrefix -> Path s (Rel d1) t
constructor [Char]
validSeparators [Char] -> m p
pathParser [Char]
fp = do
  let (RelPathPrefix
prefix, [Char]
fp') = [Char] -> [Char] -> (RelPathPrefix, [Char])
extractRelPathPrefix [Char]
validSeparators [Char]
fp
      fp'' :: [Char]
fp'' = if [Char]
fp' [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"" then [Char]
"." else [Char]
fp' -- Because Path Rel parsers can't handle just "".
  (\p
p -> p -> RelPathPrefix -> Path s (Rel d1) t
constructor p
p RelPathPrefix
prefix) (p -> Path s (Rel d1) t) -> m p -> m (Path s (Rel d1) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m p
pathParser [Char]
fp''

-- | Extracts a multiple "../" from start of the file path.
--   If path is completely ../../.., also handles the last one.
--   NOTE: We don't normalize path in any way.
extractRelPathPrefix :: [Char] -> FilePath -> (RelPathPrefix, FilePath)
extractRelPathPrefix :: [Char] -> [Char] -> (RelPathPrefix, [Char])
extractRelPathPrefix [Char]
validSeparators [Char]
path =
  let (Int
n, [Char]
path') = [Char] -> (Int, [Char])
dropParentDirs [Char]
path
   in (if Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then RelPathPrefix
NoPrefix else Int -> RelPathPrefix
ParentDir Int
n, [Char]
path')
  where
    parentDirStrings :: [String]
    parentDirStrings :: [[Char]]
parentDirStrings = [[Char
'.', Char
'.', Char
s] | Char
s <- [Char]
validSeparators]

    pathStartsWithParentDir :: FilePath -> Bool
    pathStartsWithParentDir :: [Char] -> Bool
pathStartsWithParentDir [Char]
p = Int -> ShowS
forall a. Int -> [a] -> [a]
take Int
3 [Char]
p [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
parentDirStrings

    dropParentDirs :: FilePath -> (Int, FilePath)
    dropParentDirs :: [Char] -> (Int, [Char])
dropParentDirs [Char]
p
      | [Char] -> Bool
pathStartsWithParentDir [Char]
p =
        let (Int
n, [Char]
p') = [Char] -> (Int, [Char])
dropParentDirs (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
3 [Char]
p)
         in (Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n, [Char]
p')
      | [Char]
p [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
".." = (Int
1, [Char]
"")
      | Bool
otherwise = (Int
0, [Char]
p)

prefixNumParentDirs :: RelPathPrefix -> Int
prefixNumParentDirs :: RelPathPrefix -> Int
prefixNumParentDirs RelPathPrefix
NoPrefix = Int
0
prefixNumParentDirs (ParentDir Int
n) = Int
n

relPathNumParentDirs :: Path s (Rel r) t -> Int
relPathNumParentDirs :: forall s r t. Path s (Rel r) t -> Int
relPathNumParentDirs = RelPathPrefix -> Int
prefixNumParentDirs (RelPathPrefix -> Int)
-> (Path s (Rel r) t -> RelPathPrefix) -> Path s (Rel r) t -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path s (Rel r) t -> RelPathPrefix
forall s r t. Path s (Rel r) t -> RelPathPrefix
relPathPrefix

relPathPrefix :: Path s (Rel r) t -> RelPathPrefix
relPathPrefix :: forall s r t. Path s (Rel r) t -> RelPathPrefix
relPathPrefix Path s (Rel r) t
sp = case Path s (Rel r) t
sp of
  RelDir Path Rel Dir
_ RelPathPrefix
pr -> RelPathPrefix
pr
  RelFile Path Rel File
_ RelPathPrefix
pr -> RelPathPrefix
pr
  RelDirW Path Rel Dir
_ RelPathPrefix
pr -> RelPathPrefix
pr
  RelFileW Path Rel File
_ RelPathPrefix
pr -> RelPathPrefix
pr
  RelDirP Path Rel Dir
_ RelPathPrefix
pr -> RelPathPrefix
pr
  RelFileP Path Rel File
_ RelPathPrefix
pr -> RelPathPrefix
pr
  Path s (Rel r) t
_ -> RelPathPrefix
forall a. a
impossible

impossible :: a
impossible :: forall a. a
impossible = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"This should be impossible."