Conduit.Simple

Description

Synopsis

• 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
• returnC :: Monad m => m a -> Source m a r
• ($=) :: a -> (a -> b) -> b
• (=$) :: (a -> b) -> (b -> c) -> a -> c
• ($$) :: a -> (a -> b) -> b
• (<+>) :: Monad m => Source m a r -> Conduit a m a r
• 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
• 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 = 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

Documentation

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

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

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

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