-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Reflex FRP interface for running system processes
--   
--   Run and interact with system processes from within a Reflex FRP
--   application.
--   
--   <a>https://reflex-frp.org</a>
@package reflex-process
@version 0.3.2.1


module Reflex.Process

-- | Create a process feeding it input using an <a>Event</a> and exposing
--   its output <a>Event</a>s representing the process exit code,
--   <tt>stdout</tt>, and <tt>stderr</tt>.
--   
--   The <tt>stdout</tt> and <tt>stderr</tt> <a>Handle</a>s are
--   line-buffered.
--   
--   N.B. The process input is buffered with an unbounded channel! For more
--   control of this, use <a>createProcessBufferingInput</a> directly.
--   
--   N.B.: The <a>std_in</a>, <a>std_out</a>, and <a>std_err</a> parameters
--   of the provided <a>CreateProcess</a> are replaced with new pipes and
--   all output is redirected to those pipes.
createProcess :: (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m), MonadFix m) => CreateProcess -> ProcessConfig t (SendPipe ByteString) -> m (Process t ByteString ByteString)

-- | Create a process feeding it input using an <a>Event</a> and exposing
--   its output with <a>Event</a>s for its exit code, <tt>stdout</tt>, and
--   <tt>stderr</tt>. The input is fed via a buffer represented by a
--   reading action and a writing action.
--   
--   The <tt>stdout</tt> and <tt>stderr</tt> <a>Handle</a>s are
--   line-buffered.
--   
--   For example, you may use <tt>Chan</tt> for an unbounded buffer (like
--   <a>createProcess</a> does) like this:
--   
--   <pre>
--   channel &lt;- liftIO newChan
--   createProcessBufferingInput (readChan channel) (writeChan channel) myConfig
--   </pre>
--   
--   Similarly you could use <tt>TChan</tt>.
--   
--   Bounded buffers may cause the Reflex network to block when you trigger
--   an <a>Event</a> that would cause more data to be sent to a process
--   whose <tt>stdin</tt> is blocked.
--   
--   If an unbounded channel would lead to too much memory usage you will
--   want to consider * speeding up the consuming process. * buffering with
--   the file system or another persistent storage to reduce memory usage.
--   * if your usa case allows, dropping <a>Event</a>s or messages that
--   aren't important.
--   
--   N.B.: The <a>std_in</a>, <a>std_out</a>, and <a>std_err</a> parameters
--   of the provided <a>CreateProcess</a> are replaced with new pipes and
--   all output is redirected to those pipes.
createProcessBufferingInput :: (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m), MonadFix m) => IO (SendPipe ByteString) -> (SendPipe ByteString -> IO ()) -> CreateProcess -> ProcessConfig t (SendPipe ByteString) -> m (Process t ByteString ByteString)

-- | A default <a>ProcessConfig</a> where <tt>stdin</tt> and signals are
--   never sent.
--   
--   You can also use <a>def</a>.
defProcessConfig :: Reflex t => ProcessConfig t i

-- | Runs a process and uses the given input and output handler functions
--   to interact with the process via the standard streams. Used to
--   implement <a>createProcess</a>.
--   
--   N.B.: The <a>std_in</a>, <a>std_out</a>, and <a>std_err</a> parameters
--   of the provided <a>CreateProcess</a> are replaced with new pipes and
--   all output is redirected to those pipes.
unsafeCreateProcessWithHandles :: forall t m i o e. (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m)) => (Handle -> IO (i -> IO ())) -> (Handle -> (o -> IO ()) -> IO (IO ())) -> (Handle -> (e -> IO ()) -> IO (IO ())) -> CreateProcess -> ProcessConfig t i -> m (Process t o e)

-- | The output of a process
data Process t o e
Process :: ProcessHandle -> Event t o -> Event t e -> Event t ExitCode -> Event t Signal -> Process t o e
[_process_handle] :: Process t o e -> ProcessHandle

-- | Fires whenever there's some new stdout output. Depending on the
--   buffering strategy of the implementation, this could be anything from
--   whole lines to individual characters.
[_process_stdout] :: Process t o e -> Event t o

-- | Fires whenever there's some new stderr output. See note on
--   <a>_process_stdout</a>.
[_process_stderr] :: Process t o e -> Event t e

-- | Fires when the process is over and no <tt>stdout</tt> or
--   <tt>stderr</tt> data is left. Once this fires, no other <a>Event</a>s
--   for the process will fire again.
[_process_exit] :: Process t o e -> Event t ExitCode

-- | Fires when a signal has actually been sent to the process (via
--   <a>_processConfig_signal</a>).
[_process_signal] :: Process t o e -> Event t Signal

-- | The inputs to a process
data ProcessConfig t i
ProcessConfig :: Event t i -> Event t Signal -> ProcessConfig t i

-- | <tt>stdin</tt> input to be fed to the process
[_processConfig_stdin] :: ProcessConfig t i -> Event t i

-- | Signals to send to the process
[_processConfig_signal] :: ProcessConfig t i -> Event t Signal
data SendPipe i

-- | A message that's sent to the underlying process. This does NOT include
--   a trailing newline when sending your message.
SendPipe_Message :: i -> SendPipe i

-- | Send an EOF to the underlying process. Once this is sent no further
--   messages will be processed.
SendPipe_EOF :: SendPipe i

-- | Send the last message along with an EOF. Once this is sent no further
--   messages will be processed.
SendPipe_LastMessage :: i -> SendPipe i

-- | <i>Deprecated: Use unsafeCreateProcessWithHandles instead.</i>
createRedirectedProcess :: forall t m i o e. (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m)) => (Handle -> IO (i -> IO ())) -> (Handle -> (o -> IO ()) -> IO (IO ())) -> (Handle -> (e -> IO ()) -> IO (IO ())) -> CreateProcess -> ProcessConfig t i -> m (Process t o e)
instance GHC.Classes.Ord i => GHC.Classes.Ord (Reflex.Process.SendPipe i)
instance GHC.Classes.Eq i => GHC.Classes.Eq (Reflex.Process.SendPipe i)
instance GHC.Show.Show i => GHC.Show.Show (Reflex.Process.SendPipe i)
instance Reflex.Class.Reflex t => Data.Default.Class.Default (Reflex.Process.ProcessConfig t i)