{-# OPTIONS_GHC -Wno-duplicate-exports #-}

-- | Provides the 'MonadProcess' typeclass for process effects.
--
-- @since 0.1
module Effects.System.Process
  ( -- * Effect
    MonadProcess (..),

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

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

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

    -- * Re-exports
    Handle,
  )
where

import Control.Monad.Trans.Class (MonadTrans (lift))
import Control.Monad.Trans.Reader (ReaderT (runReaderT), ask)
import GHC.Stack (HasCallStack)
import System.Exit (ExitCode)
import System.IO (Handle)
import System.Posix.Internals (FD)
import System.Process (CreateProcess, Pid, ProcessHandle)
import System.Process qualified as P

-- | Effect for launching processes. API largely follows
-- [process](https://hackage.haskell.org/package/process).
--
-- @since 0.1
class (Monad m) => MonadProcess m where
  -- | @since 0.1
  createProcess ::
    (HasCallStack) =>
    -- | .
    CreateProcess ->
    m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

  -- | @since 0.1
  createProcess_ ::
    (HasCallStack) =>
    -- | .
    String ->
    CreateProcess ->
    m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

  -- | @since 0.1
  callProcess :: (HasCallStack) => FilePath -> [String] -> m ()

  -- | @since 0.1
  callCommand :: (HasCallStack) => String -> m ()

  -- | @since 0.1
  spawnProcess :: (HasCallStack) => FilePath -> [String] -> m ProcessHandle

  -- | @since 0.1
  spawnCommand :: (HasCallStack) => String -> m ProcessHandle

  -- | @since 0.1
  readCreateProcess :: (HasCallStack) => CreateProcess -> String -> m String

  -- | @since 0.1
  readProcess ::
    (HasCallStack) =>
    -- | .
    FilePath ->
    [String] ->
    String ->
    m String

  -- | @since 0.1
  readCreateProcessWithExitCode ::
    (HasCallStack) =>
    -- | .
    CreateProcess ->
    String ->
    m (ExitCode, String, String)

  -- | @since 0.1
  readProcessWithExitCode ::
    (HasCallStack) =>
    -- | .
    FilePath ->
    [String] ->
    String ->
    m (ExitCode, String, String)

  -- | @since 0.1
  withCreateProcess ::
    (HasCallStack) =>
    -- | .
    CreateProcess ->
    (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a) ->
    m a

  -- | @since 0.1
  cleanupProcess ::
    (HasCallStack) =>
    -- | .
    (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) ->
    m ()

  -- | @since 0.1
  getPid :: (HasCallStack) => ProcessHandle -> m (Maybe Pid)

  -- | @since 0.1
  getCurrentPid :: (HasCallStack) => m Pid

  -- | @since 0.1
  waitForProcess :: (HasCallStack) => ProcessHandle -> m ExitCode

  -- | @since 0.1
  getProcessExitCode :: (HasCallStack) => ProcessHandle -> m (Maybe ExitCode)

  -- | @since 0.1
  terminateProcess :: (HasCallStack) => ProcessHandle -> m ()

  -- | @since 0.1
  interruptProcessGroupOf :: (HasCallStack) => ProcessHandle -> m ()

  -- | @since 0.1
  createPipe :: (HasCallStack) => m (Handle, Handle)

  -- | @since 0.1
  createPipeFd :: (HasCallStack) => m (FD, FD)

-- | @since 0.1
instance MonadProcess IO where
  createProcess :: HasCallStack =>
CreateProcess
-> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess = CreateProcess
-> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
P.createProcess
  {-# INLINEABLE createProcess #-}

  createProcess_ :: HasCallStack =>
String
-> CreateProcess
-> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess_ = String
-> CreateProcess
-> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
P.createProcess_
  {-# INLINEABLE createProcess_ #-}

  callProcess :: HasCallStack => String -> [String] -> IO ()
callProcess = String -> [String] -> IO ()
P.callProcess
  {-# INLINEABLE callProcess #-}

  callCommand :: HasCallStack => String -> IO ()
callCommand = String -> IO ()
P.callCommand
  {-# INLINEABLE callCommand #-}

  spawnProcess :: HasCallStack => String -> [String] -> IO ProcessHandle
spawnProcess = String -> [String] -> IO ProcessHandle
P.spawnProcess
  {-# INLINEABLE spawnProcess #-}

  spawnCommand :: HasCallStack => String -> IO ProcessHandle
spawnCommand = String -> IO ProcessHandle
P.spawnCommand
  {-# INLINEABLE spawnCommand #-}

  readCreateProcess :: HasCallStack => CreateProcess -> String -> IO String
readCreateProcess = CreateProcess -> String -> IO String
P.readCreateProcess
  {-# INLINEABLE readCreateProcess #-}

  readProcess :: HasCallStack => String -> [String] -> String -> IO String
readProcess = String -> [String] -> String -> IO String
P.readProcess
  {-# INLINEABLE readProcess #-}

  readCreateProcessWithExitCode :: HasCallStack =>
CreateProcess -> String -> IO (ExitCode, String, String)
readCreateProcessWithExitCode = CreateProcess -> String -> IO (ExitCode, String, String)
P.readCreateProcessWithExitCode
  {-# INLINEABLE readCreateProcessWithExitCode #-}

  readProcessWithExitCode :: HasCallStack =>
String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode = String -> [String] -> String -> IO (ExitCode, String, String)
P.readProcessWithExitCode
  {-# INLINEABLE readProcessWithExitCode #-}

  withCreateProcess :: forall a.
HasCallStack =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> IO a)
-> IO a
withCreateProcess = CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> IO a)
-> IO a
forall a.
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> IO a)
-> IO a
P.withCreateProcess
  {-# INLINEABLE withCreateProcess #-}

  cleanupProcess :: HasCallStack =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> IO ()
cleanupProcess = (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> IO ()
P.cleanupProcess
  {-# INLINEABLE cleanupProcess #-}

  getPid :: HasCallStack => ProcessHandle -> IO (Maybe Pid)
getPid = ProcessHandle -> IO (Maybe Pid)
P.getPid
  {-# INLINEABLE getPid #-}

  getCurrentPid :: HasCallStack => IO Pid
getCurrentPid = IO Pid
P.getCurrentPid
  {-# INLINEABLE getCurrentPid #-}

  waitForProcess :: HasCallStack => ProcessHandle -> IO ExitCode
waitForProcess = ProcessHandle -> IO ExitCode
P.waitForProcess
  {-# INLINEABLE waitForProcess #-}

  getProcessExitCode :: HasCallStack => ProcessHandle -> IO (Maybe ExitCode)
getProcessExitCode = ProcessHandle -> IO (Maybe ExitCode)
P.getProcessExitCode
  {-# INLINEABLE getProcessExitCode #-}

  terminateProcess :: HasCallStack => ProcessHandle -> IO ()
terminateProcess = ProcessHandle -> IO ()
P.terminateProcess
  {-# INLINEABLE terminateProcess #-}

  interruptProcessGroupOf :: HasCallStack => ProcessHandle -> IO ()
interruptProcessGroupOf = ProcessHandle -> IO ()
P.interruptProcessGroupOf
  {-# INLINEABLE interruptProcessGroupOf #-}

  createPipe :: HasCallStack => IO (Handle, Handle)
createPipe = IO (Handle, Handle)
P.createPipe
  {-# INLINEABLE createPipe #-}

  createPipeFd :: HasCallStack => IO (FD, FD)
createPipeFd = IO (FD, FD)
P.createPipeFd
  {-# INLINEABLE createPipeFd #-}

-- | @since 0.1
instance (MonadProcess m) => MonadProcess (ReaderT e m) where
  createProcess :: HasCallStack =>
CreateProcess
-> ReaderT
     e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess = m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ReaderT
     e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
 -> ReaderT
      e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (CreateProcess
    -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> CreateProcess
-> ReaderT
     e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess
-> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
CreateProcess
-> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess
  {-# INLINEABLE createProcess #-}

  createProcess_ :: HasCallStack =>
String
-> CreateProcess
-> ReaderT
     e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess_ String
x1 = m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ReaderT
     e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
 -> ReaderT
      e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> (CreateProcess
    -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle))
-> CreateProcess
-> ReaderT
     e m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String
-> CreateProcess
-> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String
-> CreateProcess
-> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
createProcess_ String
x1
  {-# INLINEABLE createProcess_ #-}

  callProcess :: HasCallStack => String -> [String] -> ReaderT e m ()
callProcess String
x1 = m () -> ReaderT e m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT e m ())
-> ([String] -> m ()) -> [String] -> ReaderT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> m ()
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String -> [String] -> m ()
callProcess String
x1
  {-# INLINEABLE callProcess #-}

  callCommand :: HasCallStack => String -> ReaderT e m ()
callCommand = m () -> ReaderT e m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT e m ())
-> (String -> m ()) -> String -> ReaderT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> m ()
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String -> m ()
callCommand
  {-# INLINEABLE callCommand #-}

  spawnProcess :: HasCallStack => String -> [String] -> ReaderT e m ProcessHandle
spawnProcess String
x1 = m ProcessHandle -> ReaderT e m ProcessHandle
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ProcessHandle -> ReaderT e m ProcessHandle)
-> ([String] -> m ProcessHandle)
-> [String]
-> ReaderT e m ProcessHandle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> m ProcessHandle
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String -> [String] -> m ProcessHandle
spawnProcess String
x1
  {-# INLINEABLE spawnProcess #-}

  spawnCommand :: HasCallStack => String -> ReaderT e m ProcessHandle
spawnCommand = m ProcessHandle -> ReaderT e m ProcessHandle
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ProcessHandle -> ReaderT e m ProcessHandle)
-> (String -> m ProcessHandle)
-> String
-> ReaderT e m ProcessHandle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> m ProcessHandle
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String -> m ProcessHandle
spawnCommand
  {-# INLINEABLE spawnCommand #-}

  readCreateProcess :: HasCallStack => CreateProcess -> String -> ReaderT e m String
readCreateProcess CreateProcess
x1 = m String -> ReaderT e m String
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m String -> ReaderT e m String)
-> (String -> m String) -> String -> ReaderT e m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess -> String -> m String
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
CreateProcess -> String -> m String
readCreateProcess CreateProcess
x1
  {-# INLINEABLE readCreateProcess #-}

  readProcess :: HasCallStack => String -> [String] -> String -> ReaderT e m String
readProcess String
x1 [String]
x2 = m String -> ReaderT e m String
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m String -> ReaderT e m String)
-> (String -> m String) -> String -> ReaderT e m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> String -> m String
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String -> [String] -> String -> m String
readProcess String
x1 [String]
x2
  {-# INLINEABLE readProcess #-}

  readCreateProcessWithExitCode :: HasCallStack =>
CreateProcess -> String -> ReaderT e m (ExitCode, String, String)
readCreateProcessWithExitCode CreateProcess
x1 = m (ExitCode, String, String)
-> ReaderT e m (ExitCode, String, String)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ExitCode, String, String)
 -> ReaderT e m (ExitCode, String, String))
-> (String -> m (ExitCode, String, String))
-> String
-> ReaderT e m (ExitCode, String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CreateProcess -> String -> m (ExitCode, String, String)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
CreateProcess -> String -> m (ExitCode, String, String)
readCreateProcessWithExitCode CreateProcess
x1
  {-# INLINEABLE readCreateProcessWithExitCode #-}

  readProcessWithExitCode :: HasCallStack =>
String
-> [String] -> String -> ReaderT e m (ExitCode, String, String)
readProcessWithExitCode String
x1 [String]
x2 = m (ExitCode, String, String)
-> ReaderT e m (ExitCode, String, String)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ExitCode, String, String)
 -> ReaderT e m (ExitCode, String, String))
-> (String -> m (ExitCode, String, String))
-> String
-> ReaderT e m (ExitCode, String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> String -> m (ExitCode, String, String)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
String -> [String] -> String -> m (ExitCode, String, String)
readProcessWithExitCode String
x1 [String]
x2
  {-# INLINEABLE readProcessWithExitCode #-}

  withCreateProcess :: forall a.
HasCallStack =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> ReaderT e m a)
-> ReaderT e m a
withCreateProcess CreateProcess
cp Maybe Handle
-> Maybe Handle -> Maybe Handle -> ProcessHandle -> ReaderT e m a
f =
    ReaderT e m e
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask ReaderT e m e -> (e -> ReaderT e m a) -> ReaderT e m a
forall a b. ReaderT e m a -> (a -> ReaderT e m b) -> ReaderT e m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \e
env ->
      m a -> ReaderT e m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a)
-> m a
forall a.
HasCallStack =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a)
-> m a
forall (m :: * -> *) a.
(MonadProcess m, HasCallStack) =>
CreateProcess
-> (Maybe Handle
    -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a)
-> m a
withCreateProcess CreateProcess
cp (\Maybe Handle
h1 Maybe Handle
h2 Maybe Handle
h3 ProcessHandle
ph -> ReaderT e m a -> e -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Maybe Handle
-> Maybe Handle -> Maybe Handle -> ProcessHandle -> ReaderT e m a
f Maybe Handle
h1 Maybe Handle
h2 Maybe Handle
h3 ProcessHandle
ph) e
env))
  {-# INLINEABLE withCreateProcess #-}

  cleanupProcess :: HasCallStack =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ReaderT e m ()
cleanupProcess = m () -> ReaderT e m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT e m ())
-> ((Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
    -> m ())
-> (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-> ReaderT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> m ()
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
(Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> m ()
cleanupProcess
  {-# INLINEABLE cleanupProcess #-}

  getPid :: HasCallStack => ProcessHandle -> ReaderT e m (Maybe Pid)
getPid = m (Maybe Pid) -> ReaderT e m (Maybe Pid)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe Pid) -> ReaderT e m (Maybe Pid))
-> (ProcessHandle -> m (Maybe Pid))
-> ProcessHandle
-> ReaderT e m (Maybe Pid)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> m (Maybe Pid)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> m (Maybe Pid)
getPid
  {-# INLINEABLE getPid #-}

  getCurrentPid :: HasCallStack => ReaderT e m Pid
getCurrentPid = m Pid -> ReaderT e m Pid
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Pid
forall (m :: * -> *). (MonadProcess m, HasCallStack) => m Pid
getCurrentPid
  {-# INLINEABLE getCurrentPid #-}

  waitForProcess :: HasCallStack => ProcessHandle -> ReaderT e m ExitCode
waitForProcess = m ExitCode -> ReaderT e m ExitCode
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ExitCode -> ReaderT e m ExitCode)
-> (ProcessHandle -> m ExitCode)
-> ProcessHandle
-> ReaderT e m ExitCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> m ExitCode
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> m ExitCode
waitForProcess
  {-# INLINEABLE waitForProcess #-}

  getProcessExitCode :: HasCallStack => ProcessHandle -> ReaderT e m (Maybe ExitCode)
getProcessExitCode = m (Maybe ExitCode) -> ReaderT e m (Maybe ExitCode)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe ExitCode) -> ReaderT e m (Maybe ExitCode))
-> (ProcessHandle -> m (Maybe ExitCode))
-> ProcessHandle
-> ReaderT e m (Maybe ExitCode)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> m (Maybe ExitCode)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> m (Maybe ExitCode)
getProcessExitCode
  {-# INLINEABLE getProcessExitCode #-}

  terminateProcess :: HasCallStack => ProcessHandle -> ReaderT e m ()
terminateProcess = m () -> ReaderT e m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT e m ())
-> (ProcessHandle -> m ()) -> ProcessHandle -> ReaderT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> m ()
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> m ()
terminateProcess
  {-# INLINEABLE terminateProcess #-}

  interruptProcessGroupOf :: HasCallStack => ProcessHandle -> ReaderT e m ()
interruptProcessGroupOf = m () -> ReaderT e m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT e m ())
-> (ProcessHandle -> m ()) -> ProcessHandle -> ReaderT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessHandle -> m ()
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
ProcessHandle -> m ()
interruptProcessGroupOf
  {-# INLINEABLE interruptProcessGroupOf #-}

  createPipe :: HasCallStack => ReaderT e m (Handle, Handle)
createPipe = m (Handle, Handle) -> ReaderT e m (Handle, Handle)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m (Handle, Handle)
forall (m :: * -> *).
(MonadProcess m, HasCallStack) =>
m (Handle, Handle)
createPipe
  {-# INLINEABLE createPipe #-}

  createPipeFd :: HasCallStack => ReaderT e m (FD, FD)
createPipeFd = m (FD, FD) -> ReaderT e m (FD, FD)
forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m (FD, FD)
forall (m :: * -> *). (MonadProcess m, HasCallStack) => m (FD, FD)
createPipeFd
  {-# INLINEABLE createPipeFd #-}