{-# LANGUAGE CPP #-}

-- | Provides a dynamic effect for typed process.
--
-- @since 0.1
module Effectful.Process.Dynamic
  ( -- * Effect
    -- $effect
    Process,

    -- * Handler
    runProcess,

    -- * API

    -- ** Running sub-processes
    createProcess,
    createProcess_,
    EP.shell,
    EP.proc,
    EP.CreateProcess (..),
    EP.CmdSpec (..),
    EP.StdStream (..),
    EP.ProcessHandle,

    -- ** Simpler functions for common tasks
    callProcess,
    callCommand,
    spawnProcess,
    spawnCommand,
    readCreateProcess,
    readProcess,
    readCreateProcessWithExitCode,
    readProcessWithExitCode,
    withCreateProcess,
    cleanupProcess,

    -- ** Related utilities
    EP.showCommandForUser,
    Pid,
    getPid,
    getCurrentPid,
    waitForProcess,
    getProcessExitCode,
    terminateProcess,
    interruptProcessGroupOf,
    createPipe,
    createPipeFd,

    -- ** Re-exports
    FD,
    Handle,
  )
where

import Effectful
  ( Eff,
    IOE,
    type (:>),
  )
import Effectful.Dispatch.Dynamic (localSeqUnlift, reinterpret, send)
import Effectful.Process (Pid, ProcessHandle)
import Effectful.Process qualified as EP
import Effectful.Process.Dynamic.Effect (Process)
import Effectful.Process.Dynamic.Effect qualified as Effect
import GHC.Stack (HasCallStack)
import System.Exit (ExitCode)
import System.IO (Handle)
import System.Posix.Internals (FD)

-- $effect
--
-- The full definition for 'Process' is exported from
-- "Effectful.Process.Dynamic.Effect", due to a name clash between some of
-- its constructors and process re-exports. Hence if you need the data
-- constructors, import that module qualified.

-- | Runs 'Process' in 'IO'.
--
-- @since 0.1
runProcess :: (HasCallStack, IOE :> es) => Eff (Process : es) a -> Eff es a
runProcess :: forall (es :: [Effect]) a.
(HasCallStack, IOE :> es) =>
Eff (Process : es) a -> Eff es a
runProcess = (Eff (Process : es) a -> Eff es a)
-> EffectHandler Process (Process : es)
-> Eff (Process : es) a
-> Eff es a
forall (e :: Effect) (handlerEs :: [Effect]) a (es :: [Effect]) b.
(HasCallStack, DispatchOf e ~ 'Dynamic) =>
(Eff handlerEs a -> Eff es b)
-> EffectHandler e handlerEs -> Eff (e : es) a -> Eff es b
reinterpret Eff (Process : es) a -> Eff es a
forall (es :: [Effect]) a.
(HasCallStack, IOE :> es) =>
Eff (Process : es) a -> Eff es a
EP.runProcess (EffectHandler Process (Process : es)
 -> Eff (Process : es) a -> Eff es a)
-> EffectHandler Process (Process : es)
-> Eff (Process : es) a
-> Eff es a
forall a b. (a -> b) -> a -> b
$ \LocalEnv localEs (Process : es)
env -> \case
  Effect.CreateProcess CreateProcess
x1 -> CreateProcess
-> Eff
     (Process : es)
     (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (es :: [Effect]).
(Process :> es) =>
CreateProcess
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
EP.createProcess CreateProcess
x1
  Effect.CreateProcess_ String
x1 CreateProcess
x2 -> String
-> CreateProcess
-> Eff
     (Process : es)
     (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (es :: [Effect]).
(Process :> es) =>
String
-> CreateProcess
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
EP.createProcess_ String
x1 CreateProcess
x2
  Effect.CallProcess String
x1 [String]
x2 -> String -> [String] -> Eff (Process : es) ()
forall (es :: [Effect]).
(Process :> es) =>
String -> [String] -> Eff es ()
EP.callProcess String
x1 [String]
x2
  Effect.CallCommand String
x1 -> String -> Eff (Process : es) ()
forall (es :: [Effect]). (Process :> es) => String -> Eff es ()
EP.callCommand String
x1
  Effect.SpawnProcess String
x1 [String]
x2 -> String -> [String] -> Eff (Process : es) ProcessHandle
forall (es :: [Effect]).
(Process :> es) =>
String -> [String] -> Eff es ProcessHandle
EP.spawnProcess String
x1 [String]
x2
  Effect.SpawnCommand String
x1 -> String -> Eff (Process : es) ProcessHandle
forall (es :: [Effect]).
(Process :> es) =>
String -> Eff es ProcessHandle
EP.spawnCommand String
x1
  Effect.ReadCreateProcess CreateProcess
x1 String
x2 -> CreateProcess -> String -> Eff (Process : es) String
forall (es :: [Effect]).
(Process :> es) =>
CreateProcess -> String -> Eff es String
EP.readCreateProcess CreateProcess
x1 String
x2
  Effect.ReadProcess String
x1 [String]
x2 String
x3 -> String -> [String] -> String -> Eff (Process : es) String
forall (es :: [Effect]).
(Process :> es) =>
String -> [String] -> String -> Eff es String
EP.readProcess String
x1 [String]
x2 String
x3
  Effect.ReadCreateProcessWithExitCode CreateProcess
x1 String
x2 -> CreateProcess
-> String -> Eff (Process : es) (ExitCode, String, String)
forall (es :: [Effect]).
(Process :> es) =>
CreateProcess -> String -> Eff es (ExitCode, String, String)
EP.readCreateProcessWithExitCode CreateProcess
x1 String
x2
  Effect.ReadProcessWithExitCode String
x1 [String]
x2 String
x3 -> String
-> [String]
-> String
-> Eff (Process : es) (ExitCode, String, String)
forall (es :: [Effect]).
(Process :> es) =>
String -> [String] -> String -> Eff es (ExitCode, String, String)
EP.readProcessWithExitCode String
x1 [String]
x2 String
x3
  Effect.WithCreateProcess CreateProcess
x1 Maybe Handle
-> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff localEs a
onProcess -> LocalEnv localEs (Process : es)
-> ((forall r. Eff localEs r -> Eff (Process : es) r)
    -> Eff (Process : es) a)
-> Eff (Process : es) a
forall (es :: [Effect]) (handlerEs :: [Effect])
       (localEs :: [Effect]) a.
(HasCallStack, SharedSuffix es handlerEs) =>
LocalEnv localEs handlerEs
-> ((forall r. Eff localEs r -> Eff es r) -> Eff es a) -> Eff es a
localSeqUnlift LocalEnv localEs (Process : es)
env (((forall r. Eff localEs r -> Eff (Process : es) r)
  -> Eff (Process : es) a)
 -> Eff (Process : es) a)
-> ((forall r. Eff localEs r -> Eff (Process : es) r)
    -> Eff (Process : es) a)
-> Eff (Process : es) a
forall a b. (a -> b) -> a -> b
$ \forall r. Eff localEs r -> Eff (Process : es) r
unlift ->
    CreateProcess
-> (Maybe Handle
    -> Maybe Handle
    -> Maybe Handle
    -> ProcessHandle
    -> Eff (Process : es) a)
-> Eff (Process : es) a
forall (es :: [Effect]) a.
(Process :> es) =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a)
-> Eff es a
EP.withCreateProcess CreateProcess
x1 (\Maybe Handle
y1 Maybe Handle
y2 Maybe Handle
y3 ProcessHandle
y4 -> Eff localEs a -> Eff (Process : es) a
forall r. Eff localEs r -> Eff (Process : es) r
unlift (Maybe Handle
-> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff localEs a
onProcess Maybe Handle
y1 Maybe Handle
y2 Maybe Handle
y3 ProcessHandle
y4))
  Effect.CleanupProcess (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
x1 -> (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Eff (Process : es) ()
forall (es :: [Effect]).
(Process :> es) =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Eff es ()
EP.cleanupProcess (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
x1
  Effect.GetPid ProcessHandle
x1 -> ProcessHandle -> Eff (Process : es) (Maybe Pid)
forall (es :: [Effect]).
(Process :> es) =>
ProcessHandle -> Eff es (Maybe Pid)
EP.getPid ProcessHandle
x1
  Process (Eff localEs) a
Effect.GetCurrentPid -> Eff (Process : es) a
Eff (Process : es) Pid
forall (es :: [Effect]). (Process :> es) => Eff es Pid
EP.getCurrentPid
  Effect.WaitForProcess ProcessHandle
x1 -> ProcessHandle -> Eff (Process : es) ExitCode
forall (es :: [Effect]).
(Process :> es) =>
ProcessHandle -> Eff es ExitCode
EP.waitForProcess ProcessHandle
x1
  Effect.GetProcessExitCode ProcessHandle
x1 -> ProcessHandle -> Eff (Process : es) (Maybe ExitCode)
forall (es :: [Effect]).
(Process :> es) =>
ProcessHandle -> Eff es (Maybe ExitCode)
EP.getProcessExitCode ProcessHandle
x1
  Effect.TerminateProcess ProcessHandle
x1 -> ProcessHandle -> Eff (Process : es) ()
forall (es :: [Effect]).
(Process :> es) =>
ProcessHandle -> Eff es ()
EP.terminateProcess ProcessHandle
x1
  Effect.InterruptProcessGroupOf ProcessHandle
x1 -> ProcessHandle -> Eff (Process : es) ()
forall (es :: [Effect]).
(Process :> es) =>
ProcessHandle -> Eff es ()
EP.interruptProcessGroupOf ProcessHandle
x1
  Process (Eff localEs) a
Effect.CreatePipe -> Eff (Process : es) a
Eff (Process : es) (Handle, Handle)
forall (es :: [Effect]). (Process :> es) => Eff es (Handle, Handle)
EP.createPipe
  Process (Eff localEs) a
Effect.CreatePipeFd -> Eff (Process : es) a
Eff (Process : es) (FD, FD)
forall (es :: [Effect]). (Process :> es) => Eff es (FD, FD)
EP.createPipeFd

-- | Lifted 'EP.createProcess'.
--
-- @since 0.1
createProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  EP.CreateProcess ->
  Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
CreateProcess
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess = Process
  (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process
   (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
 -> Eff
      es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (CreateProcess
    -> Process
         (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> CreateProcess
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess
-> Process
     (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (a :: * -> *).
CreateProcess
-> Process
     a (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
Effect.CreateProcess

-- | Lifted 'EP.createProcess_'.
--
-- @since 0.1
createProcess_ ::
  ( HasCallStack,
    Process :> es
  ) =>
  String ->
  EP.CreateProcess ->
  Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess_ :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String
-> CreateProcess
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess_ String
x1 = Process
  (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process
   (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
 -> Eff
      es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (CreateProcess
    -> Process
         (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> CreateProcess
-> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String
-> CreateProcess
-> Process
     (Eff es) (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (a :: * -> *).
String
-> CreateProcess
-> Process
     a (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
Effect.CreateProcess_ String
x1

-- | Lifted 'EP.callProcess'.
--
-- @since 0.1
callProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  FilePath ->
  [String] ->
  Eff es ()
callProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String -> [String] -> Eff es ()
callProcess String
x1 = Process (Eff es) () -> Eff es ()
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) () -> Eff es ())
-> ([String] -> Process (Eff es) ()) -> [String] -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> Process (Eff es) ()
forall (a :: * -> *). String -> [String] -> Process a ()
Effect.CallProcess String
x1

-- | Lifted 'EP.callCommand'.
--
-- @since 0.1
callCommand ::
  ( HasCallStack,
    Process :> es
  ) =>
  String ->
  Eff es ()
callCommand :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String -> Eff es ()
callCommand = Process (Eff es) () -> Eff es ()
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) () -> Eff es ())
-> (String -> Process (Eff es) ()) -> String -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Process (Eff es) ()
forall (a :: * -> *). String -> Process a ()
Effect.CallCommand

-- | Lifted 'EP.spawnProcess'.
--
-- @since 0.1
spawnProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  FilePath ->
  [String] ->
  Eff es ProcessHandle
spawnProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String -> [String] -> Eff es ProcessHandle
spawnProcess String
x1 = Process (Eff es) ProcessHandle -> Eff es ProcessHandle
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) ProcessHandle -> Eff es ProcessHandle)
-> ([String] -> Process (Eff es) ProcessHandle)
-> [String]
-> Eff es ProcessHandle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> Process (Eff es) ProcessHandle
forall (a :: * -> *). String -> [String] -> Process a ProcessHandle
Effect.SpawnProcess String
x1

-- | Lifted 'EP.spawnCommand'.
--
-- @since 0.1
spawnCommand ::
  ( HasCallStack,
    Process :> es
  ) =>
  String ->
  Eff es ProcessHandle
spawnCommand :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String -> Eff es ProcessHandle
spawnCommand = Process (Eff es) ProcessHandle -> Eff es ProcessHandle
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) ProcessHandle -> Eff es ProcessHandle)
-> (String -> Process (Eff es) ProcessHandle)
-> String
-> Eff es ProcessHandle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Process (Eff es) ProcessHandle
forall (a :: * -> *). String -> Process a ProcessHandle
Effect.SpawnCommand

-- | Lifted 'EP.readCreateProcess'.
--
-- @since 0.1
readCreateProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  EP.CreateProcess ->
  String ->
  Eff es String
readCreateProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
CreateProcess -> String -> Eff es String
readCreateProcess CreateProcess
x1 = Process (Eff es) String -> Eff es String
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) String -> Eff es String)
-> (String -> Process (Eff es) String) -> String -> Eff es String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess -> String -> Process (Eff es) String
forall (a :: * -> *). CreateProcess -> String -> Process a String
Effect.ReadCreateProcess CreateProcess
x1

-- | Lifted 'EP.readProcess'.
--
-- @since 0.1
readProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  FilePath ->
  [String] ->
  String ->
  Eff es String
readProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String -> [String] -> String -> Eff es String
readProcess String
x1 [String]
x2 = Process (Eff es) String -> Eff es String
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) String -> Eff es String)
-> (String -> Process (Eff es) String) -> String -> Eff es String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> String -> Process (Eff es) String
forall (a :: * -> *).
String -> [String] -> String -> Process a String
Effect.ReadProcess String
x1 [String]
x2

-- | Lifted 'EP.readCreateProcessWithExitCode'.
--
-- @since 0.1
readCreateProcessWithExitCode ::
  ( HasCallStack,
    Process :> es
  ) =>
  EP.CreateProcess ->
  String ->
  Eff es (ExitCode, String, String)
readCreateProcessWithExitCode :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
CreateProcess -> String -> Eff es (ExitCode, String, String)
readCreateProcessWithExitCode CreateProcess
x1 = Process (Eff es) (ExitCode, String, String)
-> Eff es (ExitCode, String, String)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) (ExitCode, String, String)
 -> Eff es (ExitCode, String, String))
-> (String -> Process (Eff es) (ExitCode, String, String))
-> String
-> Eff es (ExitCode, String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess
-> String -> Process (Eff es) (ExitCode, String, String)
forall (a :: * -> *).
CreateProcess -> String -> Process a (ExitCode, String, String)
Effect.ReadCreateProcessWithExitCode CreateProcess
x1

-- | Lifted 'EP.readProcessWithExitCode'.
--
-- @since 0.1
readProcessWithExitCode ::
  ( HasCallStack,
    Process :> es
  ) =>
  FilePath ->
  [String] ->
  String ->
  Eff es (ExitCode, String, String)
readProcessWithExitCode :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
String -> [String] -> String -> Eff es (ExitCode, String, String)
readProcessWithExitCode String
x1 [String]
x2 = Process (Eff es) (ExitCode, String, String)
-> Eff es (ExitCode, String, String)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) (ExitCode, String, String)
 -> Eff es (ExitCode, String, String))
-> (String -> Process (Eff es) (ExitCode, String, String))
-> String
-> Eff es (ExitCode, String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String
-> [String]
-> String
-> Process (Eff es) (ExitCode, String, String)
forall (a :: * -> *).
String
-> [String] -> String -> Process a (ExitCode, String, String)
Effect.ReadProcessWithExitCode String
x1 [String]
x2

-- | Lifted 'EP.withCreateProcess'.
--
-- @since 0.1
withCreateProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  EP.CreateProcess ->
  (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a) ->
  Eff es a
withCreateProcess :: forall (es :: [Effect]) a.
(HasCallStack, Process :> es) =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a)
-> Eff es a
withCreateProcess CreateProcess
x1 = Process (Eff es) a -> Eff es a
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) a -> Eff es a)
-> ((Maybe Handle
     -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a)
    -> Process (Eff es) a)
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a)
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a)
-> Process (Eff es) a
forall (a :: * -> *) b.
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> a b)
-> Process a b
Effect.WithCreateProcess CreateProcess
x1

