Convert a lazy ByteString into a Producer of strict ByteStrings

Stream bytes from stdin

Convert a Handle into a byte stream using a default chunk size

Convert a handle into a byte stream using a maximum chunk size

hGetSome forwards input immediately as it becomes available, splitting the input into multiple chunks if it exceeds the maximum chunk size.

Convert a handle into a byte stream using a fixed chunk size

Similar to hGet except that it will never block waiting for data to become available.

Convert a handle into a byte stream using a fixed chunk size

hGet waits until exactly the requested number of bytes are available for each chunk.

Like hGet but with an extra parameter specifying an initial handle offset

Like hGetSome, except you can vary the maximum chunk size for each request

Like hGet, except you can vary the chunk size for each request

Stream bytes to stdout

Unlike toHandle, stdout gracefully terminates on a broken output pipe.

Convert a byte stream into a Handle

p >-> toHandle handle = for p (liftIO . hPutStr handle)

Apply a transformation to each Word8 in the stream

Map a function over the byte stream and concatenate the results

(take n) only allows n bytes to pass

Take bytes until they fail the predicate

Only allows Word8s to pass if they satisfy the predicate

Stream all indices whose elements match the given Word8

Stream all indices whose elements satisfy the given predicate

Strict left scan over the bytes

Fold a pure Producer of strict ByteStrings into a lazy ByteString

Fold an effectful Producer of strict ByteStrings into a lazy ByteString

Note: toLazyM is not an idiomatic use of pipes, but I provide it for simple testing purposes. Idiomatic pipes style consumes the chunks immediately as they are generated instead of loading them all into memory.

Fold an effectful Producer of strict ByteStrings into a lazy ByteString alongside the return value

Note: toLazyM' is not an idiomatic use of pipes, but I provide it for simple testing purposes. Idiomatic pipes style consumes the chunks immediately as they are generated instead of loading them all into memory.

Reduce the stream of bytes using a strict left fold

Note: It's more efficient to use folds from Control.Foldl.ByteString in conjunction with Pipes.Prelude.fold when possible

Retrieve the first Word8

Retrieve the last Word8

Determine if the stream is empty

Count the number of bytes

Fold that returns whether Any received Word8s satisfy the predicate

Fold that returns whether All received Word8s satisfy the predicate

Return the maximum Word8 within a byte stream

Return the minimum Word8 within a byte stream

Determine whether any element in the byte stream matches the given Word8

Determine whether all elements in the byte stream do not match the given Word8

Find the first element in the stream that matches the predicate

Index into a byte stream

Find the index of an element that matches the given Word8

Store the first index of an element that satisfies the predicate

Store a tally of how many elements match the given Word8

Consume the first byte from a byte stream

next either fails with a Left if the Producer has no more bytes or succeeds with a Right providing the next byte and the remainder of the Producer.

Draw one Word8 from the underlying Producer, returning Nothing if the Producer is empty

Push back a Word8 onto the underlying Producer

peekByte checks the first Word8 in the stream, but uses unDrawByte to push the Word8 back

peekByte = do
    x <- drawByte
    case x of
        Nothing -> return ()
        Just w8 -> unDrawByte w8
    return x

Check if the underlying Producer has no more bytes

Note that this will skip over empty ByteString chunks, unlike isEndOfInput from pipes-parse.

isEndOfBytes = liftM isNothing peekByte

Improper lens that splits a Producer after the given number of bytes

Improper lens that splits after the longest consecutive group of bytes that satisfy the given predicate

Improper lens that splits after the longest consecutive group of bytes that fail the given predicate

Improper lens that splits at the first occurrence of the pattern.

Improper lens that splits after the first group of matching bytes, as defined by the given equality predicate

Like groupBy, where the equality predicate is (==)

Improper lens that splits a Producer after the first word

Unlike words, this does not drop leading whitespace

Note: This function is purely for demonstration purposes since it assumes a particular encoding. You should prefer the Text equivalent of this function from the pipes-text library.

Improper lens that splits a Producer after the first line

Unlike lines, this does not consume the newline marker, which is stored within the inner Producer

Note: This function is purely for demonstration purposes since it assumes a particular encoding. You should prefer the Text equivalent of this function from the pipes-text library.

(drop n) drops the first n bytes

Drop bytes until they fail the predicate

Intersperse a Word8 in between the bytes of the byte stream

Improper lens from unpacked Word8s to packaged ByteStrings

Improper lens from packed ByteStrings to unpacked Word8s

Group byte stream chunks into chunks of fixed length

Note: This is the only function in this API that concatenates ByteString chunks, which requires allocating new ByteStrings

Split a byte stream into FreeT-delimited byte streams of fixed size

Split a byte stream into groups separated by bytes that satisfy the predicate

Split a byte stream into groups separated by the given byte

Split a byte stream into groups separated by the given ByteString

Isomorphism between a byte stream and groups of identical bytes using the supplied equality predicate

Like groupsBy, where the equality predicate is (==)

Improper lens between a bytestream and its lines

Note: This function is purely for demonstration purposes since it assumes a particular encoding. You should prefer the Text equivalent of this function from the pipes-text library.

Improper lens between lines and a bytestream

Note: This function is purely for demonstration purposes since it assumes a particular encoding. You should prefer the Text equivalent of this function from the pipes-text library.

Convert a bytestream to delimited words

Note: This function is purely for demonstration purposes since it assumes a particular encoding. You should prefer the Text equivalent of this function from the pipes-text library.

Convert delimited words back to a byte stream

Note: This function is purely for demonstration purposes since it assumes a particular encoding. You should prefer the Text equivalent of this function from the pipes-text library.

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

8-bit unsigned integer type

Join a FreeT-delimited stream of Producers into a single Producer by intercalating a Producer in between them

intercalates :: Monad m => Producer a m () -> Joiner a m x

Join a FreeT-delimited stream of Producers into a single Producer

concats :: Monad m => Joiner a m x

A Parser is an action that reads from and writes to a stored Producer