enumerator-0.4.13.1: Reliable, high-performance processing with left-fold enumerators

Portabilityportable
Maintainerjmillikin@gmail.com

Data.Enumerator.Binary

Contents

Description

Byte-oriented alternatives to Data.Enumerator.List. Note that the enumeratees in this module must unpack their inputs to work properly. If you do not need to handle leftover input on a byte-by-byte basis, the chunk-oriented versions will be much faster.

This module is intended to be imported qualified: 

 import qualified Data.Enumerator.Binary as EB

Since: 0.4.5

Synopsis

IO

enumHandleSource

Arguments

:: MonadIO m 
=> Integer

Buffer size

-> Handle 
-> Enumerator ByteString m b 

Read bytes (in chunks of the given buffer size) from the handle, and stream them to an Iteratee. If an exception occurs during file IO, enumeration will stop and Error will be returned. Exceptions from the iteratee are not caught.

This enumerator blocks until at least one byte is available from the handle, and might read less than the maximum buffer size in some cases.

The handle should be opened with no encoding, and in ReadMode or ReadWriteMode.

Since: 0.4.5

enumHandleRangeSource

Arguments

:: MonadIO m 
=> Integer

Buffer size

-> Maybe Integer

Offset

-> Maybe Integer

Maximum count

-> Handle 
-> Enumerator ByteString m b 

Read bytes (in chunks of the given buffer size) from the handle, and stream them to an Iteratee. If an exception occurs during file IO, enumeration will stop and Error will be returned. Exceptions from the iteratee are not caught.

This enumerator blocks until at least one byte is available from the handle, and might read less than the maximum buffer size in some cases.

The handle should be opened with no encoding, and in ReadMode or ReadWriteMode.

If an offset is specified, the handle will be seeked to that offset before reading. If the handle cannot be seeked, an error will be thrown.

If a maximum count is specified, the number of bytes read will not exceed that count.

Since: 0.4.8

enumFile :: FilePath -> Enumerator ByteString IO bSource

Opens a file path in binary mode, and passes the handle to enumHandle. The file will be closed when enumeration finishes.

Since: 0.4.5

enumFileRangeSource

Arguments

:: FilePath 
-> Maybe Integer

Offset

-> Maybe Integer

Maximum count

-> Enumerator ByteString IO b 

Opens a file path in binary mode, and passes the handle to enumHandleRange. The file will be closed when enumeration finishes.

Since: 0.4.8

iterHandle :: MonadIO m => Handle -> Iteratee ByteString m ()Source

Read bytes from a stream and write them to a handle. If an exception occurs during file IO, enumeration will stop and Error will be returned.

The handle should be opened with no encoding, and in WriteMode or ReadWriteMode.

Since: 0.4.5

List analogues

Folds

fold :: Monad m => (b -> Word8 -> b) -> b -> Iteratee ByteString m bSource

Consume the entire input stream with a strict left fold, one byte at a time.

Since: 0.4.8

foldM :: Monad m => (b -> Word8 -> m b) -> b -> Iteratee ByteString m bSource

Consume the entire input stream with a strict monadic left fold, one byte at a time.

Since: 0.4.8

Maps

map :: Monad m => (Word8 -> Word8) -> Enumeratee ByteString ByteString m bSource

map f applies f to each input byte and feeds the resulting outputs to the inner iteratee.

Since: 0.4.8

mapM :: Monad m => (Word8 -> m Word8) -> Enumeratee ByteString ByteString m bSource

mapM f applies f to each input byte and feeds the resulting outputs to the inner iteratee.

Since: 0.4.8

mapM_ :: Monad m => (Word8 -> m ()) -> Iteratee ByteString m ()Source

mapM_ f applies f to each input byte, and discards the results.

Since: 0.4.11

concatMap :: Monad m => (Word8 -> ByteString) -> Enumeratee ByteString ByteString m bSource

concatMap f applies f to each input byte and feeds the resulting outputs to the inner iteratee.

Since: 0.4.8

concatMapM :: Monad m => (Word8 -> m ByteString) -> Enumeratee ByteString ByteString m bSource

concatMapM f applies f to each input byte and feeds the resulting outputs to the inner iteratee.

Since: 0.4.8

Accumulating maps

mapAccum :: Monad m => (s -> Word8 -> (s, Word8)) -> s -> Enumeratee ByteString ByteString m bSource

Similar to map, but with a stateful step function.

Since: 0.4.9

mapAccumM :: Monad m => (s -> Word8 -> m (s, Word8)) -> s -> Enumeratee ByteString ByteString m bSource