-- | Lifted 'EP.cleanupProcess'.
--
-- @since 0.1
cleanupProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) ->
  Eff es ()
cleanupProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Eff es ()
cleanupProcess = Process (Eff es) () -> Eff es ()
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) () -> Eff es ())
-> ((Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
    -> Process (Eff es) ())
-> (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Process (Eff es) ()
forall (a :: * -> *).
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> Process a ()
Effect.CleanupProcess

-- | Lifted 'EP.getPid'.
--
-- @since 0.1
getPid ::
  ( HasCallStack,
    Process :> es
  ) =>
  ProcessHandle ->
  Eff es (Maybe Pid)
getPid :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
ProcessHandle -> Eff es (Maybe Pid)
getPid = Process (Eff es) (Maybe Pid) -> Eff es (Maybe Pid)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) (Maybe Pid) -> Eff es (Maybe Pid))
-> (ProcessHandle -> Process (Eff es) (Maybe Pid))
-> ProcessHandle
-> Eff es (Maybe Pid)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> Process (Eff es) (Maybe Pid)
forall (a :: * -> *). ProcessHandle -> Process a (Maybe Pid)
Effect.GetPid

-- | Lifted 'EP.getCurrentPid'.
--
-- @since 0.1
getCurrentPid ::
  ( HasCallStack,
    Process :> es
  ) =>
  Eff es Pid
