{-# LANGUAGE UndecidableInstances #-}

-- | Provides the 'ShellT' monad transformer.
module Shrun.ShellT
  ( ShellT,
    runShellT,
  )
where

import Effects.System.Posix.Signals
  ( MonadPosixSignals
      ( awaitSignal,
        blockSignals,
        getPendingSignals,
        getSignalMask,
        installHandler,
        queryStoppedChildFlag,
        raiseSignal,
        scheduleAlarm,
        setSignalMask,
        setStoppedChildFlag,
        signalProcess,
        signalProcessGroup,
        unblockSignals
      ),
  )
import Effects.System.Posix.Signals qualified as Signals
import Shrun.Configuration.Env.Types (Env)
import Shrun.Logging.MonadRegionLogger (MonadRegionLogger)
import Shrun.Prelude

-- | `ShellT` is the main application type that runs shell commands.
type ShellT :: Type -> (Type -> Type) -> Type -> Type
newtype ShellT env m a = MkShellT (ReaderT env m a)
  deriving
    ( (forall a b. (a -> b) -> ShellT env m a -> ShellT env m b)
-> (forall a b. a -> ShellT env m b -> ShellT env m a)
-> Functor (ShellT env m)
forall a b. a -> ShellT env m b -> ShellT env m a
forall a b. (a -> b) -> ShellT env m a -> ShellT env m b
forall env (m :: Type -> Type) a b.
Functor m =>
a -> ShellT env m b -> ShellT env m a
forall env (m :: Type -> Type) a b.
Functor m =>
(a -> b) -> ShellT env m a -> ShellT env m b
forall (f :: Type -> Type).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall env (m :: Type -> Type) a b.
Functor m =>
(a -> b) -> ShellT env m a -> ShellT env m b
fmap :: forall a b. (a -> b) -> ShellT env m a -> ShellT env m b
$c<$ :: forall env (m :: Type -> Type) a b.
Functor m =>
a -> ShellT env m b -> ShellT env m a
<$ :: forall a b. a -> ShellT env m b -> ShellT env m a
Functor,
      Functor (ShellT env m)
Functor (ShellT env m) =>
(forall a. a -> ShellT env m a)
-> (forall a b.
    ShellT env m (a -> b) -> ShellT env m a -> ShellT env m b)
-> (forall a b c.
    (a -> b -> c)
    -> ShellT env m a -> ShellT env m b -> ShellT env m c)
-> (forall a b. ShellT env m a -> ShellT env m b -> ShellT env m b)
-> (forall a b. ShellT env m a -> ShellT env m b -> ShellT env m a)
-> Applicative (ShellT env m)
forall a. a -> ShellT env m a
forall a b. ShellT env m a -> ShellT env m b -> ShellT env m a
forall a b. ShellT env m a -> ShellT env m b -> ShellT env m b
forall a b.
ShellT env m (a -> b) -> ShellT env m a -> ShellT env m b
forall a b c.
(a -> b -> c) -> ShellT env m a -> ShellT env m b -> ShellT env m c
forall env (m :: Type -> Type).
Applicative m =>
Functor (ShellT env m)
forall env (m :: Type -> Type) a.
Applicative m =>
a -> ShellT env m a
forall env (m :: Type -> Type) a b.
Applicative m =>
ShellT env m a -> ShellT env m b -> ShellT env m a
forall env (m :: Type -> Type) a b.
Applicative m =>
ShellT env m a -> ShellT env m b -> ShellT env m b
forall env (m :: Type -> Type) a b.
Applicative m =>
ShellT env m (a -> b) -> ShellT env m a -> ShellT env m b
forall env (m :: Type -> Type) a b c.
Applicative m =>
(a -> b -> c) -> ShellT env m a -> ShellT env m b -> ShellT env m c
forall (f :: Type -> Type).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall env (m :: Type -> Type) a.
Applicative m =>
a -> ShellT env m a
pure :: forall a. a -> ShellT env m a
$c<*> :: forall env (m :: Type -> Type) a b.
Applicative m =>
ShellT env m (a -> b) -> ShellT env m a -> ShellT env m b
<*> :: forall a b.
ShellT env m (a -> b) -> ShellT env m a -> ShellT env m b
$cliftA2 :: forall env (m :: Type -> Type) a b c.
Applicative m =>
(a -> b -> c) -> ShellT env m a -> ShellT env m b -> ShellT env m c
liftA2 :: forall a b c.
(a -> b -> c) -> ShellT env m a -> ShellT env m b -> ShellT env m c
$c*> :: forall env (m :: Type -> Type) a b.
Applicative m =>
ShellT env m a -> ShellT env m b -> ShellT env m b
*> :: forall a b. ShellT env m a -> ShellT env m b -> ShellT env m b
$c<* :: forall env (m :: Type -> Type) a b.
Applicative m =>
ShellT env m a -> ShellT env m b -> ShellT env m a
<* :: forall a b. ShellT env m a -> ShellT env m b -> ShellT env m a
Applicative,
      Applicative (ShellT env m)
Applicative (ShellT env m) =>
(forall a b.
 ShellT env m a -> (a -> ShellT env m b) -> ShellT env m b)
-> (forall a b. ShellT env m a -> ShellT env m b -> ShellT env m b)
-> (forall a. a -> ShellT env m a)
-> Monad (ShellT env m)
forall a. a -> ShellT env m a
forall a b. ShellT env m a -> ShellT env m b -> ShellT env m b
forall a b.
ShellT env m a -> (a -> ShellT env m b) -> ShellT env m b
forall env (m :: Type -> Type).
Monad m =>
Applicative (ShellT env m)
forall env (m :: Type -> Type) a. Monad m => a -> ShellT env m a
forall env (m :: Type -> Type) a b.
Monad m =>
ShellT env m a -> ShellT env m b -> ShellT env m b
forall env (m :: Type -> Type) a b.
Monad m =>
ShellT env m a -> (a -> ShellT env m b) -> ShellT env m b
forall (m :: Type -> Type).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall env (m :: Type -> Type) a b.
Monad m =>
ShellT env m a -> (a -> ShellT env m b) -> ShellT env m b
>>= :: forall a b.
ShellT env m a -> (a -> ShellT env m b) -> ShellT env m b
$c>> :: forall env (m :: Type -> Type) a b.
Monad m =>
ShellT env m a -> ShellT env m b -> ShellT env m b
>> :: forall a b. ShellT env m a -> ShellT env m b -> ShellT env m b
$creturn :: forall env (m :: Type -> Type) a. Monad m => a -> ShellT env m a
return :: forall a. a -> ShellT env m a
Monad,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall a b.
 HasCallStack =>
 ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b)
-> (forall a b.
    HasCallStack =>
    ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b)
-> (forall a b.
    HasCallStack =>
    Int
    -> ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b)
-> (forall a b.
    HasCallStack =>
    ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
    -> (Async a -> ShellT env m b) -> ShellT env m b)
-> (forall a b.
    HasCallStack =>
    Int
    -> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
    -> (Async a -> ShellT env m b)
    -> ShellT env m b)
-> (forall a. HasCallStack => Async a -> ShellT env m a)
-> (forall a.
    HasCallStack =>
    Async a -> ShellT env m (Maybe (Either SomeException a)))
-> (forall a.
    HasCallStack =>
    Async a -> ShellT env m (Either SomeException a))
-> (forall a. HasCallStack => Async a -> ShellT env m ())
-> (forall a. HasCallStack => Async a -> ShellT env m ())
-> (forall e a.
    (Exception e, HasCallStack) =>
    Async a -> e -> ShellT env m ())
-> (forall a b.
    HasCallStack =>
    ShellT env m a -> ShellT env m b -> ShellT env m (Either a b))
-> (forall a b.
    HasCallStack =>
    ShellT env m a -> ShellT env m b -> ShellT env m (a, b))
-> (forall a b.
    HasCallStack =>
    ShellT env m a -> ShellT env m b -> ShellT env m ())
-> (forall a.
    HasCallStack =>
    [Async a] -> ShellT env m (Async a, a))
-> (forall a.
    HasCallStack =>
    [Async a] -> ShellT env m (Async a, Either SomeException a))
-> (forall a.
    HasCallStack =>
    [Async a] -> ShellT env m (Async a, a))
-> (forall a.
    HasCallStack =>
    [Async a] -> ShellT env m (Async a, Either SomeException a))
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> ShellT env m (Either a b))
-> (forall a b.
    HasCallStack =>
    Async a
    -> Async b
    -> ShellT
         env m (Either (Either SomeException a) (Either SomeException b)))
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> ShellT env m (Either a b))
-> (forall a b.
    HasCallStack =>
    Async a
    -> Async b
    -> ShellT
         env m (Either (Either SomeException a) (Either SomeException b)))
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> ShellT env m ())
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> ShellT env m (a, b))
-> (forall a.
    HasCallStack =>
    ShellT env m a -> ShellT env m (Async a))
-> (forall a.
    HasCallStack =>
    ShellT env m a -> ShellT env m (Async a))
-> (forall a.
    HasCallStack =>
    Int -> ShellT env m a -> ShellT env m (Async a))
-> (forall a.
    HasCallStack =>
    ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
    -> ShellT env m (Async a))
-> (forall a.
    HasCallStack =>
    Int
    -> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
    -> ShellT env m (Async a))
-> (forall a. HasCallStack => Async a -> ShellT env m ())
-> (forall a.
    HasCallStack =>
    (SomeException -> Bool) -> Async a -> ShellT env m ())
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> ShellT env m ())
-> (forall a b.
    HasCallStack =>
    (SomeException -> Bool) -> Async a -> Async b -> ShellT env m ())
-> (forall (t :: Type -> Type) a b.
    (HasCallStack, Traversable t) =>
    Positive Int -> (a -> ShellT env m b) -> t a -> ShellT env m (t b))
-> (forall (t :: Type -> Type) a b.
    (HasCallStack, Traversable t) =>
    (a -> ShellT env m b) -> t a -> ShellT env m (t b))
-> (forall (f :: Type -> Type) a b.
    (Foldable f, HasCallStack) =>
    Positive Int -> (a -> ShellT env m b) -> f a -> ShellT env m ())
-> (forall (f :: Type -> Type) a b.
    (Foldable f, HasCallStack) =>
    (a -> ShellT env m b) -> f a -> ShellT env m ())
-> MonadAsync (ShellT env m)
forall a.
HasCallStack =>
Int -> ShellT env m a -> ShellT env m (Async a)
forall a.
HasCallStack =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
forall a. HasCallStack => [Async a] -> ShellT env m (Async a, a)
forall a.
HasCallStack =>
[Async a] -> ShellT env m (Async a, Either SomeException a)
forall a. HasCallStack => Async a -> ShellT env m a
forall a.
HasCallStack =>
Async a -> ShellT env m (Maybe (Either SomeException a))
forall a.
HasCallStack =>
Async a -> ShellT env m (Either SomeException a)
forall a. HasCallStack => Async a -> ShellT env m ()
forall a. HasCallStack => ShellT env m a -> ShellT env m (Async a)
forall a.
HasCallStack =>
(SomeException -> Bool) -> Async a -> ShellT env m ()
forall a.
HasCallStack =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
forall a b.
HasCallStack =>
Int
-> ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
forall a b.
HasCallStack =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b)
-> ShellT env m b
forall a b.
HasCallStack =>
Async a -> Async b -> ShellT env m (Either a b)
forall a b.
HasCallStack =>
Async a
-> Async b
-> ShellT
     env m (Either (Either SomeException a) (Either SomeException b))
