classy-prelude-conduit 1.4.0 → 1.5.0
raw patch · 1 files changed
+7/−7 lines, 1 filesdep ~classy-preludePVP ok
version bump matches the API change (PVP)
Dependency ranges changed: classy-prelude
API changes (from Hackage documentation)
+ ClassyPrelude.Conduit: ($$) :: Monad m => Source m a -> Sink a m b -> m b
+ ClassyPrelude.Conduit: ($$+) :: Monad m => Source m a -> Sink a m b -> m (SealedConduitT () a m (), b)
+ ClassyPrelude.Conduit: ($$++) :: Monad m => SealedConduitT () a m () -> Sink a m b -> m (SealedConduitT () a m (), b)
+ ClassyPrelude.Conduit: ($$+-) :: Monad m => SealedConduitT () a m () -> Sink a m b -> m b
+ ClassyPrelude.Conduit: ($=) :: Monad m => Conduit a m b -> ConduitT b c m r -> ConduitT a c m r
+ ClassyPrelude.Conduit: ($=+) :: Monad m => SealedConduitT () a m () -> Conduit a m b -> SealedConduitT () b m ()
+ ClassyPrelude.Conduit: (.|) :: Monad m => ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
+ ClassyPrelude.Conduit: (=$$+) :: Monad m => ConduitT a b m () -> ConduitT b Void m r -> ConduitT a Void m (SealedConduitT a b m (), r)
+ ClassyPrelude.Conduit: (=$$++) :: Monad m => SealedConduitT i o m () -> ConduitT o Void m r -> ConduitT i Void m (SealedConduitT i o m (), r)
+ ClassyPrelude.Conduit: (=$$+-) :: Monad m => SealedConduitT i o m () -> ConduitT o Void m r -> ConduitT i Void m r
+ ClassyPrelude.Conduit: (=$) :: Monad m => Conduit a m b -> ConduitT b c m r -> ConduitT a c m r
+ ClassyPrelude.Conduit: (=$=) :: Monad m => Conduit a m b -> ConduitT b c m r -> ConduitT a c m r
+ ClassyPrelude.Conduit: Chunk :: a -> Flush a
+ ClassyPrelude.Conduit: Flush :: Flush a
+ ClassyPrelude.Conduit: Identity :: a -> Identity a
+ ClassyPrelude.Conduit: ReleaseEarly :: ReleaseType
+ ClassyPrelude.Conduit: ReleaseException :: ReleaseType
+ ClassyPrelude.Conduit: ReleaseNormal :: ReleaseType
+ ClassyPrelude.Conduit: ZipConduit :: ConduitT i o m r -> ZipConduit i o r
+ ClassyPrelude.Conduit: ZipSink :: Sink i m r -> ZipSink i r
+ ClassyPrelude.Conduit: ZipSource :: Source m o -> ZipSource o
+ ClassyPrelude.Conduit: [getZipConduit] :: ZipConduit i o r -> ConduitT i o m r
+ ClassyPrelude.Conduit: [getZipSink] :: ZipSink i r -> Sink i m r
+ ClassyPrelude.Conduit: [getZipSource] :: ZipSource o -> Source m o
+ ClassyPrelude.Conduit: [runIdentity] :: Identity a -> a
+ ClassyPrelude.Conduit: allC :: Monad m => a -> Bool -> ConduitT a o m Bool
+ ClassyPrelude.Conduit: allCE :: (Monad m, MonoFoldable mono) => Element mono -> Bool -> ConduitT mono o m Bool
+ ClassyPrelude.Conduit: allNewBuffersStrategy :: Int -> BufferAllocStrategy
+ ClassyPrelude.Conduit: allocateAcquire :: MonadResource m => Acquire a -> m (ReleaseKey, a)
+ ClassyPrelude.Conduit: andC :: Monad m => ConduitT Bool o m Bool
+ ClassyPrelude.Conduit: andCE :: (Monad m, MonoFoldable mono, Element mono ~ Bool) => ConduitT mono o m Bool
+ ClassyPrelude.Conduit: anyC :: Monad m => a -> Bool -> ConduitT a o m Bool
+ ClassyPrelude.Conduit: anyCE :: (Monad m, MonoFoldable mono) => Element mono -> Bool -> ConduitT mono o m Bool
+ ClassyPrelude.Conduit: askUnliftIO :: MonadUnliftIO m => m UnliftIO m
+ ClassyPrelude.Conduit: asumC :: (Monad m, Alternative f) => ConduitT f a o m f a
+ ClassyPrelude.Conduit: await :: Monad m => Consumer i m Maybe i
+ ClassyPrelude.Conduit: awaitForever :: Monad m => i -> ConduitT i o m r -> ConduitT i o m ()
+ ClassyPrelude.Conduit: awaitNonNull :: (Monad m, MonoFoldable a) => ConduitT a o m Maybe NonNull a
+ ClassyPrelude.Conduit: bracketP :: MonadResource m => IO a -> a -> IO () -> a -> ConduitT i o m r -> ConduitT i o m r
+ ClassyPrelude.Conduit: builderToByteString :: PrimMonad m => ConduitT Builder ByteString m ()
+ ClassyPrelude.Conduit: builderToByteStringFlush :: PrimMonad m => ConduitT Flush Builder Flush ByteString m ()
+ ClassyPrelude.Conduit: builderToByteStringWith :: PrimMonad m => BufferAllocStrategy -> ConduitT Builder ByteString m ()
+ ClassyPrelude.Conduit: builderToByteStringWithFlush :: PrimMonad m => BufferAllocStrategy -> ConduitT Flush Builder Flush ByteString m ()
+ ClassyPrelude.Conduit: catchC :: (MonadUnliftIO m, Exception e) => ConduitT i o m r -> e -> ConduitT i o m r -> ConduitT i o m r
+ ClassyPrelude.Conduit: catchCatchC :: Monad m => ConduitT i o CatchT m r -> SomeException -> ConduitT i o CatchT m r -> ConduitT i o CatchT m r
+ ClassyPrelude.Conduit: catchExceptC :: Monad m => ConduitT i o ExceptT e m r -> e -> ConduitT i o ExceptT e m r -> ConduitT i o ExceptT e m r
+ ClassyPrelude.Conduit: chunksOfCE :: (Monad m, IsSequence seq) => Index seq -> ConduitT seq seq m ()
+ ClassyPrelude.Conduit: chunksOfExactlyCE :: (Monad m, IsSequence seq) => Index seq -> ConduitT seq seq m ()
+ ClassyPrelude.Conduit: class Monad m => MonadIO (m :: * -> *)
+ ClassyPrelude.Conduit: class MonadIO m => MonadResource (m :: * -> *)
+ ClassyPrelude.Conduit: class Monad m => MonadThrow (m :: * -> *)
+ ClassyPrelude.Conduit: class MonadTrans (t :: * -> * -> * -> *)
+ ClassyPrelude.Conduit: class MonadIO m => MonadUnliftIO (m :: * -> *)
+ ClassyPrelude.Conduit: class Monad m => PrimMonad (m :: * -> *) where {
+ ClassyPrelude.Conduit: concatC :: (Monad m, MonoFoldable mono) => ConduitT mono Element mono m ()
+ ClassyPrelude.Conduit: concatMapAccumC :: Monad m => a -> accum -> (accum, [b]) -> accum -> ConduitT a b m ()
+ ClassyPrelude.Conduit: concatMapAccumMC :: Monad m => a -> accum -> m (accum, [b]) -> accum -> ConduitT a b m ()
+ ClassyPrelude.Conduit: concatMapC :: (Monad m, MonoFoldable mono) => a -> mono -> ConduitT a Element mono m ()
+ ClassyPrelude.Conduit: concatMapCE :: (Monad m, MonoFoldable mono, Monoid w) => Element mono -> w -> ConduitT mono w m ()
+ ClassyPrelude.Conduit: concatMapMC :: (Monad m, MonoFoldable mono) => a -> m mono -> ConduitT a Element mono m ()
+ ClassyPrelude.Conduit: conduitVector :: (Vector v a, PrimMonad m) => Int -> ConduitT a v a m ()
+ ClassyPrelude.Conduit: connect :: Monad m => ConduitT () a m () -> ConduitT a Void m r -> m r
+ ClassyPrelude.Conduit: data Acquire a
+ ClassyPrelude.Conduit: data ConduitT i o (m :: * -> *) r
+ ClassyPrelude.Conduit: data Flush a
+ ClassyPrelude.Conduit: data ReleaseType
+ ClassyPrelude.Conduit: data ResourceT (m :: * -> *) a
+ ClassyPrelude.Conduit: data SealedConduitT i o (m :: * -> *) r
+ ClassyPrelude.Conduit: data Void
+ ClassyPrelude.Conduit: decodeUtf8C :: MonadThrow m => ConduitT ByteString Text m ()
+ ClassyPrelude.Conduit: decodeUtf8LenientC :: Monad m => ConduitT ByteString Text m ()
+ ClassyPrelude.Conduit: dropC :: Monad m => Int -> ConduitT a o m ()
+ ClassyPrelude.Conduit: dropCE :: (Monad m, IsSequence seq) => Index seq -> ConduitT seq o m ()
+ ClassyPrelude.Conduit: dropWhileC :: Monad m => a -> Bool -> ConduitT a o m ()
+ ClassyPrelude.Conduit: dropWhileCE :: (Monad m, IsSequence seq) => Element seq -> Bool -> ConduitT seq o m ()
+ ClassyPrelude.Conduit: elemC :: (Monad m, Eq a) => a -> ConduitT a o m Bool
+ ClassyPrelude.Conduit: elemCE :: (Monad m, IsSequence seq, Eq Element seq) => Element seq -> ConduitT seq o m Bool
+ ClassyPrelude.Conduit: encodeUtf8C :: (Monad m, Utf8 text binary) => ConduitT text binary m ()
+ ClassyPrelude.Conduit: enumFromToC :: (Monad m, Enum a, Ord a) => a -> a -> ConduitT i a m ()
+ ClassyPrelude.Conduit: evalRWSC :: (Monad m, Monoid w) => r -> s -> ConduitT i o RWST r w s m res -> ConduitT i o m (res, w)
+ ClassyPrelude.Conduit: evalRWSLC :: (Monad m, Monoid w) => r -> s -> ConduitT i o RWST r w s m res -> ConduitT i o m (res, w)
+ ClassyPrelude.Conduit: evalStateC :: Monad m => s -> ConduitT i o StateT s m r -> ConduitT i o m r
+ ClassyPrelude.Conduit: evalStateLC :: Monad m => s -> ConduitT i o StateT s m r -> ConduitT i o m r
+ ClassyPrelude.Conduit: exceptC :: Monad m => ConduitT i o m Either e a -> ConduitT i o ExceptT e m a
+ ClassyPrelude.Conduit: execRWSC :: (Monad m, Monoid w) => r -> s -> ConduitT i o RWST r w s m res -> ConduitT i o m (s, w)
+ ClassyPrelude.Conduit: execRWSLC :: (Monad m, Monoid w) => r -> s -> ConduitT i o RWST r w s m res -> ConduitT i o m (s, w)
+ ClassyPrelude.Conduit: execStateC :: Monad m => s -> ConduitT i o StateT s m r -> ConduitT i o m s
+ ClassyPrelude.Conduit: execStateLC :: Monad m => s -> ConduitT i o StateT s m r -> ConduitT i o m s
+ ClassyPrelude.Conduit: execWriterC :: (Monad m, Monoid w) => ConduitT i o WriterT w m r -> ConduitT i o m w
+ ClassyPrelude.Conduit: execWriterLC :: (Monad m, Monoid w) => ConduitT i o WriterT w m r -> ConduitT i o m w
+ ClassyPrelude.Conduit: filterC :: Monad m => a -> Bool -> ConduitT a a m ()
+ ClassyPrelude.Conduit: filterCE :: (IsSequence seq, Monad m) => Element seq -> Bool -> ConduitT seq seq m ()
+ ClassyPrelude.Conduit: filterMC :: Monad m => a -> m Bool -> ConduitT a a m ()
+ ClassyPrelude.Conduit: filterMCE :: (Monad m, IsSequence seq) => Element seq -> m Bool -> ConduitT seq seq m ()
+ ClassyPrelude.Conduit: findC :: Monad m => a -> Bool -> ConduitT a o m Maybe a
+ ClassyPrelude.Conduit: foldC :: (Monad m, Monoid a) => ConduitT a o m a
+ ClassyPrelude.Conduit: foldCE :: (Monad m, MonoFoldable mono, Monoid Element mono) => ConduitT mono o m Element mono
+ ClassyPrelude.Conduit: foldMC :: Monad m => a -> b -> m a -> a -> ConduitT b o m a
+ ClassyPrelude.Conduit: foldMCE :: (Monad m, MonoFoldable mono) => a -> Element mono -> m a -> a -> ConduitT mono o m a
+ ClassyPrelude.Conduit: foldMapC :: (Monad m, Monoid b) => a -> b -> ConduitT a o m b
+ ClassyPrelude.Conduit: foldMapCE :: (Monad m, MonoFoldable mono, Monoid w) => Element mono -> w -> ConduitT mono o m w
+ ClassyPrelude.Conduit: foldMapMC :: (Monad m, Monoid w) => a -> m w -> ConduitT a o m w
+ ClassyPrelude.Conduit: foldMapMCE :: (Monad m, MonoFoldable mono, Monoid w) => Element mono -> m w -> ConduitT mono o m w
+ ClassyPrelude.Conduit: foldlC :: Monad m => a -> b -> a -> a -> ConduitT b o m a
+ ClassyPrelude.Conduit: foldlCE :: (Monad m, MonoFoldable mono) => a -> Element mono -> a -> a -> ConduitT mono o m a
+ ClassyPrelude.Conduit: fuse :: Monad m => Conduit a m b -> ConduitM b c m r -> ConduitM a c m r
+ ClassyPrelude.Conduit: fuseBoth :: Monad m => ConduitT a b m r1 -> ConduitT b c m r2 -> ConduitT a c m (r1, r2)
+ ClassyPrelude.Conduit: fuseBothMaybe :: Monad m => ConduitT a b m r1 -> ConduitT b c m r2 -> ConduitT a c m (Maybe r1, r2)
+ ClassyPrelude.Conduit: fuseLeftovers :: Monad m => [b] -> [a] -> ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
+ ClassyPrelude.Conduit: fuseReturnLeftovers :: Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m (r, [b])
+ ClassyPrelude.Conduit: fuseUpstream :: Monad m => ConduitT a b m r -> Conduit b m c -> ConduitT a c m r
+ ClassyPrelude.Conduit: handleC :: (MonadUnliftIO m, Exception e) => e -> ConduitT i o m r -> ConduitT i o m r -> ConduitT i o m r
+ ClassyPrelude.Conduit: headC :: Monad m => ConduitT a o m Maybe a
+ ClassyPrelude.Conduit: headCE :: (Monad m, IsSequence seq) => ConduitT seq o m Maybe Element seq
+ ClassyPrelude.Conduit: headDefC :: Monad m => a -> ConduitT a o m a
+ ClassyPrelude.Conduit: infixl 1 $=
+ ClassyPrelude.Conduit: infixr 0 $$
+ ClassyPrelude.Conduit: infixr 2 .|
+ ClassyPrelude.Conduit: intersperseC :: Monad m => a -> ConduitT a a m ()
+ ClassyPrelude.Conduit: iterMC :: Monad m => a -> m () -> ConduitT a a m ()
+ ClassyPrelude.Conduit: iterateC :: Monad m => a -> a -> a -> ConduitT i a m ()
+ ClassyPrelude.Conduit: lastC :: Monad m => ConduitT a o m Maybe a
+ ClassyPrelude.Conduit: lastCE :: (Monad m, IsSequence seq) => ConduitT seq o m Maybe Element seq
+ ClassyPrelude.Conduit: lastDefC :: Monad m => a -> ConduitT a o m a
+ ClassyPrelude.Conduit: leftover :: () => i -> ConduitT i o m ()
+ ClassyPrelude.Conduit: lengthC :: (Monad m, Num len) => ConduitT a o m len
+ ClassyPrelude.Conduit: lengthCE :: (Monad m, Num len, MonoFoldable mono) => ConduitT mono o m len
+ ClassyPrelude.Conduit: lengthIfC :: (Monad m, Num len) => a -> Bool -> ConduitT a o m len
+ ClassyPrelude.Conduit: lengthIfCE :: (Monad m, Num len, MonoFoldable mono) => Element mono -> Bool -> ConduitT mono o m len
+ ClassyPrelude.Conduit: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ ClassyPrelude.Conduit: liftIO :: MonadIO m => IO a -> m a
+ ClassyPrelude.Conduit: lineAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => ConduitT seq o m r -> ConduitT seq o m r
+ ClassyPrelude.Conduit: lineC :: (Monad m, IsSequence seq, Element seq ~ Char) => ConduitT seq o m r -> ConduitT seq o m r
+ ClassyPrelude.Conduit: linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => ConduitT seq seq m ()
+ ClassyPrelude.Conduit: linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char) => ConduitT seq seq m ()
+ ClassyPrelude.Conduit: mapAccumS :: Monad m => a -> s -> ConduitT b Void m s -> s -> ConduitT () b m () -> ConduitT a Void m s
+ ClassyPrelude.Conduit: mapAccumWhileC :: Monad m => a -> s -> Either s (s, b) -> s -> ConduitT a b m s
+ ClassyPrelude.Conduit: mapAccumWhileMC :: Monad m => a -> s -> m Either s (s, b) -> s -> ConduitT a b m s
+ ClassyPrelude.Conduit: mapC :: Monad m => a -> b -> ConduitT a b m ()
+ ClassyPrelude.Conduit: mapCE :: (Monad m, Functor f) => a -> b -> ConduitT f a f b m ()
+ ClassyPrelude.Conduit: mapInput :: Monad m => i1 -> i2 -> i2 -> Maybe i1 -> ConduitT i2 o m r -> ConduitT i1 o m r
+ ClassyPrelude.Conduit: mapMC :: Monad m => a -> m b -> ConduitT a b m ()
+ ClassyPrelude.Conduit: mapMCE :: (Monad m, Traversable f) => a -> m b -> ConduitT f a f b m ()
+ ClassyPrelude.Conduit: mapM_C :: Monad m => a -> m () -> ConduitT a o m ()
+ ClassyPrelude.Conduit: mapM_CE :: (Monad m, MonoFoldable mono) => Element mono -> m () -> ConduitT mono o m ()
+ ClassyPrelude.Conduit: mapOutput :: Monad m => o1 -> o2 -> ConduitT i o1 m r -> ConduitT i o2 m r
+ ClassyPrelude.Conduit: mapOutputMaybe :: Monad m => o1 -> Maybe o2 -> ConduitT i o1 m r -> ConduitT i o2 m r
+ ClassyPrelude.Conduit: mapWhileC :: Monad m => a -> Maybe b -> ConduitT a b m ()
+ ClassyPrelude.Conduit: maximumC :: (Monad m, Ord a) => ConduitT a o m Maybe a
+ ClassyPrelude.Conduit: maximumCE :: (Monad m, IsSequence seq, Ord Element seq) => ConduitT seq o m Maybe Element seq
+ ClassyPrelude.Conduit: maybeC :: Monad m => ConduitT i o m Maybe a -> ConduitT i o MaybeT m a
+ ClassyPrelude.Conduit: mergeSource :: Monad m => Source m i -> Conduit a m (i, a)
+ ClassyPrelude.Conduit: minimumC :: (Monad m, Ord a) => ConduitT a o m Maybe a
+ ClassyPrelude.Conduit: minimumCE :: (Monad m, IsSequence seq, Ord Element seq) => ConduitT seq o m Maybe Element seq
+ ClassyPrelude.Conduit: mkAcquire :: () => IO a -> a -> IO () -> Acquire a
+ ClassyPrelude.Conduit: mkAcquireType :: () => IO a -> a -> ReleaseType -> IO () -> Acquire a
+ ClassyPrelude.Conduit: newtype Identity a
+ ClassyPrelude.Conduit: newtype ZipConduit i o (m :: * -> *) r
+ ClassyPrelude.Conduit: newtype ZipSink i (m :: * -> *) r
+ ClassyPrelude.Conduit: newtype ZipSource (m :: * -> *) o
+ ClassyPrelude.Conduit: notElemC :: (Monad m, Eq a) => a -> ConduitT a o m Bool
+ ClassyPrelude.Conduit: notElemCE :: (Monad m, IsSequence seq, Eq Element seq) => Element seq -> ConduitT seq o m Bool
+ ClassyPrelude.Conduit: nullC :: Monad m => ConduitT a o m Bool
+ ClassyPrelude.Conduit: nullCE :: (Monad m, MonoFoldable mono) => ConduitT mono o m Bool
+ ClassyPrelude.Conduit: omapCE :: (Monad m, MonoFunctor mono) => Element mono -> Element mono -> ConduitT mono mono m ()
+ ClassyPrelude.Conduit: omapMCE :: (Monad m, MonoTraversable mono) => Element mono -> m Element mono -> ConduitT mono mono m ()
+ ClassyPrelude.Conduit: orC :: Monad m => ConduitT Bool o m Bool
+ ClassyPrelude.Conduit: orCE :: (Monad m, MonoFoldable mono, Element mono ~ Bool) => ConduitT mono o m Bool
+ ClassyPrelude.Conduit: passthroughSink :: Monad m => Sink i m r -> r -> m () -> Conduit i m i
+ ClassyPrelude.Conduit: peekC :: Monad m => ConduitT a o m Maybe a
+ ClassyPrelude.Conduit: peekCE :: (Monad m, MonoFoldable mono) => ConduitT mono o m Maybe Element mono
+ ClassyPrelude.Conduit: peekForever :: Monad m => ConduitT i o m () -> ConduitT i o m ()
+ ClassyPrelude.Conduit: peekForeverE :: (Monad m, MonoFoldable i) => ConduitT i o m () -> ConduitT i o m ()
+ ClassyPrelude.Conduit: primitive :: PrimMonad m => State# PrimState m -> (# State# PrimState m, a #) -> m a
+ ClassyPrelude.Conduit: printC :: (Show a, MonadIO m) => ConduitT a o m ()
+ ClassyPrelude.Conduit: productC :: (Monad m, Num a) => ConduitT a o m a
+ ClassyPrelude.Conduit: productCE :: (Monad m, MonoFoldable mono, Num Element mono) => ConduitT mono o m Element mono
+ ClassyPrelude.Conduit: readerC :: Monad m => r -> ConduitT i o m a -> ConduitT i o ReaderT r m a
+ ClassyPrelude.Conduit: repeatC :: Monad m => a -> ConduitT i a m ()
+ ClassyPrelude.Conduit: repeatMC :: Monad m => m a -> ConduitT i a m ()
+ ClassyPrelude.Conduit: repeatWhileMC :: Monad m => m a -> a -> Bool -> ConduitT i a m ()
+ ClassyPrelude.Conduit: replicateC :: Monad m => Int -> a -> ConduitT i a m ()
+ ClassyPrelude.Conduit: replicateMC :: Monad m => Int -> m a -> ConduitT i a m ()
+ ClassyPrelude.Conduit: reuseBufferStrategy :: IO Buffer -> BufferAllocStrategy
+ ClassyPrelude.Conduit: runCatchC :: Monad m => ConduitT i o CatchT m r -> ConduitT i o m Either SomeException r
+ ClassyPrelude.Conduit: runConduit :: Monad m => ConduitT () Void m r -> m r
+ ClassyPrelude.Conduit: runConduitPure :: () => ConduitT () Void Identity r -> r
+ ClassyPrelude.Conduit: runConduitRes :: MonadUnliftIO m => ConduitT () Void ResourceT m r -> m r
+ ClassyPrelude.Conduit: runExceptC :: Monad m => ConduitT i o ExceptT e m r -> ConduitT i o m Either e r
+ ClassyPrelude.Conduit: runMaybeC :: Monad m => ConduitT i o MaybeT m r -> ConduitT i o m Maybe r
+ ClassyPrelude.Conduit: runRWSC :: (Monad m, Monoid w) => r -> s -> ConduitT i o RWST r w s m res -> ConduitT i o m (res, s, w)
+ ClassyPrelude.Conduit: runRWSLC :: (Monad m, Monoid w) => r -> s -> ConduitT i o RWST r w s m res -> ConduitT i o m (res, s, w)
+ ClassyPrelude.Conduit: runReaderC :: Monad m => r -> ConduitT i o ReaderT r m res -> ConduitT i o m res
+ ClassyPrelude.Conduit: runResourceT :: MonadUnliftIO m => ResourceT m a -> m a
+ ClassyPrelude.Conduit: runStateC :: Monad m => s -> ConduitT i o StateT s m r -> ConduitT i o m (r, s)
+ ClassyPrelude.Conduit: runStateLC :: Monad m => s -> ConduitT i o StateT s m r -> ConduitT i o m (r, s)
+ ClassyPrelude.Conduit: runWriterC :: (Monad m, Monoid w) => ConduitT i o WriterT w m r -> ConduitT i o m (r, w)
+ ClassyPrelude.Conduit: runWriterLC :: (Monad m, Monoid w) => ConduitT i o WriterT w m r -> ConduitT i o m (r, w)
+ ClassyPrelude.Conduit: rwsC :: (Monad m, Monoid w) => r -> s -> ConduitT i o m (a, s, w) -> ConduitT i o RWST r w s m a
+ ClassyPrelude.Conduit: rwsLC :: (Monad m, Monoid w) => r -> s -> ConduitT i o m (a, s, w) -> ConduitT i o RWST r w s m a
+ ClassyPrelude.Conduit: scanlC :: Monad m => a -> b -> a -> a -> ConduitT b a m ()
+ ClassyPrelude.Conduit: scanlMC :: Monad m => a -> b -> m a -> a -> ConduitT b a m ()
+ ClassyPrelude.Conduit: sealConduitT :: () => ConduitT i o m r -> SealedConduitT i o m r
+ ClassyPrelude.Conduit: sequenceConduits :: (Traversable f, Monad m) => f ConduitT i o m r -> ConduitT i o m f r
+ ClassyPrelude.Conduit: sequenceSinks :: (Traversable f, Monad m) => f Sink i m r -> Sink i m f r
+ ClassyPrelude.Conduit: sequenceSources :: (Traversable f, Monad m) => f Source m o -> Source m f o
+ ClassyPrelude.Conduit: sinkFile :: MonadResource m => FilePath -> ConduitT ByteString o m ()
+ ClassyPrelude.Conduit: sinkFileBS :: MonadResource m => FilePath -> ConduitT ByteString o m ()
+ ClassyPrelude.Conduit: sinkFileCautious :: MonadResource m => FilePath -> ConduitM ByteString o m ()
+ ClassyPrelude.Conduit: sinkHandle :: MonadIO m => Handle -> ConduitT ByteString o m ()
+ ClassyPrelude.Conduit: sinkHandleBuilder :: MonadIO m => Handle -> ConduitM Builder o m ()
+ ClassyPrelude.Conduit: sinkHandleFlush :: MonadIO m => Handle -> ConduitM Flush ByteString o m ()
+ ClassyPrelude.Conduit: sinkIOHandle :: MonadResource m => IO Handle -> ConduitT ByteString o m ()
+ ClassyPrelude.Conduit: sinkLazy :: (Monad m, LazySequence lazy strict) => ConduitT strict o m lazy
+ ClassyPrelude.Conduit: sinkLazyBuilder :: Monad m => ConduitT Builder o m ByteString
+ ClassyPrelude.Conduit: sinkList :: Monad m => ConduitT a o m [a]
+ ClassyPrelude.Conduit: sinkNull :: Monad m => ConduitT a o m ()
+ ClassyPrelude.Conduit: sinkSystemTempFile :: MonadResource m => String -> ConduitM ByteString o m FilePath
+ ClassyPrelude.Conduit: sinkTempFile :: MonadResource m => FilePath -> String -> ConduitM ByteString o m FilePath
+ ClassyPrelude.Conduit: sinkVector :: (Vector v a, PrimMonad m) => ConduitT a o m v a
+ ClassyPrelude.Conduit: sinkVectorN :: (Vector v a, PrimMonad m) => Int -> ConduitT a o m v a
+ ClassyPrelude.Conduit: slidingWindowC :: (Monad m, IsSequence seq, Element seq ~ a) => Int -> ConduitT a seq m ()
+ ClassyPrelude.Conduit: sourceDirectory :: MonadResource m => FilePath -> ConduitT i FilePath m ()
+ ClassyPrelude.Conduit: sourceDirectoryDeep :: MonadResource m => Bool -> FilePath -> ConduitT i FilePath m ()
+ ClassyPrelude.Conduit: sourceFile :: MonadResource m => FilePath -> ConduitT i ByteString m ()
+ ClassyPrelude.Conduit: sourceFileBS :: MonadResource m => FilePath -> ConduitT i ByteString m ()
+ ClassyPrelude.Conduit: sourceHandle :: MonadIO m => Handle -> ConduitT i ByteString m ()
+ ClassyPrelude.Conduit: sourceHandleUnsafe :: MonadIO m => Handle -> ConduitT i ByteString m ()
+ ClassyPrelude.Conduit: sourceIOHandle :: MonadResource m => IO Handle -> ConduitT i ByteString m ()
+ ClassyPrelude.Conduit: sourceLazy :: (Monad m, LazySequence lazy strict) => lazy -> ConduitT i strict m ()
+ ClassyPrelude.Conduit: sourceToList :: Monad m => Source m a -> m [a]
+ ClassyPrelude.Conduit: stateC :: Monad m => s -> ConduitT i o m (a, s) -> ConduitT i o StateT s m a
+ ClassyPrelude.Conduit: stateLC :: Monad m => s -> ConduitT i o m (a, s) -> ConduitT i o StateT s m a
+ ClassyPrelude.Conduit: stderrC :: MonadIO m => ConduitT ByteString o m ()
+ ClassyPrelude.Conduit: stdinC :: MonadIO m => ConduitT i ByteString m ()
+ ClassyPrelude.Conduit: stdoutC :: MonadIO m => ConduitT ByteString o m ()
+ ClassyPrelude.Conduit: sumC :: (Monad m, Num a) => ConduitT a o m a
+ ClassyPrelude.Conduit: sumCE :: (Monad m, MonoFoldable mono, Num Element mono) => ConduitT mono o m Element mono
+ ClassyPrelude.Conduit: takeC :: Monad m => Int -> ConduitT a a m ()
+ ClassyPrelude.Conduit: takeCE :: (Monad m, IsSequence seq) => Index seq -> ConduitT seq seq m ()
+ ClassyPrelude.Conduit: takeExactlyC :: Monad m => Int -> ConduitT a b m r -> ConduitT a b m r
+ ClassyPrelude.Conduit: takeExactlyCE :: (Monad m, IsSequence a) => Index a -> ConduitT a b m r -> ConduitT a b m r
+ ClassyPrelude.Conduit: takeWhileC :: Monad m => a -> Bool -> ConduitT a a m ()
+ ClassyPrelude.Conduit: takeWhileCE :: (Monad m, IsSequence seq) => Element seq -> Bool -> ConduitT seq seq m ()
+ ClassyPrelude.Conduit: toConsumer :: Monad m => Sink a m b -> Consumer a m b
+ ClassyPrelude.Conduit: toProducer :: Monad m => Source m a -> Producer m a
+ ClassyPrelude.Conduit: transPipe :: Monad m => forall a. () => m a -> n a -> ConduitT i o m r -> ConduitT i o n r
+ ClassyPrelude.Conduit: tryC :: (MonadUnliftIO m, Exception e) => ConduitT i o m r -> ConduitT i o m Either e r
+ ClassyPrelude.Conduit: type BufferAllocStrategy = (IO Buffer, Int -> Buffer -> IO IO Buffer)
+ ClassyPrelude.Conduit: type Conduit i (m :: * -> *) o = ConduitT i o m ()
+ ClassyPrelude.Conduit: type ConduitM = ConduitT
+ ClassyPrelude.Conduit: type Consumer i (m :: * -> *) r = forall o. () => ConduitT i o m r
+ ClassyPrelude.Conduit: type Sink i = ConduitT i Void
+ ClassyPrelude.Conduit: type Source (m :: * -> *) o = ConduitT () o m ()
+ ClassyPrelude.Conduit: type family PrimState (m :: * -> *) :: *;
+ ClassyPrelude.Conduit: unfoldC :: Monad m => b -> Maybe (a, b) -> b -> ConduitT i a m ()
+ ClassyPrelude.Conduit: unlinesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => ConduitT seq seq m ()
+ ClassyPrelude.Conduit: unlinesC :: (Monad m, IsSequence seq, Element seq ~ Char) => ConduitT seq seq m ()
+ ClassyPrelude.Conduit: unsafeBuilderToByteString :: PrimMonad m => ConduitT Builder ByteString m ()
+ ClassyPrelude.Conduit: unsealConduitT :: Monad m => SealedConduitT i o m r -> ConduitT i o m r
+ ClassyPrelude.Conduit: vectorBuilderC :: (PrimMonad m, Vector v e, PrimMonad n, PrimState m ~ PrimState n) => Int -> e -> n () -> ConduitT i Void m r -> ConduitT i v e m r
+ ClassyPrelude.Conduit: withAcquire :: MonadUnliftIO m => Acquire a -> a -> m b -> m b
+ ClassyPrelude.Conduit: withRunInIO :: MonadUnliftIO m => forall a. () => m a -> IO a -> IO b -> m b
+ ClassyPrelude.Conduit: withSinkFile :: (MonadUnliftIO m, MonadIO n) => FilePath -> ConduitM ByteString o n () -> m a -> m a
+ ClassyPrelude.Conduit: withSinkFileBuilder :: (MonadUnliftIO m, MonadIO n) => FilePath -> ConduitM Builder o n () -> m a -> m a
+ ClassyPrelude.Conduit: withSinkFileCautious :: (MonadUnliftIO m, MonadIO n) => FilePath -> ConduitM ByteString o n () -> m a -> m a
+ ClassyPrelude.Conduit: withSourceFile :: (MonadUnliftIO m, MonadIO n) => FilePath -> ConduitM i ByteString n () -> m a -> m a
+ ClassyPrelude.Conduit: writerC :: (Monad m, Monoid w) => ConduitT i o m (b, w) -> ConduitT i o WriterT w m b
+ ClassyPrelude.Conduit: writerLC :: (Monad m, Monoid w) => ConduitT i o m (b, w) -> ConduitT i o WriterT w m b
+ ClassyPrelude.Conduit: yield :: Monad m => o -> ConduitT i o m ()
+ ClassyPrelude.Conduit: yieldM :: Monad m => m o -> ConduitT i o m ()
+ ClassyPrelude.Conduit: yieldMany :: (Monad m, MonoFoldable mono) => mono -> ConduitT i Element mono m ()
+ ClassyPrelude.Conduit: }
Files
classy-prelude-conduit.cabal view
@@ -1,11 +1,13 @@--- This file has been generated from package.yaml by hpack version 0.20.0.+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.30.0. -- -- see: https://github.com/sol/hpack ----- hash: eac13775f728db935eb0e7d72b5aa866d73d53534db56878f47a54f6f22b1d83+-- hash: 4adcfd7fdce423ab658e251ecde6e21f8a079e638a2d5b333c8ddbf12dc61084 name: classy-prelude-conduit-version: 1.4.0+version: 1.5.0 synopsis: classy-prelude together with conduit functions description: See docs and README at <http://www.stackage.org/package/classy-prelude-conduit> category: Control, Prelude@@ -16,11 +18,9 @@ license: MIT license-file: LICENSE build-type: Simple-cabal-version: >= 1.10- extra-source-files:- ChangeLog.md README.md+ ChangeLog.md source-repository head type: git@@ -33,7 +33,7 @@ build-depends: base >=4.9 && <5 , bytestring- , classy-prelude >=1.4.0 && <1.4.1+ , classy-prelude >=1.5.0 && <1.5.1 , conduit >=1.3 && <1.4 , monad-control , resourcet