conduit-0.4.2: Streaming data processing library.

Safe HaskellSafe-Infered

Data.Conduit.List

Contents

Description

Higher-level functions to interact with the elements of a stream. Most of these are based on list functions.

Note that these functions all deal with individual elements of a stream as a sort of "black box", where there is no introspection of the contained elements. Values such as ByteString and Text will likely need to be treated specially to deal with their contents properly (Word8 and Char, respectively). See the Data.Conduit.Binary and Data.Conduit.Text modules.

Synopsis

Sources

sourceList :: Monad m => [a] -> Source m a

Convert a list into a source.

Since 0.3.0

sourceNull :: Monad m => Source m a

A source that returns nothing. Note that this is just a type-restricted synonym for mempty.

Since 0.3.0

unfold :: Monad m => (b -> Maybe (a, b)) -> b -> Source m a

Generate a source from a seed value.

Since 0.4.2

enumFromTo :: (Enum a, Eq a, Monad m) => a -> a -> Source m a

Enumerate from a value to a final value, inclusive, via succ.

This is generally more efficient than using Prelude's enumFromTo and combining with sourceList since this avoids any intermediate data structures.

Since 0.4.2

Sinks

Pure

fold :: Monad m => (b -> a -> b) -> b -> Sink a m b

A strict left fold.

Since 0.3.0

take :: Monad m => Int -> Sink a m [a]

Take some values from the stream and return as a list. If you want to instead create a conduit that pipes data to another sink, see isolate. This function is semantically equivalent to:

 take i = isolate i =$ consume

Since 0.3.0

drop :: Monad m => Int -> Sink a m ()

Ignore a certain number of values in the stream. This function is semantically equivalent to:

 drop i = take i >> return ()

However, drop is more efficient as it does not need to hold values in memory.

Since 0.3.0

head :: Monad m => Sink a m (Maybe a)

Take a single value from the stream, if available.

Since 0.3.0

zip :: Monad m => Source m a -> Source m b -> Source m (a, b)

Combines two sources. The new source will stop producing once either source has been exhausted.

Since 0.3.0

zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r')

Combines two sinks. The new sink will complete when both input sinks have completed.

If both sinks finish on the same chunk, and both report leftover input, arbitrarily yield the left sink's leftover input.

Since 0.4.1

peek :: Monad m => Sink a m (Maybe a)

Look at the next value in the stream, if available. This function will not change the state of the stream.

Since 0.3.0

consume :: Monad m => Sink a m [a]

Consume all values from the stream and return as a list. Note that this will pull all values into memory. For a lazy variant, see Data.Conduit.Lazy.

Since 0.3.0

sinkNull :: Monad m => Sink a m ()

Ignore the remainder of values in the source. Particularly useful when combined with isolate.

Since 0.3.0

Monadic

foldM :: Monad m => (b -> a -> m b) -> b -> Sink a m b

A monadic strict left fold.

Since 0.3.0

mapM_ :: Monad m => (a -> m ()) -> Sink a m ()

Apply the action to all values in the stream.

Since 0.3.0

Pure

map :: Monad m => (a -> b) -> Conduit a m b

Apply a transformation to all values in a stream.

Since 0.3.0

concatMap :: Monad m => (a -> [b]) -> Conduit a m b

Apply a transformation to all values in a stream, concatenating the output values.

Since 0.3.0

concatMapAccum :: Monad m => (a -> accum -> (accum, [b])) -> accum -> Conduit a m b

concatMap with an accumulator.

Since 0.3.0

groupBy :: Monad m => (a -> a -> Bool) -> Conduit a m [a]

Grouping input according to an equality function.

Since 0.3.0

isolate :: Monad m => Int -> Conduit a m a

Ensure that the inner sink consumes no more than the given number of values. Note this this does not ensure that the sink consumes all of those values. To get the latter behavior, combine with sinkNull, e.g.:

 src $$ do
     x <- isolate count =$ do
         x <- someSink
         sinkNull
         return x
     someOtherSink
     ...

Since 0.3.0

filter :: Monad m => (a -> Bool) -> Conduit a m a

Keep only values in the stream passing a given predicate.

Since 0.3.0

Monadic

mapM :: Monad m => (a -> m b) -> Conduit a m b

Apply a monadic transformation to all values in a stream.

If you do not need the transformed values, and instead just want the monadic side-effects of running the action, see mapM_.

Since 0.3.0

concatMapM :: Monad m => (a -> m [b]) -> Conduit a m b

Apply a monadic transformation to all values in a stream, concatenating the output values.

Since 0.3.0

concatMapAccumM :: Monad m => (a -> accum -> m (accum, [b])) -> accum -> Conduit a m b

concatMapM with an accumulator.

Since 0.3.0