getCurrentPid :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
Eff es Pid
getCurrentPid = Process (Eff es) Pid -> Eff es Pid
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send Process (Eff es) Pid
forall (a :: * -> *). Process a Pid
Effect.GetCurrentPid

-- | Lifted 'EP.waitForProcess'.
--
-- @since 0.1
waitForProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  ProcessHandle ->
  Eff es ExitCode
waitForProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
ProcessHandle -> Eff es ExitCode
waitForProcess = Process (Eff es) ExitCode -> Eff es ExitCode
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) ExitCode -> Eff es ExitCode)
-> (ProcessHandle -> Process (Eff es) ExitCode)
-> ProcessHandle
-> Eff es ExitCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> Process (Eff es) ExitCode
forall (a :: * -> *). ProcessHandle -> Process a ExitCode
Effect.WaitForProcess

-- | Lifted 'EP.getProcessExitCode'.
--
-- @since 0.1
getProcessExitCode ::
  ( HasCallStack,
    Process :> es
  ) =>
  ProcessHandle ->
  Eff es (Maybe ExitCode)
getProcessExitCode :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
ProcessHandle -> Eff es (Maybe ExitCode)
getProcessExitCode = Process (Eff es) (Maybe ExitCode) -> Eff es (Maybe ExitCode)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) (Maybe ExitCode) -> Eff es (Maybe ExitCode))
-> (ProcessHandle -> Process (Eff es) (Maybe ExitCode))
-> ProcessHandle
-> Eff es (Maybe ExitCode)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> Process (Eff es) (Maybe ExitCode)
forall (a :: * -> *). ProcessHandle -> Process a (Maybe ExitCode)
Effect.GetProcessExitCode

-- | Lifted 'EP.terminateProcess'.
--
-- @since 0.1
terminateProcess ::
  ( HasCallStack,
    Process :> es
  ) =>
  ProcessHandle ->
  Eff es ()
terminateProcess :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
ProcessHandle -> Eff es ()
terminateProcess = Process (Eff es) () -> Eff es ()
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) () -> Eff es ())
-> (ProcessHandle -> Process (Eff es) ())
-> ProcessHandle
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> Process (Eff es) ()
forall (a :: * -> *). ProcessHandle -> Process a ()
Effect.TerminateProcess

-- | Lifted 'EP.interruptProcessGroupOf'.
--
-- @since 0.1
interruptProcessGroupOf ::
  ( HasCallStack,
    Process :> es
  ) =>
  ProcessHandle ->
  Eff es ()
interruptProcessGroupOf :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
ProcessHandle -> Eff es ()
interruptProcessGroupOf = Process (Eff es) () -> Eff es ()
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Process (Eff es) () -> Eff es ())
-> (ProcessHandle -> Process (Eff es) ())
-> ProcessHandle
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> Process (Eff es) ()
forall (a :: * -> *). ProcessHandle -> Process a ()
Effect.InterruptProcessGroupOf

-- | Lifted 'EP.createPipe'.
--
-- @since 0.1
createPipe ::
  ( HasCallStack,
    Process :> es
  ) =>
  Eff es (Handle, Handle)
createPipe :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
Eff es (Handle, Handle)
createPipe = Process (Eff es) (Handle, Handle) -> Eff es (Handle, Handle)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send Process (Eff es) (Handle, Handle)
forall (a :: * -> *). Process a (Handle, Handle)
Effect.CreatePipe

-- | Lifted 'EP.createPipeFd'.
--
-- @since 0.1
createPipeFd ::
  ( HasCallStack,
    Process :> es
  ) =>
  Eff es (FD, FD)
createPipeFd :: forall (es :: [Effect]).
(HasCallStack, Process :> es) =>
Eff es (FD, FD)
createPipeFd = Process (Eff es) (FD, FD) -> Eff es (FD, FD)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send Process (Eff es) (FD, FD)
forall (a :: * -> *). Process a (FD, FD)
Effect.CreatePipeFd