-- | Provides a dynamic effect for "System.Posix.Signals".
--
-- @since 0.1
module Effectful.Posix.Signals.Dynamic
  ( -- * Effect
    PosixSignals (..),
    raiseSignal,
    signalProcess,
    signalProcessGroup,
    installHandler,
    getSignalMask,
    setSignalMask,
    blockSignals,
    unblockSignals,
    scheduleAlarm,
    getPendingSignals,
    awaitSignal,
    setStoppedChildFlag,
    queryStoppedChildFlag,

    -- ** Handler
    runPosixSignals,

    -- * Posix Handler
    Handler (..),
    Handler.mapHandler,
    Handler.PosixHandler,
    Handler.mapHandlerToPosix,
    Handler.mapHandlerFromPosix,

    -- * Re-exports
    Signal,
    SignalSet,
    ProcessID,
    ProcessGroupID,
  )
where

import Effectful
  ( Dispatch (Dynamic),
    DispatchOf,
    Eff,
    Effect,
    IOE,
    UnliftStrategy (ConcUnlift),
    type (:>),
  )
import Effectful.Dispatch.Dynamic
  ( HasCallStack,
    localLiftUnliftIO,
    reinterpret,
    send,
  )
import Effectful.Dynamic.Utils (ShowEffect (showEffectCons))
import Effectful.Posix.Signals.Handler
  ( Handler
      ( Catch,
        CatchInfo,
        CatchInfoOnce,
        CatchOnce,
        Default,
        Ignore
      ),
  )
import Effectful.Posix.Signals.Handler qualified as Handler
import Effectful.Posix.Signals.Static qualified as Static
import System.Posix.Signals (Signal, SignalSet)
import System.Posix.Signals qualified as Signals
import System.Posix.Types (ProcessGroupID, ProcessID)

-- | Dynamic effect for "System.Posix.Files".
--
-- @since 0.1
data PosixSignals :: Effect where
  RaiseSignal :: Signal -> PosixSignals m ()
  SignalProcess :: Signal -> ProcessID -> PosixSignals m ()
  SignalProcessGroup :: Signal -> ProcessGroupID -> PosixSignals m ()
  InstallHandler :: Signal -> Handler m -> Maybe SignalSet -> PosixSignals m (Handler m)
  GetSignalMask :: PosixSignals m SignalSet
  SetSignalMask :: SignalSet -> PosixSignals m ()
  BlockSignals :: SignalSet -> PosixSignals m ()
  UnblockSignals :: SignalSet -> PosixSignals m ()
  ScheduleAlarm :: Int -> PosixSignals m Int
  GetPendingSignals :: PosixSignals m SignalSet
  AwaitSignal :: Maybe SignalSet -> PosixSignals m ()
  SetStoppedChildFlag :: Bool -> PosixSignals m Bool
  QueryStoppedChildFlag :: PosixSignals m Bool

-- | @since 0.1
type instance DispatchOf PosixSignals = Dynamic

-- | @since 0.1
instance ShowEffect PosixSignals where
  showEffectCons :: forall (m :: * -> *) a. PosixSignals m a -> String
showEffectCons = \case
    RaiseSignal {} -> String
"RaiseSignal"
    SignalProcess {} -> String
"SignalProcess"
    SignalProcessGroup {} -> String
"SignalProcessGroup"
    InstallHandler {} -> String
"InstallHandler"
    GetSignalMask {} -> String
"GetSignalMask"
    SetSignalMask {} -> String
"SetSignalMask"
    BlockSignals {} -> String
"BlockSignals"
    UnblockSignals {} -> String
"UnblockSignals"
    ScheduleAlarm {} -> String
"ScheduleAlarm"
    GetPendingSignals {} -> String
"GetPendingSignals"
    AwaitSignal {} -> String
"AwaitSignal"
    SetStoppedChildFlag {} -> String
"SetStoppedChildFlag"
    QueryStoppedChildFlag {} -> String
"QueryStoppedChildFlag"

-- | Runs 'PosixSignals' in 'IO'.
--
-- @since 0.1
runPosixSignals ::
  forall es a.
  (HasCallStack, IOE :> es) =>
  -- | .
  Eff (PosixSignals : es) a ->
  Eff es a
runPosixSignals :: forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, IOE :> es) =>
Eff (PosixSignals : es) a -> Eff es a
runPosixSignals = (Eff (PosixSignals : es) a -> Eff es a)
-> EffectHandler PosixSignals (PosixSignals : es)
-> Eff (PosixSignals : es) a
-> Eff es a
forall (e :: (* -> *) -> * -> *)
       (handlerEs :: [(* -> *) -> * -> *]) a (es :: [(* -> *) -> * -> *])
       b.
(HasCallStack, DispatchOf e ~ 'Dynamic) =>
(Eff handlerEs a -> Eff es b)
-> EffectHandler e handlerEs -> Eff (e : es) a -> Eff es b
reinterpret Eff (PosixSignals : es) a -> Eff es a
forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, IOE :> es) =>
Eff (PosixSignals : es) a -> Eff es a
Static.runPosixSignals (EffectHandler PosixSignals (PosixSignals : es)
 -> Eff (PosixSignals : es) a -> Eff es a)
-> EffectHandler PosixSignals (PosixSignals : es)
-> Eff (PosixSignals : es) a
-> Eff es a
forall a b. (a -> b) -> a -> b
$ \LocalEnv localEs
env -> \case
  RaiseSignal Signal
x1 -> Signal -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal -> Eff es ()
Static.raiseSignal Signal
x1
  SignalProcess Signal
x1 ProcessID
x2 -> Signal -> ProcessID -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal -> ProcessID -> Eff es ()
Static.signalProcess Signal
x1 ProcessID
x2
  SignalProcessGroup Signal
x1 ProcessID
x2 -> Signal -> ProcessID -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal -> ProcessID -> Eff es ()
Static.signalProcessGroup Signal
x1 ProcessID
x2
  InstallHandler Signal
s Handler (Eff localEs)
h Maybe SignalSet
ms ->
    -- The IO installHandler runs the handler in a new thread, hence we
    -- need the concurrent strategy.
    --
    -- Notice that we do /not/ use the Static impl but instead use the
    -- underlying IO directly. We do this to save Handler traversals
    -- i.e. each runner needs to convert to/from the Handler type here to the
    -- posix Handler.
    --
    -- That is, we /could/ re-use the static impl here, using
    --
    --   (localLiftUnlift, mapHandler lift, mapHandler unlift)
    --
    -- instead of
    --
    --   (localLiftUnliftIO, mapHandlerFromPosix lift, mapHandlerToPosix unlift)
    --
    -- But then we would be traversing the Handler type 4 times (2 here,
    -- 2 in static) vs. just 2 here.
    --
    -- Curiously, even if we re-use the static handler, we still need to
    -- use the concurrent strategy here, or we will receive an effectful
    -- runtime exception.
    --
    -- See NOTE: [installHandler concurrency].
    LocalEnv localEs
-> UnliftStrategy
-> ((forall r. IO r -> Eff localEs r)
    -> (forall r. Eff localEs r -> IO r) -> IO a)
-> Eff (PosixSignals : es) a
forall (es :: [(* -> *) -> * -> *])
       (localEs :: [(* -> *) -> * -> *]) a.
(HasCallStack, IOE :> es) =>
LocalEnv localEs
-> UnliftStrategy
-> ((forall r. IO r -> Eff localEs r)
    -> (forall r. Eff localEs r -> IO r) -> IO a)
-> Eff es a
localLiftUnliftIO LocalEnv localEs
env (Persistence -> Limit -> UnliftStrategy
ConcUnlift Persistence
Handler.persistence Limit
Handler.limit) (((forall r. IO r -> Eff localEs r)
  -> (forall r. Eff localEs r -> IO r) -> IO a)
 -> Eff (PosixSignals : es) a)
-> ((forall r. IO r -> Eff localEs r)
    -> (forall r. Eff localEs r -> IO r) -> IO a)
-> Eff (PosixSignals : es) a
forall a b. (a -> b) -> a -> b
$ \forall r. IO r -> Eff localEs r
lift forall r. Eff localEs r -> IO r
unlift ->
      (PosixHandler -> a) -> IO PosixHandler -> IO a
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((forall r. IO r -> Eff localEs r)
-> PosixHandler -> Handler (Eff localEs)
forall (n :: * -> *).
(forall x. IO x -> n x) -> PosixHandler -> Handler n
Handler.mapHandlerFromPosix IO x -> Eff localEs x
forall r. IO r -> Eff localEs r
lift)
        (IO PosixHandler -> IO a)
-> (Handler (Eff localEs) -> IO PosixHandler)
-> Handler (Eff localEs)
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\PosixHandler
x -> Signal -> PosixHandler -> Maybe SignalSet -> IO PosixHandler
Signals.installHandler Signal
s PosixHandler
x Maybe SignalSet
ms)
        (PosixHandler -> IO PosixHandler)
-> (Handler (Eff localEs) -> PosixHandler)
-> Handler (Eff localEs)
-> IO PosixHandler
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall r. Eff localEs r -> IO r)
-> Handler (Eff localEs) -> PosixHandler
forall (m :: * -> *).
(forall x. m x -> IO x) -> Handler m -> PosixHandler
Handler.mapHandlerToPosix Eff localEs x -> IO x
forall r. Eff localEs r -> IO r
unlift
        (Handler (Eff localEs) -> IO a) -> Handler (Eff localEs) -> IO a
forall a b. (a -> b) -> a -> b
$ Handler (Eff localEs)
h
  PosixSignals (Eff localEs) a
GetSignalMask -> Eff (PosixSignals : es) a
Eff (PosixSignals : es) SignalSet
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Eff es SignalSet
Static.getSignalMask
  SetSignalMask SignalSet
x1 -> SignalSet -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
SignalSet -> Eff es ()
Static.setSignalMask SignalSet
x1
  BlockSignals SignalSet
x1 -> SignalSet -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
SignalSet -> Eff es ()
Static.blockSignals SignalSet
x1
  UnblockSignals SignalSet
x1 -> SignalSet -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
SignalSet -> Eff es ()
Static.unblockSignals SignalSet
x1
  ScheduleAlarm Int
x1 -> Int -> Eff (PosixSignals : es) Int
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Int -> Eff es Int
Static.scheduleAlarm Int
x1
  PosixSignals (Eff localEs) a
GetPendingSignals -> Eff (PosixSignals : es) a
Eff (PosixSignals : es) SignalSet
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Eff es SignalSet
Static.getPendingSignals
  AwaitSignal Maybe SignalSet
x1 -> Maybe SignalSet -> Eff (PosixSignals : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Maybe SignalSet -> Eff es ()
Static.awaitSignal Maybe SignalSet
x1
  SetStoppedChildFlag Bool
x1 -> Bool -> Eff (PosixSignals : es) Bool
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Bool -> Eff es Bool
Static.setStoppedChildFlag Bool
x1
  PosixSignals (Eff localEs) a
QueryStoppedChildFlag -> Eff (PosixSignals : es) a
Eff (PosixSignals : es) Bool
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Eff es Bool
Static.queryStoppedChildFlag

-- | Lifted 'Signals.raiseSignal'.
--
-- @since 0.1
raiseSignal ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Signal ->
  Eff es ()
raiseSignal :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal -> Eff es ()
raiseSignal = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (Signal -> PosixSignals (Eff es) ()) -> Signal -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signal -> PosixSignals (Eff es) ()
forall (m :: * -> *). Signal -> PosixSignals m ()
RaiseSignal

-- | Lifted 'Signals.signalProcess'.
--
-- @since 0.1
signalProcess ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Signal ->
  ProcessID ->
  Eff es ()
signalProcess :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal -> ProcessID -> Eff es ()
signalProcess Signal
x1 = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (ProcessID -> PosixSignals (Eff es) ())
-> ProcessID
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signal -> ProcessID -> PosixSignals (Eff es) ()
forall (m :: * -> *). Signal -> ProcessID -> PosixSignals m ()
SignalProcess Signal
x1

-- | Lifted 'Signals.signalProcessGroup'.
--
-- @since 0.1
signalProcessGroup ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Signal ->
  ProcessGroupID ->
  Eff es ()
signalProcessGroup :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal -> ProcessID -> Eff es ()
signalProcessGroup Signal
x1 = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (ProcessID -> PosixSignals (Eff es) ())
-> ProcessID
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signal -> ProcessID -> PosixSignals (Eff es) ()
forall (m :: * -> *). Signal -> ProcessID -> PosixSignals m ()
SignalProcessGroup Signal
x1

-- | Lifted 'Signals.installHandler'.
--
-- @since 0.1
installHandler ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Signal ->
  Handler (Eff es) ->
  Maybe SignalSet ->
  Eff es (Handler (Eff es))
installHandler :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal
-> Handler (Eff es) -> Maybe SignalSet -> Eff es (Handler (Eff es))
installHandler Signal
x1 Handler (Eff es)
x2 = PosixSignals (Eff es) (Handler (Eff es))
-> Eff es (Handler (Eff es))
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) (Handler (Eff es))
 -> Eff es (Handler (Eff es)))
-> (Maybe SignalSet -> PosixSignals (Eff es) (Handler (Eff es)))
-> Maybe SignalSet
-> Eff es (Handler (Eff es))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signal
-> Handler (Eff es)
-> Maybe SignalSet
-> PosixSignals (Eff es) (Handler (Eff es))
forall (m :: * -> *).
Signal
-> Handler m -> Maybe SignalSet -> PosixSignals m (Handler m)
InstallHandler Signal
x1 Handler (Eff es)
x2

-- | Lifted 'Signals.getSignalMask'.
--
-- @since 0.1
getSignalMask ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Eff es SignalSet
getSignalMask :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Eff es SignalSet
getSignalMask = PosixSignals (Eff es) SignalSet -> Eff es SignalSet
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send PosixSignals (Eff es) SignalSet
forall (m :: * -> *). PosixSignals m SignalSet
GetSignalMask

-- | Lifted 'Signals.setSignalMask'.
--
-- @since 0.1
setSignalMask ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  SignalSet ->
  Eff es ()
setSignalMask :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
SignalSet -> Eff es ()
setSignalMask = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (SignalSet -> PosixSignals (Eff es) ())
-> SignalSet
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignalSet -> PosixSignals (Eff es) ()
forall (m :: * -> *). SignalSet -> PosixSignals m ()
SetSignalMask

-- | Lifted 'Signals.blockSignals'.
--
-- @since 0.1
blockSignals ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  SignalSet ->
  Eff es ()
blockSignals :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
SignalSet -> Eff es ()
blockSignals = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (SignalSet -> PosixSignals (Eff es) ())
-> SignalSet
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignalSet -> PosixSignals (Eff es) ()
forall (m :: * -> *). SignalSet -> PosixSignals m ()
BlockSignals

-- | Lifted 'Signals.unblockSignals'.
--
-- @since 0.1
unblockSignals ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  SignalSet ->
  Eff es ()
unblockSignals :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
SignalSet -> Eff es ()
unblockSignals = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (SignalSet -> PosixSignals (Eff es) ())
-> SignalSet
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignalSet -> PosixSignals (Eff es) ()
forall (m :: * -> *). SignalSet -> PosixSignals m ()
UnblockSignals

-- | Lifted 'Signals.scheduleAlarm'.
--
-- @since 0.1
scheduleAlarm ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Int ->
  Eff es Int
scheduleAlarm :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Int -> Eff es Int
scheduleAlarm = PosixSignals (Eff es) Int -> Eff es Int
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) Int -> Eff es Int)
-> (Int -> PosixSignals (Eff es) Int) -> Int -> Eff es Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> PosixSignals (Eff es) Int
forall (m :: * -> *). Int -> PosixSignals m Int
ScheduleAlarm

-- | Lifted 'Signals.getPendingSignals'.
--
-- @since 0.1
getPendingSignals ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Eff es SignalSet
getPendingSignals :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Eff es SignalSet
getPendingSignals = PosixSignals (Eff es) SignalSet -> Eff es SignalSet
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send PosixSignals (Eff es) SignalSet
forall (m :: * -> *). PosixSignals m SignalSet
GetPendingSignals

-- | Lifted 'Signals.awaitSignal'.
--
-- @since 0.1
awaitSignal ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Maybe SignalSet ->
  Eff es ()
awaitSignal :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Maybe SignalSet -> Eff es ()
awaitSignal = PosixSignals (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) () -> Eff es ())
-> (Maybe SignalSet -> PosixSignals (Eff es) ())
-> Maybe SignalSet
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe SignalSet -> PosixSignals (Eff es) ()
forall (m :: * -> *). Maybe SignalSet -> PosixSignals m ()
AwaitSignal

-- | Lifted 'Signals.setStoppedChildFlag'.
--
-- @since 0.1
setStoppedChildFlag ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Bool ->
  Eff es Bool
setStoppedChildFlag :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Bool -> Eff es Bool
setStoppedChildFlag = PosixSignals (Eff es) Bool -> Eff es Bool
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (PosixSignals (Eff es) Bool -> Eff es Bool)
-> (Bool -> PosixSignals (Eff es) Bool) -> Bool -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> PosixSignals (Eff es) Bool
forall (m :: * -> *). Bool -> PosixSignals m Bool
SetStoppedChildFlag

-- | Lifted 'Signals.queryStoppedChildFlag'.
--
-- @since 0.1
queryStoppedChildFlag ::
  ( HasCallStack,
    PosixSignals :> es
  ) =>
  -- | .
  Eff es Bool
queryStoppedChildFlag :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Eff es Bool
queryStoppedChildFlag = PosixSignals (Eff es) Bool -> Eff es Bool
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send PosixSignals (Eff es) Bool
forall (m :: * -> *). PosixSignals m Bool
QueryStoppedChildFlag