Similar to mapM, but with a stateful step function.

Since: 0.4.9

concatMapAccum :: Monad m => (s -> Word8 -> (s, ByteString)) -> s -> Enumeratee ByteString ByteString m bSource

Similar to concatMap, but with a stateful step function.

Since: 0.4.11

concatMapAccumM :: Monad m => (s -> Word8 -> m (s, ByteString)) -> s -> Enumeratee ByteString ByteString m bSource

Similar to concatMapM, but with a stateful step function.

Since: 0.4.11

Infinite streams

iterate :: Monad m => (Word8 -> Word8) -> Word8 -> Enumerator ByteString m bSource

iterate f x enumerates an infinite stream of repeated applications of f to x.

Analogous to iterate.

Since: 0.4.8

iterateM :: Monad m => (Word8 -> m Word8) -> Word8 -> Enumerator ByteString m bSource

Similar to iterate, except the iteration function is monadic.

Since: 0.4.8

repeat :: Monad m => Word8 -> Enumerator ByteString m bSource

Enumerates an infinite stream of a single byte.

Analogous to repeat.

Since: 0.4.8

repeatM :: Monad m => m Word8 -> Enumerator ByteString m bSource

Enumerates an infinite stream of byte. Each byte is computed by the underlying monad.

Since: 0.4.8

Bounded streams

replicate :: Monad m => Integer -> Word8 -> Enumerator ByteString m bSource

replicate n x enumerates a stream containing n copies of x.

Since: 0.4.8

replicateM :: Monad m => Integer -> m Word8 -> Enumerator ByteString m bSource

replicateM n m_x enumerates a stream of n bytes, with each byte computed by m_x.

Since: 0.4.8

generateM :: Monad m => m (Maybe Word8) -> Enumerator ByteString m bSource

Like repeatM, except the computation may terminate the stream by returning Nothing.

Since: 0.4.8

unfold :: Monad m => (s -> Maybe (Word8, s)) -> s -> Enumerator ByteString m bSource

Enumerates a stream of bytes by repeatedly applying a function to some state.

Similar to iterate.

Since: 0.4.8

unfoldM :: Monad m => (s -> m (Maybe (Word8, s))) -> s -> Enumerator ByteString m bSource

Enumerates a stream of bytes by repeatedly applying a computation to some state.

Similar to iterateM.

Since: 0.4.8

Filters

filter :: Monad m => (Word8 -> Bool) -> Enumeratee ByteString ByteString m bSource

Applies a predicate to the stream. The inner iteratee only receives characters for which the predicate is True.

Since: 0.4.8

filterM :: Monad m => (Word8 -> m Bool) -> Enumeratee ByteString ByteString m bSource

Applies a monadic predicate to the stream. The inner iteratee only receives bytes for which the predicate returns True.

Since: 0.4.8

Consumers

take :: Monad m => Integer -> Iteratee ByteString m ByteStringSource

take n extracts the next n bytes from the stream, as a lazy ByteString.

Since: 0.4.5

takeWhile :: Monad m => (Word8 -> Bool) -> Iteratee ByteString m ByteStringSource

takeWhile p extracts input from the stream until the first byte which does not match the predicate.

Since: 0.4.5

consume :: Monad m => Iteratee ByteString m ByteStringSource

consume = takeWhile (const True)

Since: 0.4.5

Unsorted

head :: Monad m => Iteratee ByteString m (Maybe Word8)Source

Get the next byte from the stream, or Nothing if the stream has ended.

Since: 0.4.5

drop :: Monad m => Integer -> Iteratee ByteString m ()Source

drop n ignores n bytes of input from the stream.

Since: 0.4.5

dropWhile :: Monad m => (Word8 -> Bool) -> Iteratee ByteString m ()Source

dropWhile p ignores input from the stream until the first byte which does not match the predicate.

Since: 0.4.5

require :: Monad m => Integer -> Iteratee ByteString m ()Source

require n buffers input until at least n bytes are available, or throws an error if the stream ends early.

Since: 0.4.5

isolate :: Monad m => Integer -> Enumeratee ByteString ByteString m bSource

isolate n reads at most n bytes from the stream, and passes them to its iteratee. If the iteratee finishes early, bytes continue to be consumed from the outer stream until n have been consumed.

Since: 0.4.5

splitWhen :: Monad m => (Word8 -> Bool) -> Enumeratee ByteString ByteString m bSource

Split on bytes satisfying a given predicate.

Since: 0.4.8