Safe Haskell | Safe-Infered |
---|

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.

- sourceList :: Monad m => [a] -> Source m a
- sourceNull :: Monad m => Source m a
- unfold :: Monad m => (b -> Maybe (a, b)) -> b -> Source m a
- enumFromTo :: (Enum a, Eq a, Monad m) => a -> a -> Source m a
- fold :: Monad m => (b -> a -> b) -> b -> Sink a m b
- take :: Monad m => Int -> Sink a m [a]
- drop :: Monad m => Int -> Sink a m ()
- head :: Monad m => Sink a m (Maybe a)
- zip :: Monad m => Source m a -> Source m b -> Source m (a, b)
- zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r')
- peek :: Monad m => Sink a m (Maybe a)
- consume :: Monad m => Sink a m [a]
- sinkNull :: Monad m => Sink a m ()
- foldM :: Monad m => (b -> a -> m b) -> b -> Sink a m b
- mapM_ :: Monad m => (a -> m ()) -> Sink a m ()
- map :: Monad m => (a -> b) -> Conduit a m b
- concatMap :: Monad m => (a -> [b]) -> Conduit a m b
- concatMapAccum :: Monad m => (a -> accum -> (accum, [b])) -> accum -> Conduit a m b
- groupBy :: Monad m => (a -> a -> Bool) -> Conduit a m [a]
- isolate :: Monad m => Int -> Conduit a m a
- filter :: Monad m => (a -> Bool) -> Conduit a m a
- mapM :: Monad m => (a -> m b) -> Conduit a m b
- concatMapM :: Monad m => (a -> m [b]) -> Conduit a m b
- concatMapAccumM :: Monad m => (a -> accum -> m (accum, [b])) -> accum -> Conduit a m b

# Sources

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

Convert a list into a source.

Since 0.3.0

sourceNull :: Monad m => Source m aSource

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 aSource

Generate a source from a seed value.

Since 0.4.2

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

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

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

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 ()Source

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)Source

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)Source

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')Source

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)Source

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]Source

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 ()Source

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

.

Since 0.3.0

## Monadic

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

Apply the action to all values in the stream.

Since 0.3.0

## Pure

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

Apply a transformation to all values in a stream.

Since 0.3.0

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

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 bSource

`concatMap`

with an accumulator.

Since 0.3.0

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

Grouping input according to an equality function.

Since 0.3.0

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

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 aSource

Keep only values in the stream passing a given predicate.

Since 0.3.0

## Monadic

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

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 bSource

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 bSource

`concatMapM`

with an accumulator.

Since 0.3.0