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

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

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

(drop n) drops the first n bytes

Take bytes until they fail the predicate

Drop 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.

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 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 upcoming 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 upcoming pipes-text library.

Intersperse a Word8 in between the bytes of the byte stream

Improper isomorphism between a Producer of ByteStrings and 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

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

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

Improper isomorphism 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 upcoming pipes-text library.

Improper isomorphism between a bytestream and its 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 upcoming pipes-text library.