Conduit.Simple

Please see the project README for more details:

https:github.comjwiegleysimple-conduitblobmaster/README.md

Also see this blog article:

https:www.newartisans.com201406/simpler-conduit-library

Documentation

type Source m a r = r -> (r -> a -> EitherT r m r) -> EitherT r m r

In the type variable below, r stands for result, with much the same meaning as you find in ContT. a is the type of each element in the stream. The type of Source should recall foldM:

 Monad m => (a -> b -> m a) -> a -> [b] -> m a

EitherT is used to signal short-circuiting of the pipeline.

type Conduit a m b r = Source m a r -> Source m b r

type Sink a m r = Source m a r -> m r

returnC :: Monad m => m a -> Source m a r

Promote any sink to a source. This can be used as if it were a source transformer (aka, a conduit):

>>> sinkList $ returnC $ sumC $ mapC (+1) $ sourceList [1..10]
[65]

($=) :: a -> (a -> b) -> b

Compose a Source and a Conduit into a new Source. Note that this is just flipped function application, so ($) can be used to achieve the same thing.

(=$) :: (a -> b) -> (b -> c) -> a -> c

Compose a Conduit and a Sink into a new Sink. Note that this is just function composition, so (.) can be used to achieve the same thing.

($$) :: a -> (a -> b) -> b

Compose a Source and a Sink and compute the result. Note that this is just flipped function application, so ($) can be used to achieve the same thing.

(<+>) :: Monad m => Source m a r -> Conduit a m a r

Since Sources are not Monads in this library (as they are in the full conduit library), they can be sequentially chained using this append operator. If Source were a newtype, we could make it an instance of Monoid.

rewrap :: Monad m => (a -> b) -> EitherT a m a -> EitherT b m b

This is just like bimapEitherT, but it only requires a Monad constraint rather than Functor.

rewrapM :: Monad m => (a -> EitherT b m b) -> EitherT a m a -> EitherT b m b

resolve :: Monad m => (r -> a -> EitherT r m r) -> r -> a -> m r

yieldMany :: (Monad m, MonoFoldable mono) => mono -> Source m (Element mono) r

yieldOne :: Monad m => a -> Source m a r

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

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

iterateC :: Monad m => (a -> a) -> a -> Source m a r

repeatC :: Monad m => a -> Source m a r

replicateC :: Monad m => Int -> a -> Source m a r

sourceLazy :: (Monad m, LazySequence lazy strict) => lazy -> Source m strict r

repeatMC :: Monad m => m a -> Source m a r

repeatWhileMC :: Monad m => m a -> (a -> Bool) -> Source m a r

replicateMC :: Monad m => Int -> m a -> Source m a r

sourceHandle :: (MonadIO m, IOData a) => Handle -> Source m a r

sourceFile :: (MonadBaseControl IO m, MonadIO m, IOData a) => FilePath -> Source m a r

sourceIOHandle :: (MonadBaseControl IO m, MonadIO m, IOData a) => IO Handle -> Source m a r

stdinC :: (MonadBaseControl IO m, MonadIO m, IOData a) => Source m a r

initRepeat :: Monad m => m seed -> (seed -> m a) -> Source m a r

initReplicate :: Monad m => m seed -> (seed -> m a) -> Int -> Source m a r

sourceRandom :: (Variate a, MonadIO m) => Source m a r

sourceRandomN :: (Variate a, MonadIO m) => Int -> Source m a r

sourceRandomGen :: (Variate a, MonadBase base m, PrimMonad base) => Gen (PrimState base) -> Source m a r

sourceRandomNGen :: (Variate a, MonadBase base m, PrimMonad base) => Gen (PrimState base) -> Int -> Source m a r

sourceDirectory :: (MonadBaseControl IO m, MonadIO m) => FilePath -> Source m FilePath r

sourceDirectoryDeep :: (MonadBaseControl IO m, MonadIO m) => Bool -> FilePath -> Source m FilePath r

dropC :: Monad m => Int -> Source m a (Int, r) -> Source m a r

dropCE :: (Monad m, IsSequence seq) => Index seq -> Source m seq (Index seq, r) -> Source m seq r

dropWhileC :: Monad m => (a -> Bool) -> Source m a (a -> Bool, r) -> Source m a r

dropWhileCE :: (Monad m, IsSequence seq) => (Element seq -> Bool) -> Source m seq (Element seq -> Bool, r) -> Source m seq r

foldC :: (Monad m, Monoid a) => Sink a m a

foldCE :: (Monad m, MonoFoldable mono, Monoid (Element mono)) => Sink mono m (Element mono)

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

foldlCE :: (Monad m, MonoFoldable mono) => (a -> Element mono -> a) -> a -> Sink mono m a

foldMapC :: (Monad m, Monoid b) => (a -> b) -> Sink a m b

foldMapCE :: (Monad m, MonoFoldable mono, Monoid w) => (Element mono -> w) -> Sink mono m w

allC :: Monad m => (a -> Bool) -> Source m a All -> m Bool

allCE :: (Monad m, MonoFoldable mono) => (Element mono -> Bool) -> Source m mono All -> m Bool

anyC :: Monad m => (a -> Bool) -> Source m a Any -> m Bool

anyCE :: (Monad m, MonoFoldable mono) => (Element mono -> Bool) -> Source m mono Any -> m Bool

andC :: Monad m => Source m Bool All -> m Bool

andCE :: (Monad m, MonoFoldable mono, Element mono ~ Bool) => Source m mono All -> m Bool

orC :: Monad m => Source m Bool Any -> m Bool

orCE :: (Monad m, MonoFoldable mono, Element mono ~ Bool) => Source m mono Any -> m Bool

elemC :: (Monad m, Eq a) => a -> Source m a Any -> m Bool

elemCE :: (Monad m, EqSequence seq) => Element seq -> Source m seq Any -> m Bool

notElemC :: (Monad m, Eq a) => a -> Source m a All -> m Bool

notElemCE :: (Monad m, EqSequence seq) => Element seq -> Source m seq All -> m Bool

produceList :: Monad m => ([a] -> b) -> Source m a ([a] -> [a]) -> m b

sinkLazy :: (Monad m, LazySequence lazy strict) => Source m strict ([strict] -> [strict]) -> m lazy

sinkList :: Monad m => Source m a ([a] -> [a]) -> m [a]

sinkVector :: (MonadBase base m, Vector v a, PrimMonad base) => Sink a m (v a)

sinkVectorN :: (MonadBase base m, Vector v a, PrimMonad base) => Int -> Sink a m (v a)

sinkBuilder :: (Monad m, Monoid builder, ToBuilder a builder) => Sink a m builder

sinkLazyBuilder :: (Monad m, Monoid builder, ToBuilder a builder, Builder builder lazy) => Source m a builder -> m lazy

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

awaitNonNull :: (Monad m, MonoFoldable a) => Conduit a m (Maybe (NonNull a)) r

headCE :: (Monad m, IsSequence seq) => Sink seq m (Maybe (Element seq))

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

lastCE :: (Monad m, IsSequence seq) => Sink seq m (Maybe (Element seq))

lengthC :: (Monad m, Num len) => Sink a m len

lengthCE :: (Monad m, Num len, MonoFoldable mono) => Sink mono m len

lengthIfC :: (Monad m, Num len) => (a -> Bool) -> Sink a m len

lengthIfCE :: (Monad m, Num len, MonoFoldable mono) => (Element mono -> Bool) -> Sink mono m len

maximumC :: (Monad m, Ord a) => Sink a m (Maybe a)

maximumCE :: (Monad m, OrdSequence seq) => Sink seq m (Maybe (Element seq))

minimumC :: (Monad m, Ord a) => Sink a m (Maybe a)

minimumCE :: (Monad m, OrdSequence seq) => Sink seq m (Maybe (Element seq))

sumC :: (Monad m, Num a) => Sink a m a

sumCE :: (Monad m, MonoFoldable mono, Num (Element mono)) => Sink mono m (Element mono)

productC :: (Monad m, Num a) => Sink a m a

productCE :: (Monad m, MonoFoldable mono, Num (Element mono)) => Sink mono m (Element mono)

findC :: Monad m => (a -> Bool) -> Sink a m (Maybe a)

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

mapM_CE :: (Monad m, MonoFoldable mono) => (Element mono -> m ()) -> Sink mono m ()

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

foldMCE :: (Monad m, MonoFoldable mono) => (a -> Element mono -> m a) -> a -> Sink mono m a

foldMapMC :: (Monad m, Monoid w) => (a -> m w) -> Sink a m w

foldMapMCE :: (Monad m, MonoFoldable mono, Monoid w) => (Element mono -> m w) -> Sink mono m w

sinkFile :: (MonadBaseControl IO m, MonadIO m, IOData a) => FilePath -> Sink a m ()

sinkHandle :: (MonadIO m, IOData a) => Handle -> Sink a m ()

sinkIOHandle :: (MonadBaseControl IO m, MonadIO m, IOData a) => IO Handle -> Sink a m ()

printC :: (Show a, MonadIO m) => Sink a m ()

stdoutC :: (MonadIO m, IOData a) => Sink a m ()

stderrC :: (MonadIO m, IOData a) => Sink a m ()

mapC :: Monad m => (a -> b) -> Conduit a m b r

mapCE :: (Monad m, Functor f) => (a -> b) -> Conduit (f a) m (f b) r

omapCE :: (Monad m, MonoFunctor mono) => (Element mono -> Element mono) -> Conduit mono m mono r

concatMapC :: (Monad m, MonoFoldable mono) => (a -> mono) -> Conduit a m (Element mono) r

concatMapCE :: (Monad m, MonoFoldable mono, Monoid w) => (Element mono -> w) -> Conduit mono m w r

takeC :: Monad m => Int -> Source m a (Int, r) -> Source m a r

takeCE :: (Monad m, IsSequence seq) => Index seq -> Conduit seq m seq r

takeWhileC :: Monad m => (a -> Bool) -> Source m a (a -> Bool, r) -> Source m a r

This function reads one more element than it yields, which would be a problem if Sinks were monadic, as they are in conduit or pipes. There is no such concept as resuming where the last conduit left off in this library.

takeWhileCE :: (Monad m, IsSequence seq) => (Element seq -> Bool) -> Conduit seq m seq r

takeExactlyC :: Monad m => Int -> Conduit a m b r -> Conduit a m b r

takeExactlyCE :: (Monad m, IsSequence a) => Index a -> Conduit a m b r -> Conduit a m b r

concatC :: (Monad m, MonoFoldable mono) => Conduit mono m (Element mono) r

filterC :: Monad m => (a -> Bool) -> Conduit a m a r

filterCE :: (IsSequence seq, Monad m) => (Element seq -> Bool) -> Conduit seq m seq r

mapWhileC :: Monad m => (a -> Maybe b) -> Conduit a m b r

conduitVector :: (MonadBase base m, Vector v a, PrimMonad base) => Int -> Conduit a m (v a) r

scanlC :: Monad m => (a -> b -> a) -> a -> Conduit b m a r

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

intersperseC :: Monad m => a -> Source m a (Maybe a, r) -> Source m a r

encodeBase64C :: Monad m => Conduit ByteString m ByteString r

decodeBase64C :: Monad m => Conduit ByteString m ByteString r

encodeBase64URLC :: Monad m => Conduit ByteString m ByteString r

decodeBase64URLC :: Monad m => Conduit ByteString m ByteString r

encodeBase16C :: Monad m => Conduit ByteString m ByteString r

decodeBase16C :: Monad m => Conduit ByteString m ByteString r

mapMC :: Monad m => (a -> m b) -> Conduit a m b r

mapMCE :: (Monad m, Traversable f) => (a -> m b) -> Conduit (f a) m (f b) r

omapMCE :: (Monad m, MonoTraversable mono) => (Element mono -> m (Element mono)) -> Conduit mono m mono r

concatMapMC :: (Monad m, MonoFoldable mono) => (a -> m mono) -> Conduit a m (Element mono) r

filterMC :: Monad m => (a -> m Bool) -> Conduit a m a r

filterMCE :: (Monad m, IsSequence seq) => (Element seq -> m Bool) -> Conduit seq m seq r

iterMC :: Monad m => (a -> m ()) -> Conduit a m a r

scanlMC :: Monad m => (a -> b -> m a) -> a -> Conduit b m a r

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

encodeUtf8C :: (Monad m, Utf8 text binary) => Conduit text m binary r

decodeUtf8C :: MonadThrow m => Conduit ByteString m Text r

lineC :: (Monad m, IsSequence seq, Element seq ~ Char) => Conduit seq m o r -> Conduit seq m o r

lineAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Conduit seq m o r -> Conduit seq m o r

unlinesC :: (Monad m, IsSequence seq, Element seq ~ Char) => Conduit seq m seq r

unlinesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Conduit seq m seq r

linesUnboundedC_ :: (Monad m, IsSequence seq, Eq (Element seq)) => Element seq -> Source m seq (r, seq) -> Source m seq r

linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char) => Source m seq (r, seq) -> Source m seq r

linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Source m seq (r, seq) -> Source m seq r

awaitForever :: Monad m => (a -> (b -> EitherT r m r) -> EitherT r m r -> EitherT r m r) -> Conduit a m b r

The use of awaitForever in this library is just a bit different from conduit:

>>> awaitForever $ \x yield skip -> if even x then yield x else skip

zipSourceApp :: Monad m => Source m (x -> y) r -> Source m x r -> Source m y r

newtype ZipSource m r a

Constructors

ZipSource

Fields

getZipSource :: Source m a r

Instances

Monad m => Functor (ZipSource m r)

Monad m => Applicative (ZipSource m r)

sequenceSources :: (Traversable f, Monad m) => f (Source m a r) -> Source m (f a) r

Sequence a collection of sources, feeding them all the same input and yielding a collection of their results.

>>> sinkList $ sequenceSources [yieldOne 1, yieldOne 2, yieldOne 3]
[[1,2,3]]

zipSinks :: Monad m => (Source m i rs -> m r) -> (Source m i rs' -> m r') -> (forall s. Source m i s) -> m (r, r')

newtype ZipSink i m r s

Constructors

ZipSink

Fields

getZipSink :: Source m i r -> m s

Instances

Monad m => Functor (ZipSink i m r)

Monad m => Applicative (ZipSink i m r)

sequenceSinks :: (Traversable f, Monad m) => f (Source m i r -> m s) -> Source m i r -> m (f s)

Send incoming values to all of the Sink providing, and ultimately coalesce together all return values.

Implemented on top of ZipSink, see that data type for more details.

Since 1.0.13

asyncC :: (MonadBaseControl IO m, Monad m) => (a -> m b) -> Conduit a m (Async (StM m b)) r