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

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