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

{- ORMOLU_DISABLE -}

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

    -- * Types
    ProcessConfig,
    StreamSpec,
    StreamType (..),
    Process,

    -- * ProcessConfig
    P.proc,
    P.shell,

    -- * Setters
    P.setStdin,
    P.setStdout,
    P.setStderr,
    P.setWorkingDir,
    P.setWorkingDirInherit,
    P.setEnv,
    P.setEnvInherit,
    P.setCloseFds,
    P.setCreateGroup,
    P.setDelegateCtlc,
    P.setDetachConsole,
    P.setCreateNewConsole,
    P.setNewSession,
#if !WINDOWS
    P.setChildGroup,
    P.setChildGroupInherit,
    P.setChildUser,
    P.setChildUserInherit,
#endif

    -- * Stream specs

    -- ** Built-in stream specs
    P.inherit,
    P.nullStream,
    P.closed,
    P.byteStringInput,
    P.byteStringOutput,
    P.createPipe,
    P.useHandleOpen,
    P.useHandleClose,

    -- ** Create your own stream spec
    P.mkStreamSpec,
    P.mkPipeStreamSpec,

    -- * Launch a process
    runProcess,
    readProcess,
    readProcessStdout,
    readProcessStderr,
    readProcessInterleaved,
    withProcessWait,
    withProcessTerm,
    startProcess,
    stopProcess,

    -- * Exception-throwing functions
    runProcess_,
    readProcess_,
    readProcessStdout_,
    readProcessStderr_,
    readProcessInterleaved_,
    withProcessWait_,
    withProcessTerm_,

    -- * Interact with a process

    -- ** Process exit code
    waitExitCode,
    P.waitExitCodeSTM,
    getExitCode,
    P.getExitCodeSTM,
    checkExitCode,
    P.checkExitCodeSTM,

    -- ** Process streams
    P.getStdin,
    P.getStdout,
    P.getStderr,

    -- * Exceptions
    P.ExitCodeException (..),
    P.ByteStringOutputException (..),

    -- * Re-exports
    P.ExitCode (..),
    P.StdStream (..),

    -- * Unsafe functions
    P.unsafeProcessHandle,
  )
where

{- ORMOLU_ENABLE -}

import Control.Monad.Trans.Class (MonadTrans (lift))
import Control.Monad.Trans.Reader (ReaderT (runReaderT), ask)
import Data.ByteString.Lazy qualified as BSL
import GHC.Stack (HasCallStack)
import System.Exit (ExitCode)
import System.Process.Typed
  ( Process,
    ProcessConfig,
    StreamSpec,
    StreamType (STInput, STOutput),
  )
import System.Process.Typed qualified as P

-- | Effect for launching processes. API largely follows
-- [typed-process](https://hackage.haskell.org/package/typed-process).
--
-- @since 0.1
class (Monad m) => MonadTypedProcess m where
  -- | Lifted 'P.runProcess'.
  --
  -- @since 0.1
  runProcess ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    m ExitCode

  -- | Lifted 'P.readProcess'.
  --
  -- @since 0.1
  readProcess ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdoutIgnored stderrIgnored ->
    m (ExitCode, BSL.ByteString, BSL.ByteString)

  -- | Lifted 'P.readProcessStdout'.
  --
  -- @since 0.1
  readProcessStdout ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdoutIgnored stderr ->
    m (ExitCode, BSL.ByteString)

  -- | Lifted 'P.readProcessStderr'.
  --
  -- @since 0.1
  readProcessStderr ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderrIgnored ->
    m (ExitCode, BSL.ByteString)

  -- | Lifted 'P.readProcessInterleaved'.
  --
  -- @since 0.1
  readProcessInterleaved ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdoutIgnored stderrIgnored ->
    m (ExitCode, BSL.ByteString)

  -- | Lifted 'P.withProcessWait'.
  --
  -- @since 0.1
  withProcessWait ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    (Process stdin stdout stderr -> m a) ->
    m a

  -- | Lifted 'P.withProcessTerm'.
  --
  -- @since 0.1
  withProcessTerm ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    (Process stdin stdout stderr -> m a) ->
    m a

  -- | Lifted 'P.startProcess'.
  --
  -- @since 0.1
  startProcess ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    m (Process stdin stdout stderr)

  -- | Lifted 'P.stopProcess'.
  --
  -- @since 0.1
  stopProcess ::
    (HasCallStack) =>
    -- | .
    Process stdin stdout stderr ->
    m ()

  -- | Lifted 'P.runProcess_'.
  --
  -- @since 0.1
  runProcess_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    m ()

  -- | Lifted 'P.readProcess_'.
  --
  -- @since 0.1
  readProcess_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdoutIgnored stderrIgnored ->
    m (BSL.ByteString, BSL.ByteString)

  -- | Lifted 'P.readProcessStdout_'.
  --
  -- @since 0.1
  readProcessStdout_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdoutIgnored stderr ->
    m BSL.ByteString

  -- | Lifted 'P.readProcessStderr_'.
  --
  -- @since 0.1
  readProcessStderr_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderrIgnored ->
    m BSL.ByteString

  -- | Lifted 'P.readProcessInterleaved_'.
  --
  -- @since 0.1
  readProcessInterleaved_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdoutIgnored stderrIgnored ->
    m BSL.ByteString

  -- | Lifted 'P.withProcessWait_'.
  --
  -- @since 0.1
  withProcessWait_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    (Process stdin stdout stderr -> m a) ->
    m a

  -- | Lifted 'P.withProcessTerm_'.
  --
  -- @since 0.1
  withProcessTerm_ ::
    (HasCallStack) =>
    -- | .
    ProcessConfig stdin stdout stderr ->
    (Process stdin stdout stderr -> m a) ->
    m a

  -- | Lifted 'P.waitExitCode'.
  --
  -- @since 0.1
  waitExitCode ::
    (HasCallStack) =>
    -- | .
    Process stdin stdout stderr ->
    m ExitCode

  -- | Lifted 'P.getExitCode'.
  --
  -- @since 0.1
  getExitCode ::
    (HasCallStack) =>
    -- | .
    Process stdin stdout stderr ->
    m (Maybe ExitCode)

  -- | Lifted 'P.checkExitCode'.
  --
  -- @since 0.1
  checkExitCode ::
    (HasCallStack) =>
    -- | .
    Process stdin stdout stderr ->
    m ()

-- | @since 0.1
instance MonadTypedProcess IO where
  runProcess :: forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr -> IO ExitCode
runProcess = ProcessConfig stdin stdout stderr -> IO ExitCode
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
ProcessConfig stdin stdout stderr -> m ExitCode
P.runProcess
  {-# INLINEABLE runProcess #-}
  readProcess :: forall stdin stdoutIgnored stderrIgnored.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> IO (ExitCode, ByteString, ByteString)
readProcess = ProcessConfig stdin stdoutIgnored stderrIgnored
-> IO (ExitCode, ByteString, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderrIgnored.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ExitCode, ByteString, ByteString)
P.readProcess
  {-# INLINEABLE readProcess #-}
  readProcessStdout :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> IO (ExitCode, ByteString)
readProcessStdout = ProcessConfig stdin stdoutIgnored stderr
-> IO (ExitCode, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderr.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
P.readProcessStdout
  {-# INLINEABLE readProcessStdout #-}
  readProcessStderr :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> IO (ExitCode, ByteString)
readProcessStderr = ProcessConfig stdin stdout stderrIgnored
-> IO (ExitCode, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderr.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
P.readProcessStderr
  {-# INLINEABLE readProcessStderr #-}
  readProcessInterleaved :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> IO (ExitCode, ByteString)
readProcessInterleaved = ProcessConfig stdin stdoutIgnored stderrIgnored
-> IO (ExitCode, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderr.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
P.readProcessInterleaved
  {-# INLINEABLE readProcessInterleaved #-}
  withProcessWait :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
withProcessWait = ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
forall (m :: * -> *) stdin stdout stderr a.
MonadUnliftIO m =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
P.withProcessWait
  {-# INLINEABLE withProcessWait #-}
  withProcessTerm :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
withProcessTerm = ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
forall (m :: * -> *) stdin stdout stderr a.
MonadUnliftIO m =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
P.withProcessTerm
  {-# INLINEABLE withProcessTerm #-}
  startProcess :: forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> IO (Process stdin stdout stderr)
startProcess = ProcessConfig stdin stdout stderr
-> IO (Process stdin stdout stderr)
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
ProcessConfig stdin stdout stderr
-> m (Process stdin stdout stderr)
P.startProcess
  {-# INLINEABLE startProcess #-}
  stopProcess :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> IO ()
stopProcess = Process stdin stdout stderr -> IO ()
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
Process stdin stdout stderr -> m ()
P.stopProcess
  {-# INLINEABLE stopProcess #-}
  runProcess_ :: forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr -> IO ()
runProcess_ = ProcessConfig stdin stdout stderr -> IO ()
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
ProcessConfig stdin stdout stderr -> m ()
P.runProcess_
  {-# INLINEABLE runProcess_ #-}
  readProcess_ :: forall stdin stdoutIgnored stderrIgnored.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> IO (ByteString, ByteString)
readProcess_ = ProcessConfig stdin stdoutIgnored stderrIgnored
-> IO (ByteString, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderrIgnored.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ByteString, ByteString)
P.readProcess_
  {-# INLINEABLE readProcess_ #-}
  readProcessStdout_ :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr -> IO ByteString
readProcessStdout_ = ProcessConfig stdin stdoutIgnored stderr -> IO ByteString
forall (m :: * -> *) stdin stdoutIgnored stderr.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
P.readProcessStdout_
  {-# INLINEABLE readProcessStdout_ #-}
  readProcessStderr_ :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr -> IO ByteString
readProcessStderr_ = ProcessConfig stdin stdout stderrIgnored -> IO ByteString
forall (m :: * -> *) stdin stdoutIgnored stderr.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
P.readProcessStderr_
  {-# INLINEABLE readProcessStderr_ #-}
  readProcessInterleaved_ :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr -> IO ByteString
readProcessInterleaved_ = ProcessConfig stdin stdoutIgnored stderrIgnored -> IO ByteString
forall (m :: * -> *) stdin stdoutIgnored stderr.
MonadIO m =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
P.readProcessInterleaved_
  {-# INLINEABLE readProcessInterleaved_ #-}
  withProcessWait_ :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
withProcessWait_ = ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
forall (m :: * -> *) stdin stdout stderr a.
MonadUnliftIO m =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
P.withProcessWait_
  {-# INLINEABLE withProcessWait_ #-}
  withProcessTerm_ :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
withProcessTerm_ = ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> IO a) -> IO a
forall (m :: * -> *) stdin stdout stderr a.
MonadUnliftIO m =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
P.withProcessTerm_
  {-# INLINEABLE withProcessTerm_ #-}
  waitExitCode :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> IO ExitCode
waitExitCode = Process stdin stdout stderr -> IO ExitCode
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
Process stdin stdout stderr -> m ExitCode
P.waitExitCode
  {-# INLINEABLE waitExitCode #-}
  getExitCode :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> IO (Maybe ExitCode)
getExitCode = Process stdin stdout stderr -> IO (Maybe ExitCode)
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
Process stdin stdout stderr -> m (Maybe ExitCode)
P.getExitCode
  {-# INLINEABLE getExitCode #-}
  checkExitCode :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> IO ()
checkExitCode = Process stdin stdout stderr -> IO ()
forall (m :: * -> *) stdin stdout stderr.
MonadIO m =>
Process stdin stdout stderr -> m ()
P.checkExitCode
  {-# INLINEABLE checkExitCode #-}

-- | @since 0.1
instance (MonadTypedProcess m) => MonadTypedProcess (ReaderT env m) where
  runProcess :: forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr -> ReaderT env m ExitCode
runProcess = m ExitCode -> ReaderT env m ExitCode
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ExitCode -> ReaderT env m ExitCode)
-> (ProcessConfig stdin stdout stderr -> m ExitCode)
-> ProcessConfig stdin stdout stderr
-> ReaderT env m ExitCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdout stderr -> m ExitCode
forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr -> m ExitCode
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr -> m ExitCode
runProcess
  {-# INLINEABLE runProcess #-}
  readProcess :: forall stdin stdoutIgnored stderrIgnored.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> ReaderT env m (ExitCode, ByteString, ByteString)
readProcess = m (ExitCode, ByteString, ByteString)
-> ReaderT env m (ExitCode, ByteString, ByteString)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ExitCode, ByteString, ByteString)
 -> ReaderT env m (ExitCode, ByteString, ByteString))
-> (ProcessConfig stdin stdoutIgnored stderrIgnored
    -> m (ExitCode, ByteString, ByteString))
-> ProcessConfig stdin stdoutIgnored stderrIgnored
-> ReaderT env m (ExitCode, ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ExitCode, ByteString, ByteString)
forall stdin stdoutIgnored stderrIgnored.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ExitCode, ByteString, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderrIgnored.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ExitCode, ByteString, ByteString)
readProcess
  {-# INLINEABLE readProcess #-}
  readProcessStdout :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m (ExitCode, ByteString)
readProcessStdout = m (ExitCode, ByteString) -> ReaderT env m (ExitCode, ByteString)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ExitCode, ByteString) -> ReaderT env m (ExitCode, ByteString))
-> (ProcessConfig stdin stdoutIgnored stderr
    -> m (ExitCode, ByteString))
-> ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m (ExitCode, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
readProcessStdout
  {-# INLINEABLE readProcessStdout #-}
  readProcessStderr :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m (ExitCode, ByteString)
readProcessStderr = m (ExitCode, ByteString) -> ReaderT env m (ExitCode, ByteString)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ExitCode, ByteString) -> ReaderT env m (ExitCode, ByteString))
-> (ProcessConfig stdin stdout stderrIgnored
    -> m (ExitCode, ByteString))
-> ProcessConfig stdin stdout stderrIgnored
-> ReaderT env m (ExitCode, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdout stderrIgnored
-> m (ExitCode, ByteString)
forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
readProcessStderr
  {-# INLINEABLE readProcessStderr #-}
  readProcessInterleaved :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m (ExitCode, ByteString)
readProcessInterleaved = m (ExitCode, ByteString) -> ReaderT env m (ExitCode, ByteString)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ExitCode, ByteString) -> ReaderT env m (ExitCode, ByteString))
-> (ProcessConfig stdin stdoutIgnored stderrIgnored
    -> m (ExitCode, ByteString))
-> ProcessConfig stdin stdoutIgnored stderrIgnored
-> ReaderT env m (ExitCode, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ExitCode, ByteString)
forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderr
-> m (ExitCode, ByteString)
readProcessInterleaved
  {-# INLINEABLE readProcessInterleaved #-}
  withProcessWait :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> ReaderT env m a)
-> ReaderT env m a
withProcessWait ProcessConfig stdin stdout stderr
pc Process stdin stdout stderr -> ReaderT env m a
f =
    ReaderT env m env
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask ReaderT env m env -> (env -> ReaderT env m a) -> ReaderT env m a
forall a b.
ReaderT env m a -> (a -> ReaderT env m b) -> ReaderT env m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \env
e -> m a -> ReaderT env m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT env m a) -> m a -> ReaderT env m a
forall a b. (a -> b) -> a -> b
$ ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall (m :: * -> *) stdin stdout stderr a.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
withProcessWait ProcessConfig stdin stdout stderr
pc (env -> ReaderT env m a -> m a
forall e (m :: * -> *) a. e -> ReaderT e m a -> m a
usingReaderT env
e (ReaderT env m a -> m a)
-> (Process stdin stdout stderr -> ReaderT env m a)
-> Process stdin stdout stderr
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> ReaderT env m a
f)
  {-# INLINEABLE withProcessWait #-}
  withProcessTerm :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> ReaderT env m a)
-> ReaderT env m a
withProcessTerm ProcessConfig stdin stdout stderr
pc Process stdin stdout stderr -> ReaderT env m a
f =
    ReaderT env m env
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask ReaderT env m env -> (env -> ReaderT env m a) -> ReaderT env m a
forall a b.
ReaderT env m a -> (a -> ReaderT env m b) -> ReaderT env m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \env
e -> m a -> ReaderT env m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT env m a) -> m a -> ReaderT env m a
forall a b. (a -> b) -> a -> b
$ ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall (m :: * -> *) stdin stdout stderr a.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
withProcessTerm ProcessConfig stdin stdout stderr
pc (env -> ReaderT env m a -> m a
forall e (m :: * -> *) a. e -> ReaderT e m a -> m a
usingReaderT env
e (ReaderT env m a -> m a)
-> (Process stdin stdout stderr -> ReaderT env m a)
-> Process stdin stdout stderr
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> ReaderT env m a
f)
  {-# INLINEABLE withProcessTerm #-}
  startProcess :: forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> ReaderT env m (Process stdin stdout stderr)
startProcess = m (Process stdin stdout stderr)
-> ReaderT env m (Process stdin stdout stderr)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Process stdin stdout stderr)
 -> ReaderT env m (Process stdin stdout stderr))
-> (ProcessConfig stdin stdout stderr
    -> m (Process stdin stdout stderr))
-> ProcessConfig stdin stdout stderr
-> ReaderT env m (Process stdin stdout stderr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdout stderr
-> m (Process stdin stdout stderr)
forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> m (Process stdin stdout stderr)
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr
-> m (Process stdin stdout stderr)
startProcess
  {-# INLINEABLE startProcess #-}
  stopProcess :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> ReaderT env m ()
stopProcess = m () -> ReaderT env m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT env m ())
-> (Process stdin stdout stderr -> m ())
-> Process stdin stdout stderr
-> ReaderT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> m ()
forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> m ()
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
Process stdin stdout stderr -> m ()
stopProcess
  {-# INLINEABLE stopProcess #-}
  runProcess_ :: forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr -> ReaderT env m ()
runProcess_ = m () -> ReaderT env m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT env m ())
-> (ProcessConfig stdin stdout stderr -> m ())
-> ProcessConfig stdin stdout stderr
-> ReaderT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdout stderr -> m ()
forall stdin stdout stderr.
HasCallStack =>
ProcessConfig stdin stdout stderr -> m ()
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr -> m ()
runProcess_
  {-# INLINEABLE runProcess_ #-}
  readProcess_ :: forall stdin stdoutIgnored stderrIgnored.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> ReaderT env m (ByteString, ByteString)
readProcess_ = m (ByteString, ByteString)
-> ReaderT env m (ByteString, ByteString)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (ByteString, ByteString)
 -> ReaderT env m (ByteString, ByteString))
-> (ProcessConfig stdin stdoutIgnored stderrIgnored
    -> m (ByteString, ByteString))
-> ProcessConfig stdin stdoutIgnored stderrIgnored
-> ReaderT env m (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ByteString, ByteString)
forall stdin stdoutIgnored stderrIgnored.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ByteString, ByteString)
forall (m :: * -> *) stdin stdoutIgnored stderrIgnored.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderrIgnored
-> m (ByteString, ByteString)
readProcess_
  {-# INLINEABLE readProcess_ #-}
  readProcessStdout_ :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m ByteString
readProcessStdout_ = m ByteString -> ReaderT env m ByteString
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ByteString -> ReaderT env m ByteString)
-> (ProcessConfig stdin stdoutIgnored stderr -> m ByteString)
-> ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdoutIgnored stderr -> m ByteString
forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
forall (m :: * -> *) stdin stdoutIgnored stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
readProcessStdout_
  {-# INLINEABLE readProcessStdout_ #-}
  readProcessStderr_ :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m ByteString
readProcessStderr_ = m ByteString -> ReaderT env m ByteString
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ByteString -> ReaderT env m ByteString)
-> (ProcessConfig stdin stdout stderrIgnored -> m ByteString)
-> ProcessConfig stdin stdout stderrIgnored
-> ReaderT env m ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdout stderrIgnored -> m ByteString
forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
forall (m :: * -> *) stdin stdoutIgnored stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
readProcessStderr_
  {-# INLINEABLE readProcessStderr_ #-}
  readProcessInterleaved_ :: forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr
-> ReaderT env m ByteString
readProcessInterleaved_ = m ByteString -> ReaderT env m ByteString
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ByteString -> ReaderT env m ByteString)
-> (ProcessConfig stdin stdoutIgnored stderrIgnored
    -> m ByteString)
-> ProcessConfig stdin stdoutIgnored stderrIgnored
-> ReaderT env m ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProcessConfig stdin stdoutIgnored stderrIgnored -> m ByteString
forall stdin stdoutIgnored stderr.
HasCallStack =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
forall (m :: * -> *) stdin stdoutIgnored stderr.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdoutIgnored stderr -> m ByteString
readProcessInterleaved_
  {-# INLINEABLE readProcessInterleaved_ #-}
  withProcessWait_ :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> ReaderT env m a)
-> ReaderT env m a
withProcessWait_ ProcessConfig stdin stdout stderr
pc Process stdin stdout stderr -> ReaderT env m a
f =
    ReaderT env m env
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask ReaderT env m env -> (env -> ReaderT env m a) -> ReaderT env m a
forall a b.
ReaderT env m a -> (a -> ReaderT env m b) -> ReaderT env m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \env
e -> m a -> ReaderT env m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT env m a) -> m a -> ReaderT env m a
forall a b. (a -> b) -> a -> b
$ ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall (m :: * -> *) stdin stdout stderr a.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
withProcessWait_ ProcessConfig stdin stdout stderr
pc (env -> ReaderT env m a -> m a
forall e (m :: * -> *) a. e -> ReaderT e m a -> m a
usingReaderT env
e (ReaderT env m a -> m a)
-> (Process stdin stdout stderr -> ReaderT env m a)
-> Process stdin stdout stderr
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> ReaderT env m a
f)
  {-# INLINEABLE withProcessWait_ #-}
  withProcessTerm_ :: forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> ReaderT env m a)
-> ReaderT env m a
withProcessTerm_ ProcessConfig stdin stdout stderr
pc Process stdin stdout stderr -> ReaderT env m a
f =
    ReaderT env m env
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask ReaderT env m env -> (env -> ReaderT env m a) -> ReaderT env m a
forall a b.
ReaderT env m a -> (a -> ReaderT env m b) -> ReaderT env m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \env
e -> m a -> ReaderT env m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT env m a) -> m a -> ReaderT env m a
forall a b. (a -> b) -> a -> b
$ ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall stdin stdout stderr a.
HasCallStack =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
forall (m :: * -> *) stdin stdout stderr a.
(MonadTypedProcess m, HasCallStack) =>
ProcessConfig stdin stdout stderr
-> (Process stdin stdout stderr -> m a) -> m a
withProcessTerm_ ProcessConfig stdin stdout stderr
pc (env -> ReaderT env m a -> m a
forall e (m :: * -> *) a. e -> ReaderT e m a -> m a
usingReaderT env
e (ReaderT env m a -> m a)
-> (Process stdin stdout stderr -> ReaderT env m a)
-> Process stdin stdout stderr
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> ReaderT env m a
f)
  {-# INLINEABLE withProcessTerm_ #-}
  waitExitCode :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> ReaderT env m ExitCode
waitExitCode = m ExitCode -> ReaderT env m ExitCode
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m ExitCode -> ReaderT env m ExitCode)
-> (Process stdin stdout stderr -> m ExitCode)
-> Process stdin stdout stderr
-> ReaderT env m ExitCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> m ExitCode
forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> m ExitCode
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
Process stdin stdout stderr -> m ExitCode
waitExitCode
  {-# INLINEABLE waitExitCode #-}
  getExitCode :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> ReaderT env m (Maybe ExitCode)
getExitCode = m (Maybe ExitCode) -> ReaderT env m (Maybe ExitCode)
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe ExitCode) -> ReaderT env m (Maybe ExitCode))
-> (Process stdin stdout stderr -> m (Maybe ExitCode))
-> Process stdin stdout stderr
-> ReaderT env m (Maybe ExitCode)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> m (Maybe ExitCode)
forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> m (Maybe ExitCode)
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
Process stdin stdout stderr -> m (Maybe ExitCode)
getExitCode
  {-# INLINEABLE getExitCode #-}
  checkExitCode :: forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> ReaderT env m ()
checkExitCode = m () -> ReaderT env m ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT env m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT env m ())
-> (Process stdin stdout stderr -> m ())
-> Process stdin stdout stderr
-> ReaderT env m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Process stdin stdout stderr -> m ()
forall stdin stdout stderr.
HasCallStack =>
Process stdin stdout stderr -> m ()
forall (m :: * -> *) stdin stdout stderr.
(MonadTypedProcess m, HasCallStack) =>
Process stdin stdout stderr -> m ()
checkExitCode
  {-# INLINEABLE checkExitCode #-}

usingReaderT :: e -> ReaderT e m a -> m a
usingReaderT :: forall e (m :: * -> *) a. e -> ReaderT e m a -> m a
usingReaderT = (ReaderT e m a -> e -> m a) -> e -> ReaderT e m a -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT e m a -> e -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT
{-# INLINEABLE usingReaderT #-}