Safe Haskell | None |
---|
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
- type Source m a r = r -> (r -> a -> EitherT r m r) -> EitherT r m r
- 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
- newtype SourceWrapper m a = SourceWrapper {}
- wrap :: (forall r. Source m a r) -> SourceWrapper m a
- newtype SinkWrapper a m r = SinkWrapper {
- getSink :: SourceWrapper m a -> m r
- returnC :: Monad m => m a -> Source m a r
- ($=) :: a -> (a -> b) -> b
- (=$) :: (a -> b) -> (b -> c) -> a -> c
- ($$) :: a -> (a -> b) -> b
- rewrap :: Monad m => (a -> b) -> EitherT a m a -> EitherT b m b
- 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
- 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
- zipSourceApp :: Monad m => Source m (x -> y) r -> Source m x r -> Source m y r
- newtype ZipSource m r a = ZipSource {
- getZipSource :: Source m a r
- sequenceSources :: (Traversable f, Monad m) => f (Source m a r) -> Source m (f a) r
- (<+>) :: Monad m => Source m a r -> Conduit a m a r
- zipSinks :: Monad m => (Source (StateT (r', s) m) i s -> StateT (r', s) m r) -> (Source (StateT (r', s) m) i s' -> StateT (r', s) m r') -> Source m i (s, s') -> m (r, r')
- newtype ZipSink i m r s = ZipSink {
- getZipSink :: Source m i r -> m s
- sequenceSinks :: (Traversable f, Monad m) => f (Source m i r -> m s) -> Source m i r -> m (f s)
- asyncC :: (MonadBaseControl IO m, Monad m) => (a -> m b) -> Conduit a m (Async (StM m b)) r
- fromFoldM :: Monad m => FoldM m a b -> (forall r. Source m a r) -> m b
- toFoldM :: Monad m => Sink a m r -> (FoldM (EitherT r m) a r -> EitherT r m r) -> m r
- sourceTChan :: TChan a -> Source STM a r
- sourceTQueue :: TQueue a -> Source STM a r
- sourceTBQueue :: TBQueue a -> Source STM a r
- untilMC :: Monad m => m a -> m Bool -> Source m a r
- whileMC :: Monad m => m Bool -> m a -> Source m a r
Documentation
newtype SourceWrapper m a Source
When wrapped in a SourceWrapper
using wrap
, Sources offer a number of
typeclass instances, one of which is Monad. As a Monad, it behaves very
much list the list monad: the value bound is each element of the
iteration in turn.
sinkList $ getSource $ do x <- wrap $ yieldMany [1..3] y <- wrap $ yieldMany [4..6] wrap $ yieldOne (x, y) ==> [(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]
Monad (SourceWrapper m) | |
Functor (SourceWrapper m) | |
Applicative (SourceWrapper m) | |
Foldable (SourceWrapper Identity) | |
Monad m => Monoid (SourceWrapper m a) |
wrap :: (forall r. Source m a r) -> SourceWrapper m aSource
newtype SinkWrapper a m r Source
SinkWrapper | |
|
Monad m => Functor (SinkWrapper a m) |
returnC :: Monad m => m a -> Source m a rSource
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]
rewrap :: Monad m => (a -> b) -> EitherT a m a -> EitherT b m bSource
This is just like bimapEitherT
, but it only
requires a Monad
constraint rather than Functor
.
replicateC :: Monad m => Int -> a -> Source m a rSource
sourceLazy :: (Monad m, LazySequence lazy strict) => lazy -> Source m strict rSource
repeatWhileMC :: Monad m => m a -> (a -> Bool) -> Source m a rSource
replicateMC :: Monad m => Int -> m a -> Source m a rSource
sourceFile :: (MonadBaseControl IO m, MonadIO m, IOData a) => FilePath -> Source m a rSource
sourceIOHandle :: (MonadBaseControl IO m, MonadIO m, IOData a) => IO Handle -> Source m a rSource
initRepeat :: Monad m => m seed -> (seed -> m a) -> Source m a rSource
initReplicate :: Monad m => m seed -> (seed -> m a) -> Int -> Source m a rSource
sourceRandom :: (Variate a, MonadIO m) => Source m a rSource
sourceRandomGen :: (Variate a, MonadBase base m, PrimMonad base) => Gen (PrimState base) -> Source m a rSource
sourceRandomNGen :: (Variate a, MonadBase base m, PrimMonad base) => Gen (PrimState base) -> Int -> Source m a rSource
sourceDirectory :: (MonadBaseControl IO m, MonadIO m) => FilePath -> Source m FilePath rSource
sourceDirectoryDeep :: (MonadBaseControl IO m, MonadIO m) => Bool -> FilePath -> Source m FilePath rSource
dropCE :: (Monad m, IsSequence seq) => Index seq -> Source m seq (Index seq, r) -> Source m seq rSource
dropWhileCE :: (Monad m, IsSequence seq) => (Element seq -> Bool) -> Source m seq (Element seq -> Bool, r) -> Source m seq rSource
allCE :: (Monad m, MonoFoldable mono) => (Element mono -> Bool) -> Source m mono All -> m BoolSource
anyCE :: (Monad m, MonoFoldable mono) => (Element mono -> Bool) -> Source m mono Any -> m BoolSource
produceList :: Monad m => ([a] -> b) -> Source m a ([a] -> [a]) -> m bSource
sinkLazy :: (Monad m, LazySequence lazy strict) => Source m strict ([strict] -> [strict]) -> m lazySource
sinkLazyBuilder :: (Monad m, Monoid builder, ToBuilder a builder, Builder builder lazy) => Source m a builder -> m lazySource
awaitNonNull :: (Monad m, MonoFoldable a) => Conduit a m (Maybe (NonNull a)) rSource
lengthIfCE :: (Monad m, Num len, MonoFoldable mono) => (Element mono -> Bool) -> Sink mono m lenSource
foldMapMCE :: (Monad m, MonoFoldable mono, Monoid w) => (Element mono -> m w) -> Sink mono m wSource
sinkIOHandle :: (MonadBaseControl IO m, MonadIO m, IOData a) => IO Handle -> Sink a m ()Source
omapCE :: (Monad m, MonoFunctor mono) => (Element mono -> Element mono) -> Conduit mono m mono rSource
concatMapC :: (Monad m, MonoFoldable mono) => (a -> mono) -> Conduit a m (Element mono) rSource
concatMapCE :: (Monad m, MonoFoldable mono, Monoid w) => (Element mono -> w) -> Conduit mono m w rSource
takeWhileC :: Monad m => (a -> Bool) -> Source m a (a -> Bool, r) -> Source m a rSource
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 rSource
takeExactlyCE :: (Monad m, IsSequence a) => Index a -> Conduit a m b r -> Conduit a m b rSource
concatMapAccumC :: Monad m => (a -> accum -> (accum, [b])) -> accum -> Conduit a m b rSource
encodeBase64C :: Monad m => Conduit ByteString m ByteString rSource
decodeBase64C :: Monad m => Conduit ByteString m ByteString rSource
encodeBase64URLC :: Monad m => Conduit ByteString m ByteString rSource
decodeBase64URLC :: Monad m => Conduit ByteString m ByteString rSource
encodeBase16C :: Monad m => Conduit ByteString m ByteString rSource
decodeBase16C :: Monad m => Conduit ByteString m ByteString rSource
mapMCE :: (Monad m, Traversable f) => (a -> m b) -> Conduit (f a) m (f b) rSource
omapMCE :: (Monad m, MonoTraversable mono) => (Element mono -> m (Element mono)) -> Conduit mono m mono rSource
concatMapMC :: (Monad m, MonoFoldable mono) => (a -> m mono) -> Conduit a m (Element mono) rSource
concatMapAccumMC :: Monad m => (a -> accum -> m (accum, [b])) -> accum -> Conduit a m b rSource
encodeUtf8C :: (Monad m, Utf8 text binary) => Conduit text m binary rSource
decodeUtf8C :: MonadThrow m => Conduit ByteString m Text rSource
lineC :: (Monad m, IsSequence seq, Element seq ~ Char) => Conduit seq m o r -> Conduit seq m o rSource
lineAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Conduit seq m o r -> Conduit seq m o rSource
unlinesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Conduit seq m seq rSource
linesUnboundedC_ :: (Monad m, IsSequence seq, Eq (Element seq)) => Element seq -> Source m seq (r, seq) -> Source m seq rSource
linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char) => Source m seq (r, seq) -> Source m seq rSource
linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Source m seq (r, seq) -> Source m seq rSource
awaitForever :: Monad m => (a -> (b -> EitherT r m r) -> EitherT r m r -> EitherT r m r) -> Conduit a m b rSource
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
newtype ZipSource m r a Source
ZipSource | |
|
sequenceSources :: (Traversable f, Monad m) => f (Source m a r) -> Source m (f a) rSource
Sequence a collection of sources.
>>>
sinkList $ sequenceSources [yieldOne 1, yieldOne 2, yieldOne 3]
[[1,2,3]]
(<+>) :: Monad m => Source m a r -> Conduit a m a rSource
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.
zipSinks :: Monad m => (Source (StateT (r', s) m) i s -> StateT (r', s) m r) -> (Source (StateT (r', s) m) i s' -> StateT (r', s) m r') -> Source m i (s, s') -> m (r, r')Source
Zip sinks together. This function may be used multiple times:
>>>
let mySink s await => resolve await () $ \() x -> liftIO $ print $ s <> show x
>>>
zipSinks sinkList (zipSinks (mySink "foo") (mySink "bar")) $ yieldMany [1,2,3]
"foo: 1" "bar: 1" "foo: 2" "bar: 2" "foo: 3" "bar: 3" ([1,2,3],((),()))
newtype ZipSink i m r s Source
ZipSink | |
|
sequenceSinks :: (Traversable f, Monad m) => f (Source m i r -> m s) -> Source m i r -> m (f s)Source
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.
fromFoldM :: Monad m => FoldM m a b -> (forall r. Source m a r) -> m bSource
Convert a FoldM
fold abstraction into a Sink.
NOTE: This requires ImpredicativeTypes in the code that uses it.
>>>
fromFoldM (FoldM ((return .) . (+)) (return 0) return) $ yieldMany [1..10]
55
toFoldM :: Monad m => Sink a m r -> (FoldM (EitherT r m) a r -> EitherT r m r) -> m rSource
Convert a Sink into a FoldM
, passing it into a
continuation.
>>>
toFoldM sumC (\f -> Control.Foldl.foldM f [1..10])
55
sourceTChan :: TChan a -> Source STM a rSource
A Source for exhausting a TChan, but blocks if it is initially empty.
sourceTQueue :: TQueue a -> Source STM a rSource
sourceTBQueue :: TBQueue a -> Source STM a rSource