Portability | portable |
---|---|

Maintainer | jmillikin@gmail.com |

Character-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 char-by-char basis, the chunk-oriented versions will be much faster.

This module is intended to be imported qualified:

import qualified Data.Enumerator.Text as ET

Since: 0.2

- enumHandle :: MonadIO m => Handle -> Enumerator Text m b
- enumFile :: FilePath -> Enumerator Text IO b
- iterHandle :: MonadIO m => Handle -> Iteratee Text m ()
- fold :: Monad m => (b -> Char -> b) -> b -> Iteratee Text m b
- foldM :: Monad m => (b -> Char -> m b) -> b -> Iteratee Text m b
- map :: Monad m => (Char -> Char) -> Enumeratee Text Text m b
- mapM :: Monad m => (Char -> m Char) -> Enumeratee Text Text m b
- concatMap :: Monad m => (Char -> Text) -> Enumeratee Text Text m b
- concatMapM :: Monad m => (Char -> m Text) -> Enumeratee Text Text m b
- mapAccum :: Monad m => (s -> Char -> (s, Char)) -> s -> Enumeratee Text Text m b
- mapAccumM :: Monad m => (s -> Char -> m (s, Char)) -> s -> Enumeratee Text Text m b
- iterate :: Monad m => (Char -> Char) -> Char -> Enumerator Text m b
- iterateM :: Monad m => (Char -> m Char) -> Char -> Enumerator Text m b
- repeat :: Monad m => Char -> Enumerator Text m b
- repeatM :: Monad m => m Char -> Enumerator Text m b
- replicate :: Monad m => Integer -> Char -> Enumerator Text m b
- replicateM :: Monad m => Integer -> m Char -> Enumerator Text m b
- generateM :: Monad m => m (Maybe Char) -> Enumerator Text m b
- unfold :: Monad m => (s -> Maybe (Char, s)) -> s -> Enumerator Text m b
- unfoldM :: Monad m => (s -> m (Maybe (Char, s))) -> s -> Enumerator Text m b
- filter :: Monad m => (Char -> Bool) -> Enumeratee Text Text m b
- filterM :: Monad m => (Char -> m Bool) -> Enumeratee Text Text m b
- take :: Monad m => Integer -> Iteratee Text m Text
- takeWhile :: Monad m => (Char -> Bool) -> Iteratee Text m Text
- consume :: Monad m => Iteratee Text m Text
- head :: Monad m => Iteratee Text m (Maybe Char)
- drop :: Monad m => Integer -> Iteratee Text m ()
- dropWhile :: Monad m => (Char -> Bool) -> Iteratee Text m ()
- require :: Monad m => Integer -> Iteratee Text m ()
- isolate :: Monad m => Integer -> Enumeratee Text Text m b
- splitWhen :: Monad m => (Char -> Bool) -> Enumeratee Text Text m b
- lines :: Monad m => Enumeratee Text Text m b
- data Codec
- encode :: Monad m => Codec -> Enumeratee Text ByteString m b
- decode :: Monad m => Codec -> Enumeratee ByteString Text m b
- utf8 :: Codec
- utf16_le :: Codec
- utf16_be :: Codec
- utf32_le :: Codec
- utf32_be :: Codec
- ascii :: Codec
- iso8859_1 :: Codec

# IO

enumHandle :: MonadIO m => Handle -> Enumerator Text m bSource

Read lines of text 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.

The handle should be opened with an appropriate text encoding, and
in `ReadMode`

or `ReadWriteMode`

.

Since: 0.2

enumFile :: FilePath -> Enumerator Text IO bSource

Opens a file path in text mode, and passes the handle to `enumHandle`

.
The file will be closed when the `Iteratee`

finishes.

Since: 0.2

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

Read text from a stream and write it to a handle. If an exception
occurs during file IO, enumeration will stop and `Error`

will be
returned.

The handle should be opened with an appropriate text encoding, and
in `WriteMode`

or `ReadWriteMode`

.

Since: 0.2

# List analogues

## Folds

fold :: Monad m => (b -> Char -> b) -> b -> Iteratee Text m bSource

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

Since: 0.4.8

foldM :: Monad m => (b -> Char -> m b) -> b -> Iteratee Text m bSource

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

Since: 0.4.8

## Maps

map :: Monad m => (Char -> Char) -> Enumeratee Text Text m bSource

applies `map`

f*f* to each input character and feeds the
resulting outputs to the inner iteratee.

Since: 0.4.8

mapM :: Monad m => (Char -> m Char) -> Enumeratee Text Text m bSource

applies `mapM`

f*f* to each input character and feeds the
resulting outputs to the inner iteratee.

Since: 0.4.8

concatMap :: Monad m => (Char -> Text) -> Enumeratee Text Text m bSource

applies `concatMap`

f*f* to each input character and feeds the
resulting outputs to the inner iteratee.

Since: 0.4.8

concatMapM :: Monad m => (Char -> m Text) -> Enumeratee Text Text m bSource

applies `concatMapM`

f*f* to each input character and feeds the
resulting outputs to the inner iteratee.

Since: 0.4.8

## Accumulating maps

mapAccum :: Monad m => (s -> Char -> (s, Char)) -> s -> Enumeratee Text Text m bSource

Similar to `map`

, but with a stateful step function.

Since: 0.4.9

mapAccumM :: Monad m => (s -> Char -> m (s, Char)) -> s -> Enumeratee Text Text m bSource

Similar to `mapM`

, but with a stateful step function.

Since: 0.4.9

## Infinite streams

iterateM :: Monad m => (Char -> m Char) -> Char -> Enumerator Text m bSource

Similar to `iterate`

, except the iteration function is monadic.

Since: 0.4.8

repeatM :: Monad m => m Char -> Enumerator Text m bSource

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

Since: 0.4.8

## Bounded streams

replicate :: Monad m => Integer -> Char -> Enumerator Text m bSource

enumerates a stream containing `replicate`

n x*n* copies of *x*.

Since: 0.4.8

replicateM :: Monad m => Integer -> m Char -> Enumerator Text m bSource

enumerates a stream of `replicateM`

n m_x*n* characters, with each
character computed by *m_x*.

Since: 0.4.8

unfold :: Monad m => (s -> Maybe (Char, s)) -> s -> Enumerator Text m bSource

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

Similar to `iterate`

.

Since: 0.4.8

unfoldM :: Monad m => (s -> m (Maybe (Char, s))) -> s -> Enumerator Text m bSource

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

Similar to `iterateM`

.

Since: 0.4.8

## Filters

filter :: Monad m => (Char -> Bool) -> Enumeratee Text Text 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 => (Char -> m Bool) -> Enumeratee Text Text m bSource

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

.

Since: 0.4.8

## Consumers

take :: Monad m => Integer -> Iteratee Text m TextSource

extracts the next `take`

n*n* characters from the stream, as a lazy
Text.

Since: 0.4.5

takeWhile :: Monad m => (Char -> Bool) -> Iteratee Text m TextSource

extracts input from the stream until the first character
which does not match the predicate.
`takeWhile`

p

Since: 0.4.5

## Unsorted

head :: Monad m => Iteratee Text m (Maybe Char)Source

Get the next character from the stream, or `Nothing`

if the stream has
ended.

Since: 0.4.5

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

ignores `drop`

n*n* characters of input from the stream.

Since: 0.4.5

dropWhile :: Monad m => (Char -> Bool) -> Iteratee Text m ()Source

ignores input from the stream until the first character
which does not match the predicate.
`dropWhile`

p

Since: 0.4.5

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

buffers input until at least `require`

n*n* characters are available,
or throws an error if the stream ends early.

Since: 0.4.5

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

reads at most `isolate`

n*n* characters from the stream, and passes
them to its iteratee. If the iteratee finishes early, characters continue
to be consumed from the outer stream until *n* have been consumed.

Since: 0.4.5

splitWhen :: Monad m => (Char -> Bool) -> Enumeratee Text Text m bSource

Split on characters satisfying a given predicate.

Since: 0.4.8

# Text codecs

encode :: Monad m => Codec -> Enumeratee Text ByteString m bSource

Convert text into bytes, using the provided codec. If the codec is not capable of representing an input character, an error will be thrown.

Since: 0.2

decode :: Monad m => Codec -> Enumeratee ByteString Text m bSource

Convert bytes into text, using the provided codec. If the codec is not capable of decoding an input byte sequence, an error will be thrown.

Since: 0.2