forall a b. HasCallStack => Async a -> Async b -> ShellT env m ()
forall a b.
HasCallStack =>
Async a -> Async b -> ShellT env m (a, b)
forall a b.
HasCallStack =>
ShellT env m a -> ShellT env m b -> ShellT env m (Either a b)
forall a b.
HasCallStack =>
ShellT env m a -> ShellT env m b -> ShellT env m ()
forall a b.
HasCallStack =>
ShellT env m a -> ShellT env m b -> ShellT env m (a, b)
forall a b.
HasCallStack =>
ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
forall a b.
HasCallStack =>
(SomeException -> Bool) -> Async a -> Async b -> ShellT env m ()
forall a b.
HasCallStack =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b) -> ShellT env m b
forall e a.
(Exception e, HasCallStack) =>
Async a -> e -> ShellT env m ()
forall env (m :: Type -> Type).
MonadAsync m =>
Monad (ShellT env m)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Int -> ShellT env m a -> ShellT env m (Async a)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
[Async a] -> ShellT env m (Async a, a)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
[Async a] -> ShellT env m (Async a, Either SomeException a)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m a
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m (Maybe (Either SomeException a))
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m (Either SomeException a)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m ()
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m (Async a)
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
(SomeException -> Bool) -> Async a -> ShellT env m ()
forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Int
-> ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b)
-> ShellT env m b
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m (Either a b)
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a
-> Async b
-> ShellT
     env m (Either (Either SomeException a) (Either SomeException b))
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m ()
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m (a, b)
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m b -> ShellT env m (Either a b)
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m b -> ShellT env m ()
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m b -> ShellT env m (a, b)
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
(SomeException -> Bool) -> Async a -> Async b -> ShellT env m ()
forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b) -> ShellT env m b
forall env (m :: Type -> Type) e a.
(MonadAsync m, Exception e, HasCallStack) =>
Async a -> e -> ShellT env m ()
forall env (m :: Type -> Type) (f :: Type -> Type) a b.
(MonadAsync m, Foldable f, HasCallStack) =>
Positive Int -> (a -> ShellT env m b) -> f a -> ShellT env m ()
forall env (m :: Type -> Type) (f :: Type -> Type) a b.
(MonadAsync m, Foldable f, HasCallStack) =>
(a -> ShellT env m b) -> f a -> ShellT env m ()
forall env (m :: Type -> Type) (t :: Type -> Type) a b.
(MonadAsync m, HasCallStack, Traversable t) =>
Positive Int -> (a -> ShellT env m b) -> t a -> ShellT env m (t b)
forall env (m :: Type -> Type) (t :: Type -> Type) a b.
(MonadAsync m, HasCallStack, Traversable t) =>
(a -> ShellT env m b) -> t a -> ShellT env m (t b)
forall (m :: Type -> Type).
Monad m =>
(forall a b. HasCallStack => m a -> (Async a -> m b) -> m b)
-> (forall a b. HasCallStack => m a -> (Async a -> m b) -> m b)
-> (forall a b.
    HasCallStack =>
    Int -> m a -> (Async a -> m b) -> m b)
-> (forall a b.
    HasCallStack =>
    ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b)
-> (forall a b.
    HasCallStack =>
    Int -> ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b)
-> (forall a. HasCallStack => Async a -> m a)
-> (forall a.
    HasCallStack =>
    Async a -> m (Maybe (Either SomeException a)))
-> (forall a.
    HasCallStack =>
    Async a -> m (Either SomeException a))
-> (forall a. HasCallStack => Async a -> m ())
-> (forall a. HasCallStack => Async a -> m ())
-> (forall e a.
    (Exception e, HasCallStack) =>
    Async a -> e -> m ())
-> (forall a b. HasCallStack => m a -> m b -> m (Either a b))
-> (forall a b. HasCallStack => m a -> m b -> m (a, b))
-> (forall a b. HasCallStack => m a -> m b -> m ())
-> (forall a. HasCallStack => [Async a] -> m (Async a, a))
-> (forall a.
    HasCallStack =>
    [Async a] -> m (Async a, Either SomeException a))
-> (forall a. HasCallStack => [Async a] -> m (Async a, a))
-> (forall a.
    HasCallStack =>
    [Async a] -> m (Async a, Either SomeException a))
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> m (Either a b))
-> (forall a b.
    HasCallStack =>
    Async a
    -> Async b
    -> m (Either (Either SomeException a) (Either SomeException b)))
-> (forall a b.
    HasCallStack =>
    Async a -> Async b -> m (Either a b))
-> (forall a b.
    HasCallStack =>
    Async a
    -> Async b
    -> m (Either (Either SomeException a) (Either SomeException b)))
-> (forall a b. HasCallStack => Async a -> Async b -> m ())
-> (forall a b. HasCallStack => Async a -> Async b -> m (a, b))
-> (forall a. HasCallStack => m a -> m (Async a))
-> (forall a. HasCallStack => m a -> m (Async a))
-> (forall a. HasCallStack => Int -> m a -> m (Async a))
-> (forall a.
    HasCallStack =>
    ((forall c. m c -> m c) -> m a) -> m (Async a))
-> (forall a.
    HasCallStack =>
    Int -> ((forall c. m c -> m c) -> m a) -> m (Async a))
-> (forall a. HasCallStack => Async a -> m ())
-> (forall a.
    HasCallStack =>
    (SomeException -> Bool) -> Async a -> m ())
-> (forall a b. HasCallStack => Async a -> Async b -> m ())
-> (forall a b.
    HasCallStack =>
    (SomeException -> Bool) -> Async a -> Async b -> m ())
-> (forall (t :: Type -> Type) a b.
    (HasCallStack, Traversable t) =>
    Positive Int -> (a -> m b) -> t a -> m (t b))
-> (forall (t :: Type -> Type) a b.
    (HasCallStack, Traversable t) =>
    (a -> m b) -> t a -> m (t b))
-> (forall (f :: Type -> Type) a b.
    (Foldable f, HasCallStack) =>
    Positive Int -> (a -> m b) -> f a -> m ())
-> (forall (f :: Type -> Type) a b.
    (Foldable f, HasCallStack) =>
    (a -> m b) -> f a -> m ())
-> MonadAsync m
forall (f :: Type -> Type) a b.
(Foldable f, HasCallStack) =>
Positive Int -> (a -> ShellT env m b) -> f a -> ShellT env m ()
forall (f :: Type -> Type) a b.
(Foldable f, HasCallStack) =>
(a -> ShellT env m b) -> f a -> ShellT env m ()
forall (t :: Type -> Type) a b.
(HasCallStack, Traversable t) =>
Positive Int -> (a -> ShellT env m b) -> t a -> ShellT env m (t b)
forall (t :: Type -> Type) a b.
(HasCallStack, Traversable t) =>
(a -> ShellT env m b) -> t a -> ShellT env m (t b)
$cwithAsync :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
withAsync :: forall a b.
HasCallStack =>
ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
$cwithAsyncBound :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
withAsyncBound :: forall a b.
HasCallStack =>
ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
$cwithAsyncOn :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Int
-> ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
withAsyncOn :: forall a b.
HasCallStack =>
Int
-> ShellT env m a -> (Async a -> ShellT env m b) -> ShellT env m b
$cwithAsyncWithUnmask :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b) -> ShellT env m b
withAsyncWithUnmask :: forall a b.
HasCallStack =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b) -> ShellT env m b
$cwithAsyncOnWithUnmask :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b)
-> ShellT env m b
withAsyncOnWithUnmask :: forall a b.
HasCallStack =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> (Async a -> ShellT env m b)
-> ShellT env m b
$cwait :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m a
wait :: forall a. HasCallStack => Async a -> ShellT env m a
$cpoll :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m (Maybe (Either SomeException a))
poll :: forall a.
HasCallStack =>
Async a -> ShellT env m (Maybe (Either SomeException a))
$cwaitCatch :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m (Either SomeException a)
waitCatch :: forall a.
HasCallStack =>
Async a -> ShellT env m (Either SomeException a)
$ccancel :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m ()
cancel :: forall a. HasCallStack => Async a -> ShellT env m ()
$cuninterruptibleCancel :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m ()
uninterruptibleCancel :: forall a. HasCallStack => Async a -> ShellT env m ()
$ccancelWith :: forall env (m :: Type -> Type) e a.
(MonadAsync m, Exception e, HasCallStack) =>
Async a -> e -> ShellT env m ()
cancelWith :: forall e a.
(Exception e, HasCallStack) =>
Async a -> e -> ShellT env m ()
$crace :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m b -> ShellT env m (Either a b)
race :: forall a b.
HasCallStack =>
ShellT env m a -> ShellT env m b -> ShellT env m (Either a b)
$cconcurrently :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m b -> ShellT env m (a, b)
concurrently :: forall a b.
HasCallStack =>
ShellT env m a -> ShellT env m b -> ShellT env m (a, b)
$cconcurrently_ :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m b -> ShellT env m ()
concurrently_ :: forall a b.
HasCallStack =>
ShellT env m a -> ShellT env m b -> ShellT env m ()
$cwaitAny :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
[Async a] -> ShellT env m (Async a, a)
waitAny :: forall a. HasCallStack => [Async a] -> ShellT env m (Async a, a)
$cwaitAnyCatch :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
[Async a] -> ShellT env m (Async a, Either SomeException a)
waitAnyCatch :: forall a.
HasCallStack =>
[Async a] -> ShellT env m (Async a, Either SomeException a)
$cwaitAnyCancel :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
[Async a] -> ShellT env m (Async a, a)
waitAnyCancel :: forall a. HasCallStack => [Async a] -> ShellT env m (Async a, a)
$cwaitAnyCatchCancel :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
[Async a] -> ShellT env m (Async a, Either SomeException a)
waitAnyCatchCancel :: forall a.
HasCallStack =>
[Async a] -> ShellT env m (Async a, Either SomeException a)
$cwaitEither :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m (Either a b)
waitEither :: forall a b.
HasCallStack =>
Async a -> Async b -> ShellT env m (Either a b)
$cwaitEitherCatch :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a
-> Async b
-> ShellT
     env m (Either (Either SomeException a) (Either SomeException b))
waitEitherCatch :: forall a b.
HasCallStack =>
Async a
-> Async b
-> ShellT
     env m (Either (Either SomeException a) (Either SomeException b))
$cwaitEitherCancel :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m (Either a b)
waitEitherCancel :: forall a b.
HasCallStack =>
Async a -> Async b -> ShellT env m (Either a b)
$cwaitEitherCatchCancel :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a
-> Async b
-> ShellT
     env m (Either (Either SomeException a) (Either SomeException b))
waitEitherCatchCancel :: forall a b.
HasCallStack =>
Async a
-> Async b
-> ShellT
     env m (Either (Either SomeException a) (Either SomeException b))
$cwaitEither_ :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m ()
waitEither_ :: forall a b. HasCallStack => Async a -> Async b -> ShellT env m ()
$cwaitBoth :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m (a, b)
waitBoth :: forall a b.
HasCallStack =>
Async a -> Async b -> ShellT env m (a, b)
$casync :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m (Async a)
async :: forall a. HasCallStack => ShellT env m a -> ShellT env m (Async a)
$casyncBound :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
ShellT env m a -> ShellT env m (Async a)
asyncBound :: forall a. HasCallStack => ShellT env m a -> ShellT env m (Async a)
$casyncOn :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Int -> ShellT env m a -> ShellT env m (Async a)
asyncOn :: forall a.
HasCallStack =>
Int -> ShellT env m a -> ShellT env m (Async a)
$casyncWithUnmask :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
asyncWithUnmask :: forall a.
HasCallStack =>
((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
$casyncOnWithUnmask :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
asyncOnWithUnmask :: forall a.
HasCallStack =>
Int
-> ((forall c. ShellT env m c -> ShellT env m c) -> ShellT env m a)
-> ShellT env m (Async a)
$clink :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
Async a -> ShellT env m ()
link :: forall a. HasCallStack => Async a -> ShellT env m ()
$clinkOnly :: forall env (m :: Type -> Type) a.
(MonadAsync m, HasCallStack) =>
(SomeException -> Bool) -> Async a -> ShellT env m ()
linkOnly :: forall a.
HasCallStack =>
(SomeException -> Bool) -> Async a -> ShellT env m ()
$clink2 :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
Async a -> Async b -> ShellT env m ()
link2 :: forall a b. HasCallStack => Async a -> Async b -> ShellT env m ()
$clink2Only :: forall env (m :: Type -> Type) a b.
(MonadAsync m, HasCallStack) =>
(SomeException -> Bool) -> Async a -> Async b -> ShellT env m ()
link2Only :: forall a b.
HasCallStack =>
(SomeException -> Bool) -> Async a -> Async b -> ShellT env m ()
$cpooledMapConcurrentlyN :: forall env (m :: Type -> Type) (t :: Type -> Type) a b.
(MonadAsync m, HasCallStack, Traversable t) =>
Positive Int -> (a -> ShellT env m b) -> t a -> ShellT env m (t b)
pooledMapConcurrentlyN :: forall (t :: Type -> Type) a b.
(HasCallStack, Traversable t) =>
Positive Int -> (a -> ShellT env m b) -> t a -> ShellT env m (t b)
$cpooledMapConcurrently :: forall env (m :: Type -> Type) (t :: Type -> Type) a b.
(MonadAsync m, HasCallStack, Traversable t) =>
(a -> ShellT env m b) -> t a -> ShellT env m (t b)
pooledMapConcurrently :: forall (t :: Type -> Type) a b.
(HasCallStack, Traversable t) =>
(a -> ShellT env m b) -> t a -> ShellT env m (t b)
$cpooledMapConcurrentlyN_ :: forall env (m :: Type -> Type) (f :: Type -> Type) a b.
(MonadAsync m, Foldable f, HasCallStack) =>
Positive Int -> (a -> ShellT env m b) -> f a -> ShellT env m ()
pooledMapConcurrentlyN_ :: forall (f :: Type -> Type) a b.
(Foldable f, HasCallStack) =>
Positive Int -> (a -> ShellT env m b) -> f a -> ShellT env m ()
$cpooledMapConcurrently_ :: forall env (m :: Type -> Type) (f :: Type -> Type) a b.
(MonadAsync m, Foldable f, HasCallStack) =>
(a -> ShellT env m b) -> f a -> ShellT env m ()
pooledMapConcurrently_ :: forall (f :: Type -> Type) a b.
(Foldable f, HasCallStack) =>
(a -> ShellT env m b) -> f a -> ShellT env m ()
MonadAsync,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall a. HasCallStack => STM a -> ShellT env m a)
-> MonadAtomic (ShellT env m)
forall a. HasCallStack => STM a -> ShellT env m a
forall env (m :: Type -> Type).
MonadAtomic m =>
Monad (ShellT env m)
forall env (m :: Type -> Type) a.
(MonadAtomic m, HasCallStack) =>
STM a -> ShellT env m a
forall (m :: Type -> Type).
Monad m =>
(forall a. HasCallStack => STM a -> m a) -> MonadAtomic m
$catomically :: forall env (m :: Type -> Type) a.
(MonadAtomic m, HasCallStack) =>
STM a -> ShellT env m a
atomically :: forall a. HasCallStack => STM a -> ShellT env m a
MonadAtomic,
      MonadThrow (ShellT env m)
MonadThrow (ShellT env m) =>
(forall e a.
 (HasCallStack, Exception e) =>
 ShellT env m a -> (e -> ShellT env m a) -> ShellT env m a)
-> MonadCatch (ShellT env m)
forall e a.
(HasCallStack, Exception e) =>
ShellT env m a -> (e -> ShellT env m a) -> ShellT env m a
forall env (m :: Type -> Type).
MonadCatch m =>
MonadThrow (ShellT env m)
forall env (m :: Type -> Type) e a.
(MonadCatch m, HasCallStack, Exception e) =>
ShellT env m a -> (e -> ShellT env m a) -> ShellT env m a
forall (m :: Type -> Type).
MonadThrow m =>
(forall e a.
 (HasCallStack, Exception e) =>
 m a -> (e -> m a) -> m a)
-> MonadCatch m
$ccatch :: forall env (m :: Type -> Type) e a.
(MonadCatch m, HasCallStack, Exception e) =>
ShellT env m a -> (e -> ShellT env m a) -> ShellT env m a
catch :: forall e a.
(HasCallStack, Exception e) =>
ShellT env m a -> (e -> ShellT env m a) -> ShellT env m a
MonadCatch,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall a. HasCallStack => a -> ShellT env m a)
-> MonadEvaluate (ShellT env m)
forall a. HasCallStack => a -> ShellT env m a
forall env (m :: Type -> Type).
MonadEvaluate m =>
Monad (ShellT env m)
forall env (m :: Type -> Type) a.
(MonadEvaluate m, HasCallStack) =>
a -> ShellT env m a
forall (m :: Type -> Type).
Monad m =>
(forall a. HasCallStack => a -> m a) -> MonadEvaluate m
$cevaluate :: forall env (m :: Type -> Type) a.
(MonadEvaluate m, HasCallStack) =>
a -> ShellT env m a
evaluate :: forall a. HasCallStack => a -> ShellT env m a
MonadEvaluate,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => OsPath -> ShellT env m ByteString)
-> MonadFileReader (ShellT env m)
HasCallStack => OsPath -> ShellT env m ByteString
forall env (m :: Type -> Type).
MonadFileReader m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadFileReader m, HasCallStack) =>
OsPath -> ShellT env m ByteString
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => OsPath -> m ByteString) -> MonadFileReader m
$creadBinaryFile :: forall env (m :: Type -> Type).
(MonadFileReader m, HasCallStack) =>
OsPath -> ShellT env m ByteString
readBinaryFile :: HasCallStack => OsPath -> ShellT env m ByteString
MonadFileReader,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => OsPath -> ByteString -> ShellT env m ())
-> (HasCallStack => OsPath -> ByteString -> ShellT env m ())
-> MonadFileWriter (ShellT env m)
HasCallStack => OsPath -> ByteString -> ShellT env m ()
forall env (m :: Type -> Type).
MonadFileWriter m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadFileWriter m, HasCallStack) =>
OsPath -> ByteString -> ShellT env m ()
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => OsPath -> ByteString -> m ())
-> (HasCallStack => OsPath -> ByteString -> m ())
-> MonadFileWriter m
$cwriteBinaryFile :: forall env (m :: Type -> Type).
(MonadFileWriter m, HasCallStack) =>
OsPath -> ByteString -> ShellT env m ()
writeBinaryFile :: HasCallStack => OsPath -> ByteString -> ShellT env m ()
$cappendBinaryFile :: forall env (m :: Type -> Type).
(MonadFileWriter m, HasCallStack) =>
OsPath -> ByteString -> ShellT env m ()
appendBinaryFile :: HasCallStack => OsPath -> ByteString -> ShellT env m ()
MonadFileWriter,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => OsPath -> ShellT env m (Handle 'HandleModeRead))
-> (forall a.
    HasCallStack =>
    OsPath
    -> (Handle 'HandleModeRead -> ShellT env m a) -> ShellT env m a)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m BufferMode)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Char)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> ShellT env m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> ShellT env m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> ShellT env m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> MonadHandleReader (ShellT env m)
HasCallStack => OsPath -> ShellT env m (Handle 'HandleModeRead)
forall a.
HasCallStack =>
OsPath
-> (Handle 'HandleModeRead -> ShellT env m a) -> ShellT env m a
forall env (m :: Type -> Type).
MonadHandleReader m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadHandleReader m, HasCallStack) =>
OsPath -> ShellT env m (Handle 'HandleModeRead)
forall env (m :: Type -> Type) a.
(MonadHandleReader m, HasCallStack) =>
OsPath
-> (Handle 'HandleModeRead -> ShellT env m a) -> ShellT env m a
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Char
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ByteString
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m BufferMode
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m Bool
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Char
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ByteString
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m BufferMode
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m Bool
forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => OsPath -> m (Handle 'HandleModeRead))
-> (forall a.
    HasCallStack =>
    OsPath -> (Handle 'HandleModeRead -> m a) -> m a)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m ())
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m ())
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m BufferMode)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Char)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> Int -> m ByteString)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m ())
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanRead p, HasCallStack) =>
    Handle p -> m ())
-> MonadHandleReader m
$copenBinaryFile :: forall env (m :: Type -> Type).
(MonadHandleReader m, HasCallStack) =>
OsPath -> ShellT env m (Handle 'HandleModeRead)
openBinaryFile :: HasCallStack => OsPath -> ShellT env m (Handle 'HandleModeRead)
$cwithBinaryFile :: forall env (m :: Type -> Type) a.
(MonadHandleReader m, HasCallStack) =>
OsPath
-> (Handle 'HandleModeRead -> ShellT env m a) -> ShellT env m a
withBinaryFile :: forall a.
HasCallStack =>
OsPath
-> (Handle 'HandleModeRead -> ShellT env m a) -> ShellT env m a
$chClose :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
hClose :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
$chFlush :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
hFlush :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
$chIsEOF :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsEOF :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chGetBuffering :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m BufferMode
hGetBuffering :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m BufferMode
$chIsOpen :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsOpen :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chIsClosed :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsClosed :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chIsReadable :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsReadable :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chIsWritable :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsWritable :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chIsSeekable :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsSeekable :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chIsTerminalDevice :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hIsTerminalDevice :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chGetEcho :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hGetEcho :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chWaitForInput :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m Bool
hWaitForInput :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m Bool
$chReady :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hReady :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chGetChar :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Char
hGetChar :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Char
$chGetLine :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ByteString
hGetLine :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ByteString
$chGetContents :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ByteString
hGetContents :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ByteString
$chGet :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
hGet :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
$chGetSome :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
hGetSome :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
$chGetNonBlocking :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
hGetNonBlocking :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> Int -> ShellT env m ByteString
$chLockRaw :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
hLockRaw :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
$chTryLockRaw :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
hTryLockRaw :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chUnlockRaw :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleReader m, CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
hUnlockRaw :: forall (p :: HandleMode).
(CanRead p, HasCallStack) =>
Handle p -> ShellT env m ()
MonadHandleReader,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack =>
 OsPath -> Bool -> ShellT env m (Handle 'HandleModeWrite))
-> (forall a.
    HasCallStack =>
    OsPath
    -> Bool
    -> (Handle 'HandleModeWrite -> ShellT env m a)
    -> ShellT env m a)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> Integer -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> BufferMode -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> SeekMode -> Integer -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ShellT env m Integer)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> Bool -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ByteString -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ByteString -> ShellT env m ByteString)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ShellT env m Bool)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ShellT env m ())
-> MonadHandleWriter (ShellT env m)
HasCallStack =>
OsPath -> Bool -> ShellT env m (Handle 'HandleModeWrite)
forall a.
HasCallStack =>
OsPath
-> Bool
-> (Handle 'HandleModeWrite -> ShellT env m a)
-> ShellT env m a
forall env (m :: Type -> Type).
MonadHandleWriter m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadHandleWriter m, HasCallStack) =>
OsPath -> Bool -> ShellT env m (Handle 'HandleModeWrite)
forall env (m :: Type -> Type) a.
(MonadHandleWriter m, HasCallStack) =>
OsPath
-> Bool
-> (Handle 'HandleModeWrite -> ShellT env m a)
-> ShellT env m a
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Bool
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Integer
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> Bool -> ShellT env m ()
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> Integer -> ShellT env m ()
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ()
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ByteString
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> SeekMode -> Integer -> ShellT env m ()
forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> BufferMode -> ShellT env m ()
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Bool
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Integer
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> Bool -> ShellT env m ()
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> Integer -> ShellT env m ()
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ()
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ByteString
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> SeekMode -> Integer -> ShellT env m ()
forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> BufferMode -> ShellT env m ()
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => OsPath -> Bool -> m (Handle 'HandleModeWrite))
-> (forall a.
    HasCallStack =>
    OsPath -> Bool -> (Handle 'HandleModeWrite -> m a) -> m a)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> Integer -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> BufferMode -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> SeekMode -> Integer -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> m Integer)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> Bool -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ByteString -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> ByteString -> m ByteString)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> m ())
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> m Bool)
-> (forall (p :: HandleMode).
    (CanWrite p, HasCallStack) =>
    Handle p -> m ())
-> MonadHandleWriter m
$copenBinaryFile :: forall env (m :: Type -> Type).
(MonadHandleWriter m, HasCallStack) =>
OsPath -> Bool -> ShellT env m (Handle 'HandleModeWrite)
openBinaryFile :: HasCallStack =>
OsPath -> Bool -> ShellT env m (Handle 'HandleModeWrite)
$cwithBinaryFile :: forall env (m :: Type -> Type) a.
(MonadHandleWriter m, HasCallStack) =>
OsPath
-> Bool
-> (Handle 'HandleModeWrite -> ShellT env m a)
-> ShellT env m a
withBinaryFile :: forall a.
HasCallStack =>
OsPath
-> Bool
-> (Handle 'HandleModeWrite -> ShellT env m a)
-> ShellT env m a
$chClose :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
hClose :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
$chFlush :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
hFlush :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
$chSetFileSize :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> Integer -> ShellT env m ()
hSetFileSize :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> Integer -> ShellT env m ()
$chSetBuffering :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> BufferMode -> ShellT env m ()
hSetBuffering :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> BufferMode -> ShellT env m ()
$chSeek :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> SeekMode -> Integer -> ShellT env m ()
hSeek :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> SeekMode -> Integer -> ShellT env m ()
$chTell :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Integer
hTell :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Integer
$chSetEcho :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> Bool -> ShellT env m ()
hSetEcho :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> Bool -> ShellT env m ()
$chPut :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ()
hPut :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ()
$chPutNonBlocking :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ByteString
hPutNonBlocking :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ByteString -> ShellT env m ByteString
$chLockRaw :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
hLockRaw :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
$chTryLockRaw :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Bool
hTryLockRaw :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m Bool
$chUnlockRaw :: forall env (m :: Type -> Type) (p :: HandleMode).
(MonadHandleWriter m, CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
hUnlockRaw :: forall (p :: HandleMode).
(CanWrite p, HasCallStack) =>
Handle p -> ShellT env m ()
MonadHandleWriter,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall a. IO a -> ShellT env m a) -> MonadIO (ShellT env m)
forall a. IO a -> ShellT env m a
forall env (m :: Type -> Type). MonadIO m => Monad (ShellT env m)
forall env (m :: Type -> Type) a.
MonadIO m =>
IO a -> ShellT env m a
forall (m :: Type -> Type).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
$cliftIO :: forall env (m :: Type -> Type) a.
MonadIO m =>
IO a -> ShellT env m a
liftIO :: forall a. IO a -> ShellT env m a
MonadIO,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall a. HasCallStack => a -> ShellT env m (IORef a))
-> (forall a. HasCallStack => a -> ShellT env m (IORef a))
-> (forall a. HasCallStack => IORef a -> ShellT env m a)
-> (forall a. HasCallStack => IORef a -> ShellT env m a)
-> (forall a. HasCallStack => IORef a -> a -> ShellT env m ())
-> (forall a. HasCallStack => IORef a -> a -> ShellT env m ())
-> (forall a. HasCallStack => IORef a -> a -> ShellT env m ())
-> (forall a. HasCallStack => IORef a -> a -> ShellT env m ())
-> (forall a.
    HasCallStack =>
    IORef a -> (a -> a) -> ShellT env m ())
-> (forall a.
    HasCallStack =>
    IORef a -> (a -> a) -> ShellT env m ())
-> (forall a b.
    HasCallStack =>
    IORef a -> (a -> (a, b)) -> ShellT env m b)
-> (forall a b.
    HasCallStack =>
    IORef a -> (a -> (a, b)) -> ShellT env m b)
-> MonadIORef (ShellT env m)
forall a. HasCallStack => a -> ShellT env m (IORef a)
forall a. HasCallStack => IORef a -> ShellT env m a
forall a. HasCallStack => IORef a -> a -> ShellT env m ()
forall a. HasCallStack => IORef a -> (a -> a) -> ShellT env m ()
forall a b.
HasCallStack =>
IORef a -> (a -> (a, b)) -> ShellT env m b
forall env (m :: Type -> Type).
MonadIORef m =>
Monad (ShellT env m)
forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
a -> ShellT env m (IORef a)
forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> ShellT env m a
forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> a -> ShellT env m ()
forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> (a -> a) -> ShellT env m ()
forall env (m :: Type -> Type) a b.
(MonadIORef m, HasCallStack) =>
IORef a -> (a -> (a, b)) -> ShellT env m b
forall (m :: Type -> Type).
Monad m =>
(forall a. HasCallStack => a -> m (IORef a))
-> (forall a. HasCallStack => a -> m (IORef a))
-> (forall a. HasCallStack => IORef a -> m a)
-> (forall a. HasCallStack => IORef a -> m a)
-> (forall a. HasCallStack => IORef a -> a -> m ())
-> (forall a. HasCallStack => IORef a -> a -> m ())
-> (forall a. HasCallStack => IORef a -> a -> m ())
-> (forall a. HasCallStack => IORef a -> a -> m ())
-> (forall a. HasCallStack => IORef a -> (a -> a) -> m ())
-> (forall a. HasCallStack => IORef a -> (a -> a) -> m ())
-> (forall a b. HasCallStack => IORef a -> (a -> (a, b)) -> m b)
-> (forall a b. HasCallStack => IORef a -> (a -> (a, b)) -> m b)
-> MonadIORef m
$cnewIORef :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
a -> ShellT env m (IORef a)
newIORef :: forall a. HasCallStack => a -> ShellT env m (IORef a)
$cnewIORef' :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
a -> ShellT env m (IORef a)
newIORef' :: forall a. HasCallStack => a -> ShellT env m (IORef a)
$creadIORef :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> ShellT env m a
readIORef :: forall a. HasCallStack => IORef a -> ShellT env m a
$creadIORef' :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> ShellT env m a
readIORef' :: forall a. HasCallStack => IORef a -> ShellT env m a
$cwriteIORef :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> a -> ShellT env m ()
writeIORef :: forall a. HasCallStack => IORef a -> a -> ShellT env m ()
$cwriteIORef' :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> a -> ShellT env m ()
writeIORef' :: forall a. HasCallStack => IORef a -> a -> ShellT env m ()
$catomicWriteIORef :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> a -> ShellT env m ()
atomicWriteIORef :: forall a. HasCallStack => IORef a -> a -> ShellT env m ()
$catomicWriteIORef' :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> a -> ShellT env m ()
atomicWriteIORef' :: forall a. HasCallStack => IORef a -> a -> ShellT env m ()
$cmodifyIORef :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> (a -> a) -> ShellT env m ()
modifyIORef :: forall a. HasCallStack => IORef a -> (a -> a) -> ShellT env m ()
$cmodifyIORef' :: forall env (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
IORef a -> (a -> a) -> ShellT env m ()
modifyIORef' :: forall a. HasCallStack => IORef a -> (a -> a) -> ShellT env m ()
$catomicModifyIORef :: forall env (m :: Type -> Type) a b.
(MonadIORef m, HasCallStack) =>
IORef a -> (a -> (a, b)) -> ShellT env m b
atomicModifyIORef :: forall a b.
HasCallStack =>
IORef a -> (a -> (a, b)) -> ShellT env m b
$catomicModifyIORef' :: forall env (m :: Type -> Type) a b.
(MonadIORef m, HasCallStack) =>
IORef a -> (a -> (a, b)) -> ShellT env m b
atomicModifyIORef' :: forall a b.
HasCallStack =>
IORef a -> (a -> (a, b)) -> ShellT env m b
MonadIORef,
      MonadCatch (ShellT env m)
MonadCatch (ShellT env m) =>
(forall b.
 HasCallStack =>
 ((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
 -> ShellT env m b)
-> (forall b.
    HasCallStack =>
    ((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
    -> ShellT env m b)
-> (forall a b c.
    HasCallStack =>
    ShellT env m a
    -> (a -> ExitCase b -> ShellT env m c)
    -> (a -> ShellT env m b)
    -> ShellT env m (b, c))
-> MonadMask (ShellT env m)
forall b.
HasCallStack =>
((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
-> ShellT env m b
forall a b c.
HasCallStack =>
ShellT env m a
-> (a -> ExitCase b -> ShellT env m c)
-> (a -> ShellT env m b)
-> ShellT env m (b, c)
forall env (m :: Type -> Type).
MonadMask m =>
MonadCatch (ShellT env m)
forall env (m :: Type -> Type) b.
(MonadMask m, HasCallStack) =>
((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
-> ShellT env m b
forall env (m :: Type -> Type) a b c.
(MonadMask m, HasCallStack) =>
ShellT env m a
-> (a -> ExitCase b -> ShellT env m c)
-> (a -> ShellT env m b)
-> ShellT env m (b, c)
forall (m :: Type -> Type).
MonadCatch m =>
(forall b. HasCallStack => ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b.
    HasCallStack =>
    ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    HasCallStack =>
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
$cmask :: forall env (m :: Type -> Type) b.
(MonadMask m, HasCallStack) =>
((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
-> ShellT env m b
mask :: forall b.
HasCallStack =>
((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
-> ShellT env m b
$cuninterruptibleMask :: forall env (m :: Type -> Type) b.
(MonadMask m, HasCallStack) =>
((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
-> ShellT env m b
uninterruptibleMask :: forall b.
HasCallStack =>
((forall a. ShellT env m a -> ShellT env m a) -> ShellT env m b)
-> ShellT env m b
$cgeneralBracket :: forall env (m :: Type -> Type) a b c.
(MonadMask m, HasCallStack) =>
ShellT env m a
-> (a -> ExitCase b -> ShellT env m c)
-> (a -> ShellT env m b)
-> ShellT env m (b, c)
generalBracket :: forall a b c.
HasCallStack =>
ShellT env m a
-> (a -> ExitCase b -> ShellT env m c)
-> (a -> ShellT env m b)
-> ShellT env m (b, c)
MonadMask,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall a. ShellT env m (MVar a))
-> (forall a. a -> ShellT env m (MVar a))
-> (forall a. a -> ShellT env m (MVar a))
-> (forall a. MVar a -> ShellT env m a)
-> (forall a. MVar a -> ShellT env m a)
-> (forall a. MVar a -> a -> ShellT env m ())
-> (forall a. MVar a -> a -> ShellT env m ())
-> (forall a. MVar a -> ShellT env m (Maybe a))
-> (forall a. MVar a -> ShellT env m (Maybe a))
-> (forall a. MVar a -> a -> ShellT env m Bool)
-> (forall a. MVar a -> a -> ShellT env m Bool)
-> (forall a. MVar a -> ShellT env m Bool)
-> (forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b)
-> (forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b)
-> (forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b)
-> (forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b)
-> (forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ())
-> (forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ())
-> (forall a b.
    MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b)
-> (forall a b.
    MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b)
-> (forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ())
-> (forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ())
-> (forall a b.
    MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b)
-> (forall a b.
    MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b)
-> (forall a. MVar a -> ShellT env m (Maybe a))
-> (forall a. MVar a -> ShellT env m (Maybe a))
-> (forall a.
    MVar a -> ShellT env m () -> ShellT env m (Weak (MVar a)))
-> MonadMVar (ShellT env m)
forall a. ShellT env m (MVar a)
forall a. a -> ShellT env m (MVar a)
forall a. MVar a -> ShellT env m a
forall a. MVar a -> ShellT env m Bool
forall a. MVar a -> ShellT env m (Maybe a)
forall a. MVar a -> a -> ShellT env m Bool
forall a. MVar a -> a -> ShellT env m ()
forall a. MVar a -> ShellT env m () -> ShellT env m (Weak (MVar a))
forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ()
forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b
forall a b. MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
forall env (m :: Type -> Type). MonadMVar m => Monad (ShellT env m)
forall env (m :: Type -> Type) a.
MonadMVar m =>
ShellT env m (MVar a)
forall env (m :: Type -> Type) a.
MonadMVar m =>
a -> ShellT env m (MVar a)
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m a
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m Bool
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m (Maybe a)
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> a -> ShellT env m Bool
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> a -> ShellT env m ()
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m () -> ShellT env m (Weak (MVar a))
forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> (a -> ShellT env m a) -> ShellT env m ()
forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m b) -> ShellT env m b
forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
forall (m :: Type -> Type).
Monad m =>
(forall a. m (MVar a))
-> (forall a. a -> m (MVar a))
-> (forall a. a -> m (MVar a))
-> (forall a. MVar a -> m a)
-> (forall a. MVar a -> m a)
-> (forall a. MVar a -> a -> m ())
-> (forall a. MVar a -> a -> m ())
-> (forall a. MVar a -> m (Maybe a))
-> (forall a. MVar a -> m (Maybe a))
-> (forall a. MVar a -> a -> m Bool)
-> (forall a. MVar a -> a -> m Bool)
-> (forall a. MVar a -> m Bool)
-> (forall a b. MVar a -> (a -> m b) -> m b)
-> (forall a b. MVar a -> (a -> m b) -> m b)
-> (forall a b. MVar a -> (a -> m b) -> m b)
-> (forall a b. MVar a -> (a -> m b) -> m b)
-> (forall a. MVar a -> (a -> m a) -> m ())
-> (forall a. MVar a -> (a -> m a) -> m ())
-> (forall a b. MVar a -> (a -> m (a, b)) -> m b)
-> (forall a b. MVar a -> (a -> m (a, b)) -> m b)
-> (forall a. MVar a -> (a -> m a) -> m ())
-> (forall a. MVar a -> (a -> m a) -> m ())
-> (forall a b. MVar a -> (a -> m (a, b)) -> m b)
-> (forall a b. MVar a -> (a -> m (a, b)) -> m b)
-> (forall a. MVar a -> m (Maybe a))
-> (forall a. MVar a -> m (Maybe a))
-> (forall a. MVar a -> m () -> m (Weak (MVar a)))
-> MonadMVar m
$cnewEmptyMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
ShellT env m (MVar a)
newEmptyMVar :: forall a. ShellT env m (MVar a)
$cnewMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
a -> ShellT env m (MVar a)
newMVar :: forall a. a -> ShellT env m (MVar a)
$cnewMVar' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
a -> ShellT env m (MVar a)
newMVar' :: forall a. a -> ShellT env m (MVar a)
$ctakeMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m a
takeMVar :: forall a. MVar a -> ShellT env m a
$ctakeMVar' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m a
takeMVar' :: forall a. MVar a -> ShellT env m a
$cputMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> a -> ShellT env m ()
putMVar :: forall a. MVar a -> a -> ShellT env m ()
$cputMVar' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> a -> ShellT env m ()
putMVar' :: forall a. MVar a -> a -> ShellT env m ()
$ctryTakeMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m (Maybe a)
tryTakeMVar :: forall a. MVar a -> ShellT env m (Maybe a)
$ctryTakeMVar' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m (Maybe a)
tryTakeMVar' :: forall a. MVar a -> ShellT env m (Maybe a)
$ctryPutMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> a -> ShellT env m Bool
tryPutMVar :: forall a. MVar a -> a -> ShellT env m Bool
$ctryPutMVar' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> a -> ShellT env m Bool
tryPutMVar' :: forall a. MVar a -> a -> ShellT env m Bool
$cisEmptyMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m Bool
isEmptyMVar :: forall a. MVar a -> ShellT env m Bool
$cwithMVar :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m b) -> ShellT env m b
withMVar :: forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b
$cwithMVar' :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m b) -> ShellT env m b
withMVar' :: forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b
$cwithMVarMasked :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m b) -> ShellT env m b
withMVarMasked :: forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b
$cwithMVarMasked' :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m b) -> ShellT env m b
withMVarMasked' :: forall a b. MVar a -> (a -> ShellT env m b) -> ShellT env m b
$cmodifyMVar_ :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> (a -> ShellT env m a) -> ShellT env m ()
modifyMVar_ :: forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ()
$cmodifyMVar_' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> (a -> ShellT env m a) -> ShellT env m ()
modifyMVar_' :: forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ()
$cmodifyMVar :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
modifyMVar :: forall a b. MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
$cmodifyMVar' :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
modifyMVar' :: forall a b. MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
$cmodifyMVarMasked_ :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> (a -> ShellT env m a) -> ShellT env m ()
modifyMVarMasked_ :: forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ()
$cmodifyMVarMasked_' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> (a -> ShellT env m a) -> ShellT env m ()
modifyMVarMasked_' :: forall a. MVar a -> (a -> ShellT env m a) -> ShellT env m ()
$cmodifyMVarMasked :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
modifyMVarMasked :: forall a b. MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
$cmodifyMVarMasked' :: forall env (m :: Type -> Type) a b.
MonadMVar m =>
MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
modifyMVarMasked' :: forall a b. MVar a -> (a -> ShellT env m (a, b)) -> ShellT env m b
$ctryReadMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m (Maybe a)
tryReadMVar :: forall a. MVar a -> ShellT env m (Maybe a)
$ctryReadMVar' :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m (Maybe a)
tryReadMVar' :: forall a. MVar a -> ShellT env m (Maybe a)
$cmkWeakMVar :: forall env (m :: Type -> Type) a.
MonadMVar m =>
MVar a -> ShellT env m () -> ShellT env m (Weak (MVar a))
mkWeakMVar :: forall a. MVar a -> ShellT env m () -> ShellT env m (Weak (MVar a))
MonadMVar,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack =>
 NotifySystemOs -> ShellT env m (NotifyEnvF (ShellT env m)))
-> (HasCallStack =>
    NotifyEnvF (ShellT env m) -> Note -> ShellT env m ())
-> MonadNotify (ShellT env m)
HasCallStack =>
NotifySystemOs -> ShellT env m (NotifyEnvF (ShellT env m))
HasCallStack =>
NotifyEnvF (ShellT env m) -> Note -> ShellT env m ()
forall env (m :: Type -> Type).
MonadNotify m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadNotify m, HasCallStack) =>
NotifySystemOs -> ShellT env m (NotifyEnvF (ShellT env m))
forall env (m :: Type -> Type).
(MonadNotify m, HasCallStack) =>
NotifyEnvF (ShellT env m) -> Note -> ShellT env m ()
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => NotifySystemOs -> m (NotifyEnvF m))
-> (HasCallStack => NotifyEnvF m -> Note -> m ()) -> MonadNotify m
$cinitNotifyEnv :: forall env (m :: Type -> Type).
(MonadNotify m, HasCallStack) =>
NotifySystemOs -> ShellT env m (NotifyEnvF (ShellT env m))
initNotifyEnv :: HasCallStack =>
NotifySystemOs -> ShellT env m (NotifyEnvF (ShellT env m))
$cnotify :: forall env (m :: Type -> Type).
(MonadNotify m, HasCallStack) =>
NotifyEnvF (ShellT env m) -> Note -> ShellT env m ()
notify :: HasCallStack =>
NotifyEnvF (ShellT env m) -> Note -> ShellT env m ()
MonadNotify,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => OsPath -> ShellT env m [OsPath])
-> (HasCallStack => OsPath -> ShellT env m [OsPath])
-> (HasCallStack => ShellT env m OsPath)
-> (HasCallStack => ShellT env m OsPath)
-> (HasCallStack => XdgDirectory -> OsPath -> ShellT env m OsPath)
-> (HasCallStack => XdgDirectoryList -> ShellT env m [OsPath])
-> (HasCallStack => OsPath -> ShellT env m OsPath)
-> (HasCallStack => ShellT env m OsPath)
-> (HasCallStack => ShellT env m OsPath)
-> (HasCallStack => OsPath -> ShellT env m Integer)
-> (HasCallStack => OsPath -> ShellT env m OsPath)
-> (HasCallStack => OsPath -> ShellT env m OsPath)
-> (HasCallStack => OsPath -> ShellT env m OsPath)
-> (HasCallStack => OsPath -> ShellT env m Bool)
-> (HasCallStack => OsPath -> ShellT env m Bool)
-> (HasCallStack => OsPath -> ShellT env m Bool)
-> (HasCallStack => OsPath -> ShellT env m (Maybe OsPath))
-> (HasCallStack => OsPath -> ShellT env m [OsPath])
-> (HasCallStack => [OsPath] -> OsPath -> ShellT env m [OsPath])
-> (HasCallStack =>
    (OsPath -> ShellT env m Bool)
    -> [OsPath] -> OsPath -> ShellT env m (Maybe OsPath))
-> (HasCallStack =>
    (OsPath -> ShellT env m Bool)
    -> [OsPath] -> OsPath -> ShellT env m [OsPath])
-> (HasCallStack => OsPath -> ShellT env m Bool)
-> (HasCallStack => OsPath -> ShellT env m OsPath)
-> (HasCallStack => OsPath -> ShellT env m Permissions)
-> (HasCallStack => OsPath -> ShellT env m UTCTime)
-> (HasCallStack => OsPath -> ShellT env m UTCTime)
-> MonadPathReader (ShellT env m)
HasCallStack => ShellT env m OsPath
HasCallStack => [OsPath] -> OsPath -> ShellT env m [OsPath]
HasCallStack => OsPath -> ShellT env m Bool
HasCallStack => OsPath -> ShellT env m Integer
HasCallStack => OsPath -> ShellT env m [OsPath]
HasCallStack => OsPath -> ShellT env m (Maybe OsPath)
HasCallStack => OsPath -> ShellT env m UTCTime
HasCallStack => OsPath -> ShellT env m OsPath
HasCallStack => OsPath -> ShellT env m Permissions
HasCallStack => XdgDirectoryList -> ShellT env m [OsPath]
HasCallStack => XdgDirectory -> OsPath -> ShellT env m OsPath
HasCallStack =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m [OsPath]
HasCallStack =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m (Maybe OsPath)
forall env (m :: Type -> Type).
MonadPathReader m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
ShellT env m OsPath
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
[OsPath] -> OsPath -> ShellT env m [OsPath]
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Bool
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Integer
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m [OsPath]
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m (Maybe OsPath)
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m UTCTime
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m OsPath
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Permissions
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
XdgDirectoryList -> ShellT env m [OsPath]
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
XdgDirectory -> OsPath -> ShellT env m OsPath
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m [OsPath]
forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m (Maybe OsPath)
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => OsPath -> m [OsPath])
-> (HasCallStack => OsPath -> m [OsPath])
-> (HasCallStack => m OsPath)
-> (HasCallStack => m OsPath)
-> (HasCallStack => XdgDirectory -> OsPath -> m OsPath)
-> (HasCallStack => XdgDirectoryList -> m [OsPath])
-> (HasCallStack => OsPath -> m OsPath)
-> (HasCallStack => m OsPath)
-> (HasCallStack => m OsPath)
-> (HasCallStack => OsPath -> m Integer)
-> (HasCallStack => OsPath -> m OsPath)
-> (HasCallStack => OsPath -> m OsPath)
-> (HasCallStack => OsPath -> m OsPath)
-> (HasCallStack => OsPath -> m Bool)
-> (HasCallStack => OsPath -> m Bool)
-> (HasCallStack => OsPath -> m Bool)
-> (HasCallStack => OsPath -> m (Maybe OsPath))
-> (HasCallStack => OsPath -> m [OsPath])
-> (HasCallStack => [OsPath] -> OsPath -> m [OsPath])
-> (HasCallStack =>
    (OsPath -> m Bool) -> [OsPath] -> OsPath -> m (Maybe OsPath))
-> (HasCallStack =>
    (OsPath -> m Bool) -> [OsPath] -> OsPath -> m [OsPath])
-> (HasCallStack => OsPath -> m Bool)
-> (HasCallStack => OsPath -> m OsPath)
-> (HasCallStack => OsPath -> m Permissions)
-> (HasCallStack => OsPath -> m UTCTime)
-> (HasCallStack => OsPath -> m UTCTime)
-> MonadPathReader m
$clistDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m [OsPath]
listDirectory :: HasCallStack => OsPath -> ShellT env m [OsPath]
$cgetDirectoryContents :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m [OsPath]
getDirectoryContents :: HasCallStack => OsPath -> ShellT env m [OsPath]
$cgetCurrentDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
ShellT env m OsPath
getCurrentDirectory :: HasCallStack => ShellT env m OsPath
$cgetHomeDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
ShellT env m OsPath
getHomeDirectory :: HasCallStack => ShellT env m OsPath
$cgetXdgDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
XdgDirectory -> OsPath -> ShellT env m OsPath
getXdgDirectory :: HasCallStack => XdgDirectory -> OsPath -> ShellT env m OsPath
$cgetXdgDirectoryList :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
XdgDirectoryList -> ShellT env m [OsPath]
getXdgDirectoryList :: HasCallStack => XdgDirectoryList -> ShellT env m [OsPath]
$cgetAppUserDataDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m OsPath
getAppUserDataDirectory :: HasCallStack => OsPath -> ShellT env m OsPath
$cgetUserDocumentsDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
ShellT env m OsPath
getUserDocumentsDirectory :: HasCallStack => ShellT env m OsPath
$cgetTemporaryDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
ShellT env m OsPath
getTemporaryDirectory :: HasCallStack => ShellT env m OsPath
$cgetFileSize :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Integer
getFileSize :: HasCallStack => OsPath -> ShellT env m Integer
$ccanonicalizePath :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m OsPath
canonicalizePath :: HasCallStack => OsPath -> ShellT env m OsPath
$cmakeAbsolute :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m OsPath
makeAbsolute :: HasCallStack => OsPath -> ShellT env m OsPath
$cmakeRelativeToCurrentDirectory :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m OsPath
makeRelativeToCurrentDirectory :: HasCallStack => OsPath -> ShellT env m OsPath
$cdoesPathExist :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Bool
doesPathExist :: HasCallStack => OsPath -> ShellT env m Bool
$cdoesFileExist :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Bool
doesFileExist :: HasCallStack => OsPath -> ShellT env m Bool
$cdoesDirectoryExist :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Bool
doesDirectoryExist :: HasCallStack => OsPath -> ShellT env m Bool
$cfindExecutable :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m (Maybe OsPath)
findExecutable :: HasCallStack => OsPath -> ShellT env m (Maybe OsPath)
$cfindExecutables :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m [OsPath]
findExecutables :: HasCallStack => OsPath -> ShellT env m [OsPath]
$cfindExecutablesInDirectories :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
[OsPath] -> OsPath -> ShellT env m [OsPath]
findExecutablesInDirectories :: HasCallStack => [OsPath] -> OsPath -> ShellT env m [OsPath]
$cfindFileWith :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m (Maybe OsPath)
findFileWith :: HasCallStack =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m (Maybe OsPath)
$cfindFilesWith :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m [OsPath]
findFilesWith :: HasCallStack =>
(OsPath -> ShellT env m Bool)
-> [OsPath] -> OsPath -> ShellT env m [OsPath]
$cpathIsSymbolicLink :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Bool
pathIsSymbolicLink :: HasCallStack => OsPath -> ShellT env m Bool
$cgetSymbolicLinkTarget :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m OsPath
getSymbolicLinkTarget :: HasCallStack => OsPath -> ShellT env m OsPath
$cgetPermissions :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m Permissions
getPermissions :: HasCallStack => OsPath -> ShellT env m Permissions
$cgetAccessTime :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m UTCTime
getAccessTime :: HasCallStack => OsPath -> ShellT env m UTCTime
$cgetModificationTime :: forall env (m :: Type -> Type).
(MonadPathReader m, HasCallStack) =>
OsPath -> ShellT env m UTCTime
getModificationTime :: HasCallStack => OsPath -> ShellT env m UTCTime
MonadPathReader,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => OsPath -> ShellT env m ())
-> (HasCallStack => Bool -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> ShellT env m ())
-> (forall a.
    HasCallStack =>
    OsPath -> ShellT env m a -> ShellT env m a)
-> (HasCallStack => OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> Permissions -> ShellT env m ())
-> (HasCallStack => OsPath -> OsPath -> ShellT env m ())
-> (HasCallStack => OsPath -> UTCTime -> ShellT env m ())
-> (HasCallStack => OsPath -> UTCTime -> ShellT env m ())
-> MonadPathWriter (ShellT env m)
HasCallStack => Bool -> OsPath -> ShellT env m ()
HasCallStack => OsPath -> ShellT env m ()
HasCallStack => OsPath -> UTCTime -> ShellT env m ()
HasCallStack => OsPath -> OsPath -> ShellT env m ()
HasCallStack => OsPath -> Permissions -> ShellT env m ()
forall a.
HasCallStack =>
OsPath -> ShellT env m a -> ShellT env m a
forall env (m :: Type -> Type).
MonadPathWriter m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
Bool -> OsPath -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> UTCTime -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> Permissions -> ShellT env m ()
forall env (m :: Type -> Type) a.
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m a -> ShellT env m a
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => OsPath -> m ())
-> (HasCallStack => Bool -> OsPath -> m ())
-> (HasCallStack => OsPath -> m ())
-> (HasCallStack => OsPath -> m ())
-> (HasCallStack => OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> m ())
-> (forall a. HasCallStack => OsPath -> m a -> m a)
-> (HasCallStack => OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> m ())
-> (HasCallStack => OsPath -> Permissions -> m ())
-> (HasCallStack => OsPath -> OsPath -> m ())
-> (HasCallStack => OsPath -> UTCTime -> m ())
-> (HasCallStack => OsPath -> UTCTime -> m ())
-> MonadPathWriter m
$ccreateDirectory :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
createDirectory :: HasCallStack => OsPath -> ShellT env m ()
$ccreateDirectoryIfMissing :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
Bool -> OsPath -> ShellT env m ()
createDirectoryIfMissing :: HasCallStack => Bool -> OsPath -> ShellT env m ()
$cremoveDirectory :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
removeDirectory :: HasCallStack => OsPath -> ShellT env m ()
$cremoveDirectoryRecursive :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
removeDirectoryRecursive :: HasCallStack => OsPath -> ShellT env m ()
$cremovePathForcibly :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
removePathForcibly :: HasCallStack => OsPath -> ShellT env m ()
$crenameDirectory :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
renameDirectory :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$csetCurrentDirectory :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
setCurrentDirectory :: HasCallStack => OsPath -> ShellT env m ()
$cwithCurrentDirectory :: forall env (m :: Type -> Type) a.
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m a -> ShellT env m a
withCurrentDirectory :: forall a.
HasCallStack =>
OsPath -> ShellT env m a -> ShellT env m a
$cremoveFile :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
removeFile :: HasCallStack => OsPath -> ShellT env m ()
$crenameFile :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
renameFile :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$crenamePath :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
renamePath :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$ccopyFile :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
copyFile :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$ccopyFileWithMetadata :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
copyFileWithMetadata :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$ccreateFileLink :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
createFileLink :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$ccreateDirectoryLink :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
createDirectoryLink :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$cremoveDirectoryLink :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> ShellT env m ()
removeDirectoryLink :: HasCallStack => OsPath -> ShellT env m ()
$csetPermissions :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> Permissions -> ShellT env m ()
setPermissions :: HasCallStack => OsPath -> Permissions -> ShellT env m ()
$ccopyPermissions :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> OsPath -> ShellT env m ()
copyPermissions :: HasCallStack => OsPath -> OsPath -> ShellT env m ()
$csetAccessTime :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> UTCTime -> ShellT env m ()
setAccessTime :: HasCallStack => OsPath -> UTCTime -> ShellT env m ()
$csetModificationTime :: forall env (m :: Type -> Type).
(MonadPathWriter m, HasCallStack) =>
OsPath -> UTCTime -> ShellT env m ()
setModificationTime :: HasCallStack => OsPath -> UTCTime -> ShellT env m ()
MonadPathWriter,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => PosixPath -> FileMode -> ShellT env m ())
-> (HasCallStack => Fd -> FileMode -> ShellT env m ())
-> (HasCallStack => FileMode -> ShellT env m FileMode)
-> (HasCallStack =>
    PosixPath -> Bool -> Bool -> Bool -> ShellT env m Bool)
-> (HasCallStack => PosixPath -> ShellT env m Bool)
-> (HasCallStack => PosixPath -> ShellT env m FileStatus)
-> (HasCallStack => Fd -> ShellT env m FileStatus)
-> (HasCallStack => PosixPath -> ShellT env m FileStatus)
-> (HasCallStack => PosixPath -> FileMode -> ShellT env m ())
-> (HasCallStack =>
    PosixPath -> FileMode -> DeviceID -> ShellT env m ())
-> (HasCallStack => PosixPath -> PosixPath -> ShellT env m ())
-> (HasCallStack => PosixPath -> ShellT env m ())
-> (HasCallStack => PosixPath -> PosixPath -> ShellT env m ())
-> (HasCallStack => PosixPath -> ShellT env m PosixPath)
-> (HasCallStack => PosixPath -> PosixPath -> ShellT env m ())
-> (HasCallStack =>
    PosixPath -> UserID -> GroupID -> ShellT env m ())
-> (HasCallStack => Fd -> UserID -> GroupID -> ShellT env m ())
-> (HasCallStack =>
    PosixPath -> UserID -> GroupID -> ShellT env m ())
-> (HasCallStack =>
    PosixPath -> EpochTime -> EpochTime -> ShellT env m ())
-> (HasCallStack => PosixPath -> ShellT env m ())
-> (HasCallStack => PosixPath -> FileOffset -> ShellT env m ())
-> (HasCallStack => Fd -> FileOffset -> ShellT env m ())
-> (HasCallStack => PosixPath -> PathVar -> ShellT env m Limit)
-> (HasCallStack => Fd -> PathVar -> ShellT env m Limit)
-> MonadPosixFiles (ShellT env m)
HasCallStack => FileMode -> ShellT env m FileMode
HasCallStack => Fd -> ShellT env m FileStatus
HasCallStack => Fd -> FileMode -> ShellT env m ()
HasCallStack => Fd -> FileOffset -> ShellT env m ()
HasCallStack => Fd -> UserID -> GroupID -> ShellT env m ()
HasCallStack => Fd -> PathVar -> ShellT env m Limit
HasCallStack => PosixPath -> ShellT env m Bool
HasCallStack => PosixPath -> ShellT env m ()
HasCallStack => PosixPath -> ShellT env m PosixPath
HasCallStack => PosixPath -> ShellT env m FileStatus
HasCallStack =>
PosixPath -> Bool -> Bool -> Bool -> ShellT env m Bool
HasCallStack =>
PosixPath -> EpochTime -> EpochTime -> ShellT env m ()
HasCallStack => PosixPath -> FileMode -> ShellT env m ()
HasCallStack =>
PosixPath -> FileMode -> DeviceID -> ShellT env m ()
HasCallStack => PosixPath -> FileOffset -> ShellT env m ()
HasCallStack => PosixPath -> UserID -> GroupID -> ShellT env m ()
HasCallStack => PosixPath -> PosixPath -> ShellT env m ()
HasCallStack => PosixPath -> PathVar -> ShellT env m Limit
forall env (m :: Type -> Type).
MonadPosixFiles m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
FileMode -> ShellT env m FileMode
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> ShellT env m FileStatus
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> FileMode -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> FileOffset -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> UserID -> GroupID -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> PathVar -> ShellT env m Limit
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m Bool
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m PosixPath
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m FileStatus
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> Bool -> Bool -> Bool -> ShellT env m Bool
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> EpochTime -> EpochTime -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileMode -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileMode -> DeviceID -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileOffset -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> UserID -> GroupID -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> PosixPath -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> PathVar -> ShellT env m Limit
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => PosixPath -> FileMode -> m ())
-> (HasCallStack => Fd -> FileMode -> m ())
-> (HasCallStack => FileMode -> m FileMode)
-> (HasCallStack => PosixPath -> Bool -> Bool -> Bool -> m Bool)
-> (HasCallStack => PosixPath -> m Bool)
-> (HasCallStack => PosixPath -> m FileStatus)
-> (HasCallStack => Fd -> m FileStatus)
-> (HasCallStack => PosixPath -> m FileStatus)
-> (HasCallStack => PosixPath -> FileMode -> m ())
-> (HasCallStack => PosixPath -> FileMode -> DeviceID -> m ())
-> (HasCallStack => PosixPath -> PosixPath -> m ())
-> (HasCallStack => PosixPath -> m ())
-> (HasCallStack => PosixPath -> PosixPath -> m ())
-> (HasCallStack => PosixPath -> m PosixPath)
-> (HasCallStack => PosixPath -> PosixPath -> m ())
-> (HasCallStack => PosixPath -> UserID -> GroupID -> m ())
-> (HasCallStack => Fd -> UserID -> GroupID -> m ())
-> (HasCallStack => PosixPath -> UserID -> GroupID -> m ())
-> (HasCallStack => PosixPath -> EpochTime -> EpochTime -> m ())
-> (HasCallStack => PosixPath -> m ())
-> (HasCallStack => PosixPath -> FileOffset -> m ())
-> (HasCallStack => Fd -> FileOffset -> m ())
-> (HasCallStack => PosixPath -> PathVar -> m Limit)
-> (HasCallStack => Fd -> PathVar -> m Limit)
-> MonadPosixFiles m
$csetFileMode :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileMode -> ShellT env m ()
setFileMode :: HasCallStack => PosixPath -> FileMode -> ShellT env m ()
$csetFdMode :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> FileMode -> ShellT env m ()
setFdMode :: HasCallStack => Fd -> FileMode -> ShellT env m ()
$csetFileCreationMask :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
FileMode -> ShellT env m FileMode
setFileCreationMask :: HasCallStack => FileMode -> ShellT env m FileMode
$cfileAccess :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> Bool -> Bool -> Bool -> ShellT env m Bool
fileAccess :: HasCallStack =>
PosixPath -> Bool -> Bool -> Bool -> ShellT env m Bool
$cfileExist :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m Bool
fileExist :: HasCallStack => PosixPath -> ShellT env m Bool
$cgetFileStatus :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m FileStatus
getFileStatus :: HasCallStack => PosixPath -> ShellT env m FileStatus
$cgetFdStatus :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> ShellT env m FileStatus
getFdStatus :: HasCallStack => Fd -> ShellT env m FileStatus
$cgetSymbolicLinkStatus :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m FileStatus
getSymbolicLinkStatus :: HasCallStack => PosixPath -> ShellT env m FileStatus
$ccreateNamedPipe :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileMode -> ShellT env m ()
createNamedPipe :: HasCallStack => PosixPath -> FileMode -> ShellT env m ()
$ccreateDevice :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileMode -> DeviceID -> ShellT env m ()
createDevice :: HasCallStack =>
PosixPath -> FileMode -> DeviceID -> ShellT env m ()
$ccreateLink :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> PosixPath -> ShellT env m ()
createLink :: HasCallStack => PosixPath -> PosixPath -> ShellT env m ()
$cremoveLink :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m ()
removeLink :: HasCallStack => PosixPath -> ShellT env m ()
$ccreateSymbolicLink :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> PosixPath -> ShellT env m ()
createSymbolicLink :: HasCallStack => PosixPath -> PosixPath -> ShellT env m ()
$creadSymbolicLink :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m PosixPath
readSymbolicLink :: HasCallStack => PosixPath -> ShellT env m PosixPath
$crename :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> PosixPath -> ShellT env m ()
rename :: HasCallStack => PosixPath -> PosixPath -> ShellT env m ()
$csetOwnerAndGroup :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> UserID -> GroupID -> ShellT env m ()
setOwnerAndGroup :: HasCallStack => PosixPath -> UserID -> GroupID -> ShellT env m ()
$csetFdOwnerAndGroup :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> UserID -> GroupID -> ShellT env m ()
setFdOwnerAndGroup :: HasCallStack => Fd -> UserID -> GroupID -> ShellT env m ()
$csetSymbolicLinkOwnerAndGroup :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> UserID -> GroupID -> ShellT env m ()
setSymbolicLinkOwnerAndGroup :: HasCallStack => PosixPath -> UserID -> GroupID -> ShellT env m ()
$csetFileTimes :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> EpochTime -> EpochTime -> ShellT env m ()
setFileTimes :: HasCallStack =>
PosixPath -> EpochTime -> EpochTime -> ShellT env m ()
$ctouchFile :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> ShellT env m ()
touchFile :: HasCallStack => PosixPath -> ShellT env m ()
$csetFileSize :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> FileOffset -> ShellT env m ()
setFileSize :: HasCallStack => PosixPath -> FileOffset -> ShellT env m ()
$csetFdSize :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> FileOffset -> ShellT env m ()
setFdSize :: HasCallStack => Fd -> FileOffset -> ShellT env m ()
$cgetPathVar :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
PosixPath -> PathVar -> ShellT env m Limit
getPathVar :: HasCallStack => PosixPath -> PathVar -> ShellT env m Limit
$cgetFdPathVar :: forall env (m :: Type -> Type).
(MonadPosixFiles m, HasCallStack) =>
Fd -> PathVar -> ShellT env m Limit
getFdPathVar :: HasCallStack => Fd -> PathVar -> ShellT env m Limit
MonadPosixFiles,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack =>
 CreateProcess
 -> ShellT
      env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (HasCallStack =>
    String
    -> CreateProcess
    -> ShellT
         env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (HasCallStack => String -> [String] -> ShellT env m ())
-> (HasCallStack => String -> ShellT env m ())
-> (HasCallStack =>
    String -> [String] -> ShellT env m ProcessHandle)
-> (HasCallStack => String -> ShellT env m ProcessHandle)
-> (HasCallStack => CreateProcess -> String -> ShellT env m String)
-> (HasCallStack =>
    String -> [String] -> String -> ShellT env m String)
-> (HasCallStack =>
    CreateProcess -> String -> ShellT env m (ExitCode, String, String))
-> (HasCallStack =>
    String
    -> [String] -> String -> ShellT env m (ExitCode, String, String))
-> (forall a.
    HasCallStack =>
    CreateProcess
    -> (Maybe Handle
        -> Maybe Handle -> Maybe Handle -> ProcessHandle -> ShellT env m a)
    -> ShellT env m a)
-> (HasCallStack =>
    (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
    -> ShellT env m ())
-> (HasCallStack => ProcessHandle -> ShellT env m (Maybe Pid))
-> (HasCallStack => ShellT env m Pid)
-> (HasCallStack => ProcessHandle -> ShellT env m ExitCode)
-> (HasCallStack => ProcessHandle -> ShellT env m (Maybe ExitCode))
-> (HasCallStack => ProcessHandle -> ShellT env m ())
-> (HasCallStack => ProcessHandle -> ShellT env m ())
-> (HasCallStack => ShellT env m (Handle, Handle))
-> (HasCallStack => ShellT env m (FD, FD))
-> MonadProcess (ShellT env m)
HasCallStack => ShellT env m (Handle, Handle)
HasCallStack => ShellT env m (FD, FD)
HasCallStack => ShellT env m Pid
HasCallStack => String -> ShellT env m ()
HasCallStack => String -> ShellT env m ProcessHandle
HasCallStack => String -> [String] -> ShellT env m ()
HasCallStack => String -> [String] -> ShellT env m ProcessHandle
HasCallStack => String -> [String] -> String -> ShellT env m String
HasCallStack =>
String
-> [String] -> String -> ShellT env m (ExitCode, String, String)
HasCallStack =>
String
-> CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
HasCallStack =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ShellT env m ()
HasCallStack =>
CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
HasCallStack => CreateProcess -> String -> ShellT env m String
HasCallStack =>
CreateProcess -> String -> ShellT env m (ExitCode, String, String)
HasCallStack => ProcessHandle -> ShellT env m (Maybe ExitCode)
HasCallStack => ProcessHandle -> ShellT env m (Maybe Pid)
HasCallStack => ProcessHandle -> ShellT env m ()
HasCallStack => ProcessHandle -> ShellT env m ExitCode
forall a.
HasCallStack =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> ShellT env m a)
-> ShellT env m a
forall env (m :: Type -> Type).
MonadProcess m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ShellT env m (Handle, Handle)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ShellT env m (FD, FD)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ShellT env m Pid
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> ShellT env m ProcessHandle
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> [String] -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> [String] -> ShellT env m ProcessHandle
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> [String] -> String -> ShellT env m String
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String
-> [String] -> String -> ShellT env m (ExitCode, String, String)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String
-> CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ShellT env m ()
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
CreateProcess -> String -> ShellT env m String
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
CreateProcess -> String -> ShellT env m (ExitCode, String, String)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m (Maybe ExitCode)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m (Maybe Pid)
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m ExitCode
forall env (m :: Type -> Type) a.
(MonadProcess m, HasCallStack) =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> ShellT env m a)
-> ShellT env m a
forall (m :: Type -> Type).
Monad m =>
(HasCallStack =>
 CreateProcess
 -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (HasCallStack =>
    String
    -> CreateProcess
    -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (HasCallStack => String -> [String] -> m ())
-> (HasCallStack => String -> m ())
-> (HasCallStack => String -> [String] -> m ProcessHandle)
-> (HasCallStack => String -> m ProcessHandle)
-> (HasCallStack => CreateProcess -> String -> m String)
-> (HasCallStack => String -> [String] -> String -> m String)
-> (HasCallStack =>
    CreateProcess -> String -> m (ExitCode, String, String))
-> (HasCallStack =>
    String -> [String] -> String -> m (ExitCode, String, String))
-> (forall a.
    HasCallStack =>
    CreateProcess
    -> (Maybe Handle
        -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a)
    -> m a)
-> (HasCallStack =>
    (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> m ())
-> (HasCallStack => ProcessHandle -> m (Maybe Pid))
-> (HasCallStack => m Pid)
-> (HasCallStack => ProcessHandle -> m ExitCode)
-> (HasCallStack => ProcessHandle -> m (Maybe ExitCode))
-> (HasCallStack => ProcessHandle -> m ())
-> (HasCallStack => ProcessHandle -> m ())
-> (HasCallStack => m (Handle, Handle))
-> (HasCallStack => m (FD, FD))
-> MonadProcess m
$ccreateProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess :: HasCallStack =>
CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
$ccreateProcess_ :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String
-> CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess_ :: HasCallStack =>
String
-> CreateProcess
-> ShellT
     env m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
$ccallProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> [String] -> ShellT env m ()
callProcess :: HasCallStack => String -> [String] -> ShellT env m ()
$ccallCommand :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> ShellT env m ()
callCommand :: HasCallStack => String -> ShellT env m ()
$cspawnProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> [String] -> ShellT env m ProcessHandle
spawnProcess :: HasCallStack => String -> [String] -> ShellT env m ProcessHandle
$cspawnCommand :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> ShellT env m ProcessHandle
spawnCommand :: HasCallStack => String -> ShellT env m ProcessHandle
$creadCreateProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
CreateProcess -> String -> ShellT env m String
readCreateProcess :: HasCallStack => CreateProcess -> String -> ShellT env m String
$creadProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String -> [String] -> String -> ShellT env m String
readProcess :: HasCallStack => String -> [String] -> String -> ShellT env m String
$creadCreateProcessWithExitCode :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
CreateProcess -> String -> ShellT env m (ExitCode, String, String)
readCreateProcessWithExitCode :: HasCallStack =>
CreateProcess -> String -> ShellT env m (ExitCode, String, String)
$creadProcessWithExitCode :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
String
-> [String] -> String -> ShellT env m (ExitCode, String, String)
readProcessWithExitCode :: HasCallStack =>
String
-> [String] -> String -> ShellT env m (ExitCode, String, String)
$cwithCreateProcess :: forall env (m :: Type -> Type) a.
(MonadProcess m, HasCallStack) =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> ShellT env m a)
-> ShellT env m a
withCreateProcess :: forall a.
HasCallStack =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> ShellT env m a)
-> ShellT env m a
$ccleanupProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ShellT env m ()
cleanupProcess :: HasCallStack =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ShellT env m ()
$cgetPid :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m (Maybe Pid)
getPid :: HasCallStack => ProcessHandle -> ShellT env m (Maybe Pid)
$cgetCurrentPid :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ShellT env m Pid
getCurrentPid :: HasCallStack => ShellT env m Pid
$cwaitForProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m ExitCode
waitForProcess :: HasCallStack => ProcessHandle -> ShellT env m ExitCode
$cgetProcessExitCode :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m (Maybe ExitCode)
getProcessExitCode :: HasCallStack => ProcessHandle -> ShellT env m (Maybe ExitCode)
$cterminateProcess :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m ()
terminateProcess :: HasCallStack => ProcessHandle -> ShellT env m ()
$cinterruptProcessGroupOf :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> ShellT env m ()
interruptProcessGroupOf :: HasCallStack => ProcessHandle -> ShellT env m ()
$ccreatePipe :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ShellT env m (Handle, Handle)
createPipe :: HasCallStack => ShellT env m (Handle, Handle)
$ccreatePipeFd :: forall env (m :: Type -> Type).
(MonadProcess m, HasCallStack) =>
ShellT env m (FD, FD)
createPipeFd :: HasCallStack => ShellT env m (FD, FD)
MonadProcess,
      MonadReader env,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => Int -> ShellT env m ())
-> (forall e.
    (Exception e, HasCallStack) =>
    ThreadId -> e -> ShellT env m ())
-> (HasCallStack => ShellT env m Int)
-> (HasCallStack => Int -> ShellT env m ())
-> (HasCallStack => ThreadId -> ShellT env m (Int, Bool))
-> (HasCallStack => ShellT env m ThreadId)
-> (HasCallStack => ThreadId -> String -> ShellT env m ())
-> (HasCallStack => ThreadId -> ShellT env m (Maybe String))
-> MonadThread (ShellT env m)
HasCallStack => ShellT env m Int
HasCallStack => ShellT env m ThreadId
HasCallStack => Int -> ShellT env m ()
HasCallStack => ThreadId -> ShellT env m (Maybe String)
HasCallStack => ThreadId -> ShellT env m (Int, Bool)
HasCallStack => ThreadId -> String -> ShellT env m ()
forall e.
(Exception e, HasCallStack) =>
ThreadId -> e -> ShellT env m ()
forall env (m :: Type -> Type).
MonadThread m =>
Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ShellT env m Int
forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ShellT env m ThreadId
forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
Int -> ShellT env m ()
forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ThreadId -> ShellT env m (Maybe String)
forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ThreadId -> ShellT env m (Int, Bool)
forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ThreadId -> String -> ShellT env m ()
forall env (m :: Type -> Type) e.
(MonadThread m, Exception e, HasCallStack) =>
ThreadId -> e -> ShellT env m ()
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => Int -> m ())
-> (forall e. (Exception e, HasCallStack) => ThreadId -> e -> m ())
-> (HasCallStack => m Int)
-> (HasCallStack => Int -> m ())
-> (HasCallStack => ThreadId -> m (Int, Bool))
-> (HasCallStack => m ThreadId)
-> (HasCallStack => ThreadId -> String -> m ())
-> (HasCallStack => ThreadId -> m (Maybe String))
-> MonadThread m
$cthreadDelay :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
Int -> ShellT env m ()
threadDelay :: HasCallStack => Int -> ShellT env m ()
$cthrowTo :: forall env (m :: Type -> Type) e.
(MonadThread m, Exception e, HasCallStack) =>
ThreadId -> e -> ShellT env m ()
throwTo :: forall e.
(Exception e, HasCallStack) =>
ThreadId -> e -> ShellT env m ()
$cgetNumCapabilities :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ShellT env m Int
getNumCapabilities :: HasCallStack => ShellT env m Int
$csetNumCapabilities :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
Int -> ShellT env m ()
setNumCapabilities :: HasCallStack => Int -> ShellT env m ()
$cthreadCapability :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ThreadId -> ShellT env m (Int, Bool)
threadCapability :: HasCallStack => ThreadId -> ShellT env m (Int, Bool)
$cmyThreadId :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ShellT env m ThreadId
myThreadId :: HasCallStack => ShellT env m ThreadId
$clabelThread :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ThreadId -> String -> ShellT env m ()
labelThread :: HasCallStack => ThreadId -> String -> ShellT env m ()
$cthreadLabel :: forall env (m :: Type -> Type).
(MonadThread m, HasCallStack) =>
ThreadId -> ShellT env m (Maybe String)
threadLabel :: HasCallStack => ThreadId -> ShellT env m (Maybe String)
MonadThread,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(HasCallStack => ShellT env m ZonedTime)
-> (HasCallStack => UTCTime -> ShellT env m TimeZone)
-> (HasCallStack => UTCTime -> ShellT env m ZonedTime)
-> (HasCallStack => ShellT env m TZ)
-> (HasCallStack => ShellT env m Double)
-> MonadTime (ShellT env m)
HasCallStack => ShellT env m Double
HasCallStack => ShellT env m ZonedTime
HasCallStack => ShellT env m TZ
HasCallStack => UTCTime -> ShellT env m TimeZone
HasCallStack => UTCTime -> ShellT env m ZonedTime
forall env (m :: Type -> Type). MonadTime m => Monad (ShellT env m)
forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
ShellT env m Double
forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
ShellT env m ZonedTime
forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
ShellT env m TZ
forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
UTCTime -> ShellT env m TimeZone
forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
UTCTime -> ShellT env m ZonedTime
forall (m :: Type -> Type).
Monad m =>
(HasCallStack => m ZonedTime)
-> (HasCallStack => UTCTime -> m TimeZone)
-> (HasCallStack => UTCTime -> m ZonedTime)
-> (HasCallStack => m TZ)
-> (HasCallStack => m Double)
-> MonadTime m
$cgetSystemZonedTime :: forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
ShellT env m ZonedTime
getSystemZonedTime :: HasCallStack => ShellT env m ZonedTime
$cgetTimeZone :: forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
UTCTime -> ShellT env m TimeZone
getTimeZone :: HasCallStack => UTCTime -> ShellT env m TimeZone
$cutcToLocalZonedTime :: forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
UTCTime -> ShellT env m ZonedTime
utcToLocalZonedTime :: HasCallStack => UTCTime -> ShellT env m ZonedTime
$cloadLocalTZ :: forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
ShellT env m TZ
loadLocalTZ :: HasCallStack => ShellT env m TZ
$cgetMonotonicTime :: forall env (m :: Type -> Type).
(MonadTime m, HasCallStack) =>
ShellT env m Double
getMonotonicTime :: HasCallStack => ShellT env m Double
MonadTime,
      Monad (ShellT env m)
Monad (ShellT env m) =>
(forall e a. (HasCallStack, Exception e) => e -> ShellT env m a)
-> MonadThrow (ShellT env m)
forall e a. (HasCallStack, Exception e) => e -> ShellT env m a
forall env (m :: Type -> Type).
MonadThrow m =>
Monad (ShellT env m)
forall env (m :: Type -> Type) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> ShellT env m a
forall (m :: Type -> Type).
Monad m =>
(forall e a. (HasCallStack, Exception e) => e -> m a)
-> MonadThrow m
$cthrowM :: forall env (m :: Type -> Type) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> ShellT env m a
throwM :: forall e a. (HasCallStack, Exception e) => e -> ShellT env m a
MonadThrow
    )
    via (ReaderT env m)

unShellT :: ShellT env m a -> ReaderT env m a
unShellT :: forall env (m :: Type -> Type) a. ShellT env m a -> ReaderT env m a
unShellT (MkShellT ReaderT env m a
rdr) = ReaderT env m a
rdr

-- | Runs a 'ShellT' with the given @env@.
runShellT :: forall m env a. ShellT env m a -> env -> m a
runShellT :: forall (m :: Type -> Type) env a. ShellT env m a -> env -> m a
runShellT (MkShellT ReaderT env m a
rdr) = ReaderT env m a -> env -> m a
forall r (m :: Type -> Type) a. ReaderT r m a -> r -> m a
runReaderT ReaderT env m a
rdr
{-# INLINEABLE runShellT #-}

-- Concrete Env here so we can vary our logging logic with other envs
-- (i.e. in tests).

-- Can't use @deriving via m@ due to a bug: GHC version 9.2.5: No skolem info:@.
-- https://gitlab.haskell.org/ghc/ghc/-/issues/15376

deriving newtype instance (MonadRegionLogger m) => MonadRegionLogger (ShellT (Env notifyEnv r) m)

-- REVIEW: Would be nice if we could derive this...

instance (MonadPosixSignals m) => MonadPosixSignals (ShellT env m) where
  raiseSignal :: HasCallStack => FD -> ShellT env m ()
raiseSignal = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (FD -> ReaderT env m ()) -> FD -> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. FD -> ReaderT env m ()
forall (m :: Type -> Type).
(MonadPosixSignals m, HasCallStack) =>
FD -> m ()
raiseSignal
  {-# INLINEABLE raiseSignal #-}

  signalProcess :: FD -> Pid -> ShellT env m ()
signalProcess FD
s = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (Pid -> ReaderT env m ()) -> Pid -> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. FD -> Pid -> ReaderT env m ()
forall (m :: Type -> Type).
MonadPosixSignals m =>
FD -> Pid -> m ()
signalProcess FD
s
  {-# INLINEABLE signalProcess #-}

  signalProcessGroup :: FD -> Pid -> ShellT env m ()
signalProcessGroup FD
s = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (Pid -> ReaderT env m ()) -> Pid -> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. FD -> Pid -> ReaderT env m ()
forall (m :: Type -> Type).
MonadPosixSignals m =>
FD -> Pid -> m ()
signalProcessGroup FD
s
  {-# INLINEABLE signalProcessGroup #-}

  installHandler :: FD
-> Handler (ShellT env m)
-> Maybe SignalSet
-> ShellT env m (Handler (ShellT env m))
installHandler FD
s Handler (ShellT env m)
h Maybe SignalSet
m = ReaderT env m (Handler (ShellT env m))
-> ShellT env m (Handler (ShellT env m))
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m (Handler (ShellT env m))
 -> ShellT env m (Handler (ShellT env m)))
-> ReaderT env m (Handler (ShellT env m))
-> ShellT env m (Handler (ShellT env m))
forall a b. (a -> b) -> a -> b
$ do
    Handler (ReaderT env m) -> Handler (ShellT env m)
forall {env} {m :: Type -> Type}.
Handler (ReaderT env m) -> Handler (ShellT env m)
hFromM (Handler (ReaderT env m) -> Handler (ShellT env m))
-> ReaderT env m (Handler (ReaderT env m))
-> ReaderT env m (Handler (ShellT env m))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> FD
-> Handler (ReaderT env m)
-> Maybe SignalSet
-> ReaderT env m (Handler (ReaderT env m))
forall (m :: Type -> Type).
MonadPosixSignals m =>
FD -> Handler m -> Maybe SignalSet -> m (Handler m)
installHandler FD
s (Handler (ShellT env m) -> Handler (ReaderT env m)
forall {env} {m :: Type -> Type}.
Handler (ShellT env m) -> Handler (ReaderT env m)
hToM Handler (ShellT env m)
h) Maybe SignalSet
m
    where
      hFromM :: Handler (ReaderT env m) -> Handler (ShellT env m)
hFromM = (forall x. ReaderT env m x -> ShellT env m x)
-> Handler (ReaderT env m) -> Handler (ShellT env m)
forall (m :: Type -> Type) (n :: Type -> Type).
(forall x. m x -> n x) -> Handler m -> Handler n
Signals.mapHandler ReaderT env m x -> ShellT env m x
forall x. ReaderT env m x -> ShellT env m x
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT
      hToM :: Handler (ShellT env m) -> Handler (ReaderT env m)
hToM = (forall x. ShellT env m x -> ReaderT env m x)
-> Handler (ShellT env m) -> Handler (ReaderT env m)
forall (m :: Type -> Type) (n :: Type -> Type).
(forall x. m x -> n x) -> Handler m -> Handler n
Signals.mapHandler ShellT env m x -> ReaderT env m x
forall x. ShellT env m x -> ReaderT env m x
forall env (m :: Type -> Type) a. ShellT env m a -> ReaderT env m a
unShellT
  {-# INLINEABLE installHandler #-}

  getSignalMask :: ShellT env m SignalSet
getSignalMask = ReaderT env m SignalSet -> ShellT env m SignalSet
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT ReaderT env m SignalSet
forall (m :: Type -> Type). MonadPosixSignals m => m SignalSet
getSignalMask
  {-# INLINEABLE getSignalMask #-}

  setSignalMask :: SignalSet -> ShellT env m ()
setSignalMask = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (SignalSet -> ReaderT env m ()) -> SignalSet -> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. SignalSet -> ReaderT env m ()
forall (m :: Type -> Type).
MonadPosixSignals m =>
SignalSet -> m ()
setSignalMask
  {-# INLINEABLE setSignalMask #-}

  blockSignals :: SignalSet -> ShellT env m ()
blockSignals = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (SignalSet -> ReaderT env m ()) -> SignalSet -> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. SignalSet -> ReaderT env m ()
forall (m :: Type -> Type).
MonadPosixSignals m =>
SignalSet -> m ()
blockSignals
  {-# INLINEABLE blockSignals #-}

  unblockSignals :: SignalSet -> ShellT env m ()
unblockSignals = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (SignalSet -> ReaderT env m ()) -> SignalSet -> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. SignalSet -> ReaderT env m ()
forall (m :: Type -> Type).
MonadPosixSignals m =>
SignalSet -> m ()
unblockSignals
  {-# INLINEABLE unblockSignals #-}

  scheduleAlarm :: Int -> ShellT env m Int
scheduleAlarm = ReaderT env m Int -> ShellT env m Int
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m Int -> ShellT env m Int)
-> (Int -> ReaderT env m Int) -> Int -> ShellT env m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int -> ReaderT env m Int
forall (m :: Type -> Type). MonadPosixSignals m => Int -> m Int
scheduleAlarm
  {-# INLINEABLE scheduleAlarm #-}

  getPendingSignals :: ShellT env m SignalSet
getPendingSignals = ReaderT env m SignalSet -> ShellT env m SignalSet
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT ReaderT env m SignalSet
forall (m :: Type -> Type). MonadPosixSignals m => m SignalSet
getPendingSignals
  {-# INLINEABLE getPendingSignals #-}

  awaitSignal :: Maybe SignalSet -> ShellT env m ()
awaitSignal = ReaderT env m () -> ShellT env m ()
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m () -> ShellT env m ())
-> (Maybe SignalSet -> ReaderT env m ())
-> Maybe SignalSet
-> ShellT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Maybe SignalSet -> ReaderT env m ()
forall (m :: Type -> Type).
MonadPosixSignals m =>
Maybe SignalSet -> m ()
awaitSignal
  {-# INLINEABLE awaitSignal #-}

  setStoppedChildFlag :: Bool -> ShellT env m Bool
setStoppedChildFlag = ReaderT env m Bool -> ShellT env m Bool
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT (ReaderT env m Bool -> ShellT env m Bool)
-> (Bool -> ReaderT env m Bool) -> Bool -> ShellT env m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Bool -> ReaderT env m Bool
forall (m :: Type -> Type). MonadPosixSignals m => Bool -> m Bool
setStoppedChildFlag
  {-# INLINEABLE setStoppedChildFlag #-}

  queryStoppedChildFlag :: ShellT env m Bool
queryStoppedChildFlag = ReaderT env m Bool -> ShellT env m Bool
forall env (m :: Type -> Type) a. ReaderT env m a -> ShellT env m a
MkShellT ReaderT env m Bool
forall (m :: Type -> Type). MonadPosixSignals m => m Bool
queryStoppedChildFlag
  {-# INLINEABLE queryStoppedChildFlag #-}