Streaming interface to system processes.

LTS Haskell 6.30:
Stackage Nightly 2016-05-25:
Latest on Hackage:
BSD3 licensed by Daniel Díaz Carrete
Maintained by

Module documentation for


A library for interacting with system processes in a streaming fashion.

The basic goals:

  • Concurrent, streaming access to stdin, stdout and stderr...

  • ...all the while preventing deadlocks caused by mishandling of the streams.

  • Easy integration with consumers from pipes, parsers from pipes-parse and folds from foldl.

  • Facilitate the use of sum types to signal failures, when desired.

  • No fussing around with process handles: wait for the process by waiting for the IO action, terminate the process by killing the thread executing the IO action.

A relevant thread in the Haskell Pipes Google Group.

Possible alternatives in Hackage

  • turtle (pipes-based, shell programming)

  • pipes-cliff (pipes-based)

  • pipes-shell (pipes-based)

  • shelly (shell programming)

  • shell-conduit (coundit-based, shell programming)

  • Data.Conduit.Process from conduit-extra (conduit-based)

  • System.IO.Streams.Process from io-streams (iostreams-based)

  • process-extras

- Added executeInteractive and executeInteractiveFallibly
- Added envAt lens for tweaking the environment.
- All Siphon functionality has been moved to new package pipes-transduce.
- Siphons correspond to the "Fold1" datatype in pipes-transduce.
- "Piping" is now the "Streams" Applicative.
- Exit code handling has been merged into the "Streams" Applicative.
- Removed pipeline functions.
- Removed some lenses, added others.
- Asynchronous cancellation now works on Windows (issue #8)
- contraproduce, contraencoded, Splitter, splitIntoLines, nest
- contramapFoldable, contramapEnumerable.
- Bumped conceit dependency to make it work with GHC 7.10.
- Changed signature of toLines to make it more consistent with that of encoded
(breaking change).
- Stricter signatures of some fromConsumer... functions (breaking change).
- Pump constructor now hidden (breaking change).
- Added new fromConsumer... functions for Consumers that don't stop.
- Functions to throw exceptions for encoding errors (unwantedX, leftoverX,
_leftoverX). Also a new LeftoverException.
- Re-exported more decoding functions from pipes-text.
- New module System.Process.Streaming.Extended with some experimental
- New module System.Process.Streaming.Internal.
- fromLazyBytes, intoLazyBytes, intoLazyText.
- re-export decodeUtf8 from pipes-text.
- IsString instance for Pump.
- Some changes in the haddocks.
- Bumped some dependencies.

- Added fromFoldable, fromEnumerable, prefixLines

- Brought back the tutorial.
- Added newtype SiphonOp with Contravariant, Divisible and Decidable instances.
- PipingPolicy now deprecated, use Piping instead.
- LinePolicy now deprecated, use Lines instead.
- linePolicy now deprecated, use toLines instead.
- Siphon constructors for folds from the "foldl" package.

- Allow text-1.2.

- Removed ugly (Show e,Typeable) constraints on the error type from many

- No changes to the external API, but some internal code has moved to a
separate package, "conceit".

- Now compatible with earlier versions of transformers.
- Simplified LinePolicy.
- Simplified pipeline functions and datatypes.

- A bug slipped by :(

- Changes in the internals to reduce the number of spawned threads.

- Now the constructors for "PipingPolicy" take "Siphons" directly, instead of
continuation functions.
- Removed "separated" and "combined" functions, added new "PipingPolicy"
constructors in their place.
- Removed "LeftoverPolicy", its function is now performed by Siphons.
- Removed "surely", "safely", "monoidally" functions with confusing signatures.
- Removed all occurrences of unbounded buffers in the code.
- Implemented support for branching pipelines of processes.

- Renamed many functions (the number-based naming schema is gone).
- Decisions about how to consume the standard streams were moved to the new
"PipingPolicy" type.
- "ForkProd" is now "Siphon".
- "execute" can now throw IOExceptions (but see "safeExecute").
- Some complicated types were hidden behind data declarations.
- Functor, Bifunctor and Profunctor instances for some types.

- Added some examples.
- Re-exported System.Process from System.Process.Streaming.
comments powered byDisqus