Abstraction of a process with input and output.

This effect is intended to be used in a scoped manner:

import Polysemy.Resume
import Polysemy.Conc
import Polysemy.Process
import qualified System.Process.Typed as System

prog :: Member (Scoped resource (Process Text Text !! err)) r => Sem r Text
prog =
 resumeAs "failed" do
   withProcess do
     send "input"
     recv

main :: IO ()
main = do
  out <- runConc $ interpretProcessNative (System.proc "cat" []) prog
  putStrLn out

Obtain a chunk of output.

Send data to stdin.

Create a scoped resource for Process.

Controls the behaviour of Process interpreters.

Indicate whether to kill a process after exiting the scope in which it was used, if it hasn't terminated.

This effect is used by the effect Process to accumulate and decode chunks of ByteStrings, for example using a parser. The interpreter may be stateful or stateless, since the constructor Chunk is expected to be called with both the accumulated unprocessed output as well as the new chunk.

Kind tag for selecting the ProcessOutput handler for stdout/stderr.

An incremental parse result, potentially a partial result containing a continuation function.

This effect is used by the effect Process to encode values for process input. example using a parser.

Low-level interface for a process, operating on raw chunks of bytes. Interface is modeled after System.Process.

Create a scoped resource for SystemProcess.

A pseudo terminal, to be scoped with withPty.

Bracket an action with the creation and destruction of a pseudo terminal.

Interpret Process as a native SystemProcess, producing unaccumulated chunks of ByteString. Silently discards stderr.

Interpret Process as a native SystemProcess, producing lines of ByteString. Silently discards stderr.

Interpret Process as a native SystemProcess, producing unaccumulated chunks of Text. Silently discards stderr.

Interpret Process as a native SystemProcess, producing lines of Text. Silently discards stderr.

Interpret Process with a system process resource whose file descriptors are connected to three TBMQueues, deferring decoding of stdout and stderr to the interpreters of two ProcessOutput effects.

Interpret Process with a system process resource whose stdin/stdout are connected to two TBMQueues, producing ByteStrings. Silently discards stderr.

Interpret Process with a system process resource whose stdin/stdout are connected to two TBMQueues, producing chunks of lines of ByteStrings. Silently discards stderr.

Interpret Process with a system process resource whose stdin/stdout are connected to two TBMQueues, producing Texts. Silently discards stderr.

Interpret Process with a system process resource whose stdin/stdout are connected to two TBMQueues, producing chunks of lines of Texts. Silently discards stderr.

Reinterpret Input and Output as Process.

Interpret 'Input ByteString' by polling a Handle and stopping with ProcessError when it fails.

Interpret 'Input ByteString' by polling a Handle and stopping with ProcessError when it fails. This variant deactivates buffering for the Handle.

Interpret 'Output ByteString' by writing to a Handle and stopping with ProcessError when it fails.

Interpret 'Output ByteString' by writing to a Handle and stopping with ProcessError when it fails. This variant deactivates buffering for the Handle.

Interpret Process in terms of Input and Output. Since the i and o parameters correspond to the abstraction of stdio fds of an external system process, i is written by Output and o is read from Input. This is useful to abstract the current process's stdio as an external process, with input and output swapped.

Interpret Process in terms of two Handles. This is useful to abstract the current process's stdio as an external process, with input and output swapped. The first Handle argument corresponds to the o parameter, the second one to i, despite the first one usually being the current process's stdin. This is due to Process abstracting an external process to whose stdin would be written, while the current one's is read.

Interpret Process using the current process's stdin and stdout. This mirrors the usual abstraction of an external process, to whose stdin would be written, while the current one's is read.

Interpret ProcessOutput by discarding any output.

Interpret ProcessOutput by immediately emitting raw ByteStrings without accumulation.

Transformer for ProcessOutput that lifts results into Left, creating 'ProcessOutput p (Either a b)' from 'ProcessOutput p a'.

Transformer for ProcessOutput that lifts results into Right, creating 'ProcessOutput p (Either a b)' from 'ProcessOutput p b'.

Interpret ProcessOutput by emitting individual ByteString lines of output.

Interpret ProcessOutput by immediately emitting Text without accumulation.

Interpret ProcessOutput by emitting individual Text lines of output.

Whenever a chunk of output arrives, call the supplied incremental parser whose result must be converted to ProcessOutputParseResult. If a partial parse result is produced, it is stored in the state and resumed when the next chunk is available. If parsing an a succeeds, the parser recurses until it fails.

Interpret ProcessInput by passing ByteString through.

Interpret ProcessInput by UTF-8-encoding Text.

Interpret SystemProcess with a concrete Process with connected pipes.

Interpret SystemProcess as a single global Process that's started immediately.

Interpret SystemProcess as a scoped Process that's started wherever withSystemProcess is called and terminated when the wrapped action finishes.

Interpret SystemProcess with a concrete Process with connected pipes.

Interpret SystemProcess as a single global Process that's started immediately.

Interpret SystemProcess as a scoped Process that's started wherever withSystemProcess is called and terminated when the wrapped action finishes.

Interpret Pty as a Pty.

Find a file in $PATH, verifying that it is executable by this process.