-- | 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,
  )
where

import Effectful
  ( Dispatch (Dynamic),
    DispatchOf,
    Eff,
    Effect,
    IOE,
    UnliftStrategy (SeqUnlift),
    type (:>),
  )
import Effectful.Dispatch.Dynamic
  ( HasCallStack,
    localLiftUnlift,
    reinterpret,
    send,
  )
import Effectful.Dynamic.Utils (ShowEffect (showEffectCons))
import Effectful.Posix.Signals.Handler (Handler)
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.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 (PosixSignals : es)
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 ->
    LocalEnv localEs (PosixSignals : es)
-> UnliftStrategy
-> ((forall r. Eff (PosixSignals : es) r -> Eff localEs r)
    -> (forall r. Eff localEs r -> Eff (PosixSignals : es) r)
    -> Eff (PosixSignals : es) a)
-> Eff (PosixSignals : es) a
forall (es :: [(* -> *) -> * -> *])
       (handlerEs :: [(* -> *) -> * -> *])
       (localEs :: [(* -> *) -> * -> *]) a.
(HasCallStack, SharedSuffix es handlerEs) =>
LocalEnv localEs handlerEs
-> UnliftStrategy
-> ((forall r. Eff es r -> Eff localEs r)
    -> (forall r. Eff localEs r -> Eff es r) -> Eff es a)
-> Eff es a
localLiftUnlift LocalEnv localEs (PosixSignals : es)
env UnliftStrategy
SeqUnlift (((forall r. Eff (PosixSignals : es) r -> Eff localEs r)
  -> (forall r. Eff localEs r -> Eff (PosixSignals : es) r)
  -> Eff (PosixSignals : es) a)
 -> Eff (PosixSignals : es) a)
-> ((forall r. Eff (PosixSignals : es) r -> Eff localEs r)
    -> (forall r. Eff localEs r -> Eff (PosixSignals : es) r)
    -> Eff (PosixSignals : es) a)
-> Eff (PosixSignals : es) a
forall a b. (a -> b) -> a -> b
$ \forall r. Eff (PosixSignals : es) r -> Eff localEs r
lift forall r. Eff localEs r -> Eff (PosixSignals : es) r
unlift ->
      (Handler (Eff (PosixSignals : es)) -> a)
-> Eff (PosixSignals : es) (Handler (Eff (PosixSignals : es)))
-> Eff (PosixSignals : es) a
forall a b.
(a -> b) -> Eff (PosixSignals : es) a -> Eff (PosixSignals : es) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((forall r. Eff (PosixSignals : es) r -> Eff localEs r)
-> Handler (Eff (PosixSignals : es)) -> Handler (Eff localEs)
forall (m :: * -> *) (n :: * -> *).
(forall x. m x -> n x) -> Handler m -> Handler n
Handler.mapHandler Eff (PosixSignals : es) x -> Eff localEs x
forall r. Eff (PosixSignals : es) r -> Eff localEs r
lift)
        (Eff (PosixSignals : es) (Handler (Eff (PosixSignals : es)))
 -> Eff (PosixSignals : es) a)
-> (Handler (Eff localEs)
    -> Eff (PosixSignals : es) (Handler (Eff (PosixSignals : es))))
-> Handler (Eff localEs)
-> Eff (PosixSignals : es) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Handler (Eff (PosixSignals : es))
h' -> Signal
-> Handler (Eff (PosixSignals : es))
-> Maybe SignalSet
-> Eff (PosixSignals : es) (Handler (Eff (PosixSignals : es)))
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, PosixSignals :> es) =>
Signal
-> Handler (Eff es) -> Maybe SignalSet -> Eff es (Handler (Eff es))
Static.installHandler Signal
s Handler (Eff (PosixSignals : es))
h' Maybe SignalSet
ms)
        (Handler (Eff (PosixSignals : es))
 -> Eff (PosixSignals : es) (Handler (Eff (PosixSignals : es))))
-> (Handler (Eff localEs) -> Handler (Eff (PosixSignals : es)))
-> Handler (Eff localEs)
-> Eff (PosixSignals : es) (Handler (Eff (PosixSignals : es)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall r. Eff localEs r -> Eff (PosixSignals : es) r)
-> Handler (Eff localEs) -> Handler (Eff (PosixSignals : es))
forall (m :: * -> *) (n :: * -> *).
(forall x. m x -> n x) -> Handler m -> Handler n
Handler.mapHandler Eff localEs x -> Eff (PosixSignals : es) x
forall r. Eff localEs r -> Eff (PosixSignals : es) r
unlift
        (Handler (Eff localEs) -> Eff (PosixSignals : es) a)
-> Handler (Eff localEs) -> Eff (PosixSignals : es) 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