Conduit.Simple.Core

Please see the project README for more details:

https://github.com/jwiegley/simple-conduit/blob/master/README.md

Also see this blog article:

https://www.newartisans.com/2014/06/simpler-conduit-library

Documentation

newtype Source m a

A Source is a short-circuiting monadic fold.

Source forms a Monad that behaves as ListT; for example:

do x <- yieldMany [1..3]
   line <- sourceFile "foo.txt"
   return (x, line)

This yields the cross-product of [3] and the lines in the files, but only reading chunks from the file as needed by the sink.

To skip to the next value in a Source, use the function skip or mempty; to close the source, use close. For example:

do x <- yieldMany [1..10]
   if x == 2 || x == 9
   then return x
   else if x < 5
        then skip
        else close

This outputs the list [2].

A key difference from the conduit library is that monadic chaining of sources with >> follows ListT, and not concatenation as in conduit. To achieve conduit-style behavior, use the Monoid instance:

>>> sinkList $ yieldMany [1..3] <> yieldMany [4..6]
[1,2,3,4,5,6]

Constructors

Source

Fields

• getSource :: forall r. Cont (r -> EitherT r m r) a

Instances

MonadTrans Source

Methods

lift :: Monad m => m a -> Source m a

MFunctor Source

Methods

hoist :: Monad m => (forall a. m a -> n a) -> Source m b -> Source n b

MMonad Source

Methods

embed :: Monad n => (forall a. m a -> Source n a) -> Source m b -> Source n b

(Functor f, MonadFree f m) => MonadFree f (Source m)

Methods

wrap :: f (Source m a) -> Source m a

MonadError e m => MonadError e (Source m)

Methods

throwError :: e -> Source m a

catchError :: Source m a -> (e -> Source m a) -> Source m a

MonadReader r m => MonadReader r (Source m)

Methods

ask :: Source m r

local :: (r -> r) -> Source m a -> Source m a

reader :: (r -> a) -> Source m a

MonadState s m => MonadState s (Source m)

Methods

get :: Source m s

put :: s -> Source m ()

state :: (s -> (a, s)) -> Source m a

MonadWriter w m => MonadWriter w (Source m)

Methods

writer :: (a, w) -> Source m a

tell :: w -> Source m ()

listen :: Source m a -> Source m (a, w)

pass :: Source m (a, w -> w) -> Source m a

Monad (Source m)

Methods

(>>=) :: Source m a -> (a -> Source m b) -> Source m b

(>>) :: Source m a -> Source m b -> Source m b

return :: a -> Source m a

fail :: String -> Source m a

Functor (Source m)

Methods

fmap :: (a -> b) -> Source m a -> Source m b

(<$) :: a -> Source m b -> Source m a

Applicative (Source m)

Methods

pure :: a -> Source m a

(<*>) :: Source m (a -> b) -> Source m a -> Source m b

(*>) :: Source m a -> Source m b -> Source m b

(<*) :: Source m a -> Source m b -> Source m a

Foldable (Source Identity)

Methods

fold :: Monoid m => Source Identity m -> m

foldMap :: Monoid m => (a -> m) -> Source Identity a -> m

foldr :: (a -> b -> b) -> b -> Source Identity a -> b

foldr' :: (a -> b -> b) -> b -> Source Identity a -> b

foldl :: (b -> a -> b) -> b -> Source Identity a -> b

foldl' :: (b -> a -> b) -> b -> Source Identity a -> b

foldr1 :: (a -> a -> a) -> Source Identity a -> a

foldl1 :: (a -> a -> a) -> Source Identity a -> a

toList :: Source Identity a -> [a]

null :: Source Identity a -> Bool

length :: Source Identity a -> Int

elem :: Eq a => a -> Source Identity a -> Bool

maximum :: Ord a => Source Identity a -> a

minimum :: Ord a => Source Identity a -> a

sum :: Num a => Source Identity a -> a

product :: Num a => Source Identity a -> a

Monad m => MonadPlus (Source m)

Methods

mzero :: Source m a

mplus :: Source m a -> Source m a -> Source m a

MonadIO m => MonadIO (Source m)

Methods

liftIO :: IO a -> Source m a

Monad m => Alternative (Source m)

Methods

empty :: Source m a

(<|>) :: Source m a -> Source m a -> Source m a

some :: Source m a -> Source m [a]

many :: Source m a -> Source m [a]

MonadThrow m => MonadThrow (Source m)

Methods

throwM :: Exception e => e -> Source m a

MonadCatch m => MonadCatch (Source m)

Methods

catch :: Exception e => Source m a -> (e -> Source m a) -> Source m a

MonadMask m => MonadMask (Source m)

Methods

mask :: ((forall a. Source m a -> Source m a) -> Source m b) -> Source m b

uninterruptibleMask :: ((forall a. Source m a -> Source m a) -> Source m b) -> Source m b

Monad m => Semigroup (Source m a)

Methods

(<>) :: Source m a -> Source m a -> Source m a

sconcat :: NonEmpty (Source m a) -> Source m a

stimes :: Integral b => b -> Source m a -> Source m a

Monad m => Monoid (Source m a)

Methods

mempty :: Source m a

mappend :: Source m a -> Source m a -> Source m a

mconcat :: [Source m a] -> Source m a

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

A Conduit is a "Source homomorphism", or simple a mapping between sources. There is no need for it to be a type synonym, except to save repetition across type signatures.

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

A Sink folds a Source down to its result value. It is simply a convenient type synonym for functions mapping a Source to some result type.

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

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) $ yieldMany [1..10]
[65]

Note that returnC is a synonym for lift.

prod :: Source m (Cont (r -> EitherT r m r) (Source m a)) -> Cont (r -> EitherT r m r) (Source m a)

close :: Monad m => Source m a

skip :: Monad m => Source m a

runSource :: Source m a -> r -> (r -> a -> EitherT r m r) -> EitherT r m r

lowerSource :: (Monad m, Monoid a) => Source m a -> m a

source :: (forall r. r -> (r -> a -> EitherT r m r) -> EitherT r m r) -> Source m a

conduit :: (forall r. r -> (r -> b -> EitherT r m r) -> a -> EitherT r m r) -> Conduit a m b

conduitWith :: Monad m => s -> (forall r. (r, s) -> (r -> b -> EitherT (r, s) m (r, s)) -> a -> EitherT (r, s) m (r, s)) -> Conduit a m b

Most of the time conduits pass the fold variable through unmolested, but sometimes you need to ignore that variable and use your own within a stage of the pipeline. This is done by wrapping the fold variable in a tuple and then unwrapping it when the conduit is done. conduitWith makes this transparent.

unwrap :: Monad m => EitherT a m a -> m a

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

sink :: forall m a r. Monad m => r -> (r -> a -> EitherT r m r) -> Sink a m r

awaitForever :: (a -> Source m b) -> Conduit a m b