simple-conduit 0.5.1 → 0.6.0
raw patch · 2 files changed
+29/−33 lines, 2 filesdep ~monad-controldep ~mono-traversabledep ~transformersPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: monad-control, mono-traversable, transformers, transformers-base
API changes (from Hackage documentation)
- Conduit.Simple: getSource :: Source m a -> forall r. Cont (r -> EitherT r m r) a
- Conduit.Simple.Core: getSource :: Source m a -> forall r. Cont (r -> EitherT r m r) a
- Conduit.Simple.Core: instance (Functor f, MonadFree f m) => MonadFree f (Source m)
- Conduit.Simple.Core: instance Applicative (Source m)
- Conduit.Simple.Core: instance Foldable (Source Identity)
- Conduit.Simple.Core: instance Functor (Source m)
- Conduit.Simple.Core: instance MFunctor Source
- Conduit.Simple.Core: instance MMonad Source
- Conduit.Simple.Core: instance Monad (Source m)
- Conduit.Simple.Core: instance Monad m => Alternative (Source m)
- Conduit.Simple.Core: instance Monad m => MonadPlus (Source m)
- Conduit.Simple.Core: instance Monad m => Monoid (Source m a)
- Conduit.Simple.Core: instance Monad m => Semigroup (Source m a)
- Conduit.Simple.Core: instance MonadCatch m => MonadCatch (Source m)
- Conduit.Simple.Core: instance MonadError e m => MonadError e (Source m)
- Conduit.Simple.Core: instance MonadIO m => MonadIO (Source m)
- Conduit.Simple.Core: instance MonadMask m => MonadMask (Source m)
- Conduit.Simple.Core: instance MonadReader r m => MonadReader r (Source m)
- Conduit.Simple.Core: instance MonadState s m => MonadState s (Source m)
- Conduit.Simple.Core: instance MonadThrow m => MonadThrow (Source m)
- Conduit.Simple.Core: instance MonadTrans Source
- Conduit.Simple.Core: instance MonadWriter w m => MonadWriter w (Source m)
+ Conduit.Simple: [getSource] :: Source m a -> forall r. Cont (r -> EitherT r m r) a
+ Conduit.Simple: infixl 1 $=
+ Conduit.Simple: infixr 0 $$
+ Conduit.Simple: infixr 2 =$=
+ Conduit.Simple.Compat: infixl 1 $=
+ Conduit.Simple.Compat: infixr 0 $$
+ Conduit.Simple.Compat: infixr 2 =$=
+ Conduit.Simple.Core: [getSource] :: Source m a -> forall r. Cont (r -> EitherT r m r) a
+ Conduit.Simple.Core: instance (GHC.Base.Functor f, Control.Monad.Free.Class.MonadFree f m) => Control.Monad.Free.Class.MonadFree f (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.Morph.MFunctor Conduit.Simple.Core.Source
+ Conduit.Simple.Core: instance Control.Monad.Morph.MMonad Conduit.Simple.Core.Source
+ Conduit.Simple.Core: instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Control.Monad.Trans.Class.MonadTrans Conduit.Simple.Core.Source
+ Conduit.Simple.Core: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance Data.Foldable.Foldable (Conduit.Simple.Core.Source Data.Functor.Identity.Identity)
+ Conduit.Simple.Core: instance GHC.Base.Applicative (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance GHC.Base.Functor (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance GHC.Base.Monad (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance GHC.Base.Monad m => Data.Semigroup.Semigroup (Conduit.Simple.Core.Source m a)
+ Conduit.Simple.Core: instance GHC.Base.Monad m => GHC.Base.Alternative (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance GHC.Base.Monad m => GHC.Base.MonadPlus (Conduit.Simple.Core.Source m)
+ Conduit.Simple.Core: instance GHC.Base.Monad m => GHC.Base.Monoid (Conduit.Simple.Core.Source m a)
- Conduit.Simple: elemCE :: (Monad m, EqSequence seq) => Element seq -> Sink seq m Bool
+ Conduit.Simple: elemCE :: (Monad m, MonoFoldable seq, Eq (Element seq)) => Element seq -> Sink seq m Bool
- Conduit.Simple: encodeUtf8C :: (Monad m, Utf8 text binary) => Conduit text m binary
+ Conduit.Simple: encodeUtf8C :: Monad m => Conduit Text m ByteString
- Conduit.Simple: enumFromToC :: (Monad m, Enum a, Eq a) => a -> a -> Source m a
+ Conduit.Simple: enumFromToC :: forall m a. (Monad m, Enum a, Eq a) => a -> a -> Source m a
- Conduit.Simple: iterateC :: Monad m => (a -> a) -> a -> Source m a
+ Conduit.Simple: iterateC :: forall m a. Monad m => (a -> a) -> a -> Source m a
- Conduit.Simple: linesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Conduit seq m seq
+ Conduit.Simple: linesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8, Semigroup seq) => Conduit seq m seq
- Conduit.Simple: linesC :: (Monad m, IsSequence seq, Element seq ~ Char) => Conduit seq m seq
+ Conduit.Simple: linesC :: (Monad m, IsSequence seq, Element seq ~ Char, Semigroup seq) => Conduit seq m seq
- Conduit.Simple: linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8) => Conduit seq m seq
+ Conduit.Simple: linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8, Semigroup seq) => Conduit seq m seq
- Conduit.Simple: linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char) => Conduit seq m seq
+ Conduit.Simple: linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char, Semigroup seq) => Conduit seq m seq
- Conduit.Simple: linesUnboundedC_ :: (Monad m, IsSequence seq, Eq (Element seq)) => Element seq -> Conduit seq m seq
+ Conduit.Simple: linesUnboundedC_ :: forall m seq. (Monad m, IsSequence seq, Eq (Element seq), Semigroup seq) => Element seq -> Conduit seq m seq
- Conduit.Simple: maximumCE :: (Monad m, OrdSequence seq) => Sink seq m (Maybe (Element seq))
+ Conduit.Simple: maximumCE :: (Monad m, MonoFoldable seq) => Sink seq m (Maybe (Element seq))
- Conduit.Simple: minimumCE :: (Monad m, OrdSequence seq) => Sink seq m (Maybe (Element seq))
+ Conduit.Simple: minimumCE :: (Monad m, MonoFoldable seq) => Sink seq m (Maybe (Element seq))
- Conduit.Simple: notElemCE :: (Monad m, EqSequence seq) => Element seq -> Sink seq m Bool
+ Conduit.Simple: notElemCE :: (Monad m, MonoFoldable seq, Eq (Element seq)) => Element seq -> Sink seq m Bool
- Conduit.Simple: repeatC :: Monad m => a -> Source m a
+ Conduit.Simple: repeatC :: forall m a. Monad m => a -> Source m a
- Conduit.Simple: repeatMC :: Monad m => m a -> Source m a
+ Conduit.Simple: repeatMC :: forall m a. Monad m => m a -> Source m a
- Conduit.Simple: repeatWhileMC :: Monad m => m a -> (a -> Bool) -> Source m a
+ Conduit.Simple: repeatWhileMC :: forall m a. Monad m => m a -> (a -> Bool) -> Source m a
- Conduit.Simple: replicateC :: Monad m => Int -> a -> Source m a
+ Conduit.Simple: replicateC :: forall m a. Monad m => Int -> a -> Source m a
- Conduit.Simple: replicateMC :: Monad m => Int -> m a -> Source m a
+ Conduit.Simple: replicateMC :: forall m a. Monad m => Int -> m a -> Source m a
- Conduit.Simple: sink :: Monad m => r -> (r -> a -> EitherT r m r) -> Sink a m r
+ Conduit.Simple: sink :: forall m a r. Monad m => r -> (r -> a -> EitherT r m r) -> Sink a m r
- Conduit.Simple: sourceDirectory :: MonadBaseControl IO m => FilePath -> Source m FilePath
+ Conduit.Simple: sourceDirectory :: forall m. MonadBaseControl IO m => FilePath -> Source m FilePath
- Conduit.Simple: sourceDirectoryDeep :: MonadBaseControl IO m => Bool -> FilePath -> Source m FilePath
+ Conduit.Simple: sourceDirectoryDeep :: forall m. MonadBaseControl IO m => Bool -> FilePath -> Source m FilePath
- Conduit.Simple: sourceFile :: (MonadBaseControl IO m, MonadIO m, IOData a) => FilePath -> Source m a
+ Conduit.Simple: sourceFile :: (MonadBaseControl IO m, MonadIO m, MonoFoldable a, IOData a) => FilePath -> Source m a
- Conduit.Simple: sourceHandle :: (MonadIO m, IOData a) => Handle -> Source m a
+ Conduit.Simple: sourceHandle :: forall m a. (MonadIO m, MonoFoldable a, IOData a) => Handle -> Source m a
- Conduit.Simple: sourceIOHandle :: (MonadBaseControl IO m, MonadIO m, IOData a) => IO Handle -> Source m a
+ Conduit.Simple: sourceIOHandle :: (MonadBaseControl IO m, MonadIO m, MonoFoldable a, IOData a) => IO Handle -> Source m a
- Conduit.Simple: sourceMaybeMVar :: MonadIO m => MVar (Maybe a) -> Source m a
+ Conduit.Simple: sourceMaybeMVar :: forall m a. MonadIO m => MVar (Maybe a) -> Source m a
- Conduit.Simple: sourceMaybeTMVar :: TMVar (Maybe a) -> Source STM a
+ Conduit.Simple: sourceMaybeTMVar :: forall a. TMVar (Maybe a) -> Source STM a
- Conduit.Simple: sourceTBQueue :: TBQueue a -> Source STM a
+ Conduit.Simple: sourceTBQueue :: forall a. TBQueue a -> Source STM a
- Conduit.Simple: sourceTChan :: TChan a -> Source STM a
+ Conduit.Simple: sourceTChan :: forall a. TChan a -> Source STM a
- Conduit.Simple: sourceTQueue :: TQueue a -> Source STM a
+ Conduit.Simple: sourceTQueue :: forall a. TQueue a -> Source STM a
- Conduit.Simple: stdinC :: (MonadBaseControl IO m, MonadIO m, IOData a) => Source m a
+ Conduit.Simple: stdinC :: (MonadBaseControl IO m, MonadIO m, MonoFoldable a, IOData a) => Source m a
- Conduit.Simple: unfoldC :: Monad m => (b -> Maybe (a, b)) -> b -> Source m a
+ Conduit.Simple: unfoldC :: forall m a b. Monad m => (b -> Maybe (a, b)) -> b -> Source m a
- Conduit.Simple: untilMC :: Monad m => m a -> m Bool -> Source m a
+ Conduit.Simple: untilMC :: forall m a. Monad m => m a -> m Bool -> Source m a
- Conduit.Simple: whileMC :: Monad m => m Bool -> m a -> Source m a
+ Conduit.Simple: whileMC :: forall m a. Monad m => m Bool -> m a -> Source m a
- Conduit.Simple: zipSinks :: (MonadBaseControl IO m, MonadIO m) => Sink a m r -> Sink a m r' -> Sink a m (r, r')
+ Conduit.Simple: zipSinks :: forall a m r r'. (MonadBaseControl IO m, MonadIO m) => Sink a m r -> Sink a m r' -> Sink a m (r, r')
- Conduit.Simple.Core: sink :: Monad m => r -> (r -> a -> EitherT r m r) -> Sink a m r
+ Conduit.Simple.Core: sink :: forall m a r. Monad m => r -> (r -> a -> EitherT r m r) -> Sink a m r
Files
- Conduit/Simple.hs +24/−28
- simple-conduit.cabal +5/−5
Conduit/Simple.hs view
@@ -172,20 +172,16 @@ import Data.ByteString (ByteString) import Data.IOData (IOData(hGetChunk, hPut)) import Data.List (unfoldr)-import Data.MonoTraversable (MonoTraversable, MonoFunctor, Element,- MonoFoldable(oall, oany, ofoldMap,- ofoldl', ofoldlM, olength,- onull))+import Data.MonoTraversable import Data.NonNull as NonNull (NonNull, fromNullable) import Data.Semigroup (Any(..), All(..), Monoid(..), Semigroup((<>)))-import Data.Sequences as Seq (OrdSequence, EqSequence(elem, notElem),- SemiSequence(..), singleton,+import Data.Sequences as Seq (SemiSequence(..), singleton, IsSequence(break, drop, dropWhile, fromList, splitAt))-import Data.Sequences.Lazy (LazySequence(fromChunks, toChunks))+import Data.Sequences (LazySequence(fromChunks, toChunks)) import qualified Data.Streaming.Filesystem as F import Data.Text (Text)-import Data.Textual.Encoding (Utf8(encodeUtf8))+import Data.Text.Encoding (encodeUtf8) import Data.Traversable (Traversable) import qualified Data.Vector.Generic as V import qualified Data.Vector.Generic.Mutable as VM@@ -249,7 +245,7 @@ loop n' r | n' > 0 = loop (n' - 1) =<< yield r =<< lift m loop _ r = return r -sourceHandle :: forall m a. (MonadIO m, IOData a) => Handle -> Source m a+sourceHandle :: forall m a. (MonadIO m, MonoFoldable a, IOData a) => Handle -> Source m a sourceHandle h = source go where go :: r -> (r -> a -> EitherT r m r) -> EitherT r m r@@ -260,25 +256,25 @@ if onull x then return y else loop =<< yield y x-{-# SPECIALIZE sourceHandle :: IOData a => Handle -> Source IO a #-}+{-# SPECIALIZE sourceHandle :: (MonoFoldable a, IOData a) => Handle -> Source IO a #-} -sourceFile :: (MonadBaseControl IO m, MonadIO m, IOData a)+sourceFile :: (MonadBaseControl IO m, MonadIO m, MonoFoldable a, IOData a) => FilePath -> Source m a sourceFile path = source $ \z yield -> liftBaseOp (bracket (openFile path ReadMode) hClose) (\h -> runSource (sourceHandle h) z yield)-{-# SPECIALIZE sourceFile :: IOData a => FilePath -> Source IO a #-}+{-# SPECIALIZE sourceFile :: (MonoFoldable a, IOData a) => FilePath -> Source IO a #-} -sourceIOHandle :: (MonadBaseControl IO m, MonadIO m, IOData a)+sourceIOHandle :: (MonadBaseControl IO m, MonadIO m, MonoFoldable a, IOData a) => IO Handle -> Source m a sourceIOHandle f = source $ \z yield -> liftBaseOp (bracket f hClose) $ \h -> runSource (sourceHandle h) z yield-{-# SPECIALIZE sourceIOHandle :: IOData a => IO Handle -> Source IO a #-}+{-# SPECIALIZE sourceIOHandle :: (MonoFoldable a, IOData a) => IO Handle -> Source IO a #-} -stdinC :: (MonadBaseControl IO m, MonadIO m, IOData a) => Source m a+stdinC :: (MonadBaseControl IO m, MonadIO m, MonoFoldable a, IOData a) => Source m a stdinC = sourceHandle stdin-{-# SPECIALIZE stdinC :: IOData a => Source IO a #-}+{-# SPECIALIZE stdinC :: (MonoFoldable a, IOData a) => Source IO a #-} initRepeat :: Monad m => m seed -> (seed -> m a) -> Source m a initRepeat mseed f = source $ \z yield ->@@ -426,14 +422,14 @@ elemC :: (Monad m, Eq a) => a -> Sink a m Bool elemC x = anyC (== x) -elemCE :: (Monad m, EqSequence seq) => Element seq -> Sink seq m Bool-elemCE = anyC . Seq.elem+elemCE :: (Monad m, MonoFoldable seq, Eq (Element seq)) => Element seq -> Sink seq m Bool+elemCE = anyC . oelem notElemC :: (Monad m, Eq a) => a -> Sink a m Bool notElemC x = allC (/= x) -notElemCE :: (Monad m, EqSequence seq) => Element seq -> Sink seq m Bool-notElemCE = allC . Seq.notElem+notElemCE :: (Monad m, MonoFoldable seq, Eq (Element seq)) => Element seq -> Sink seq m Bool+notElemCE = allC . onotElem produceList :: Monad m => ([a] -> b) -> Sink a m b produceList f =@@ -497,13 +493,13 @@ maximumC :: (Monad m, Ord a) => Sink a m (Maybe a) maximumC = sink Nothing $ \r y -> return $ Just $ maybe y (max y) r -maximumCE :: (Monad m, OrdSequence seq) => Sink seq m (Maybe (Element seq))+maximumCE :: (Monad m, MonoFoldable seq) => Sink seq m (Maybe (Element seq)) maximumCE = undefined minimumC :: (Monad m, Ord a) => Sink a m (Maybe a) minimumC = sink Nothing $ \r y -> return $ Just $ maybe y (min y) r -minimumCE :: (Monad m, OrdSequence seq) => Sink seq m (Maybe (Element seq))+minimumCE :: (Monad m, MonoFoldable seq) => Sink seq m (Maybe (Element seq)) minimumCE = undefined -- jww (2014-06-07): These two cannot be implemented without leftover support.@@ -732,7 +728,7 @@ => (a -> accum -> m (accum, [b])) -> accum -> Conduit a m b concatMapAccumMC = undefined -encodeUtf8C :: (Monad m, Utf8 text binary) => Conduit text m binary+encodeUtf8C :: Monad m => Conduit Text m ByteString encodeUtf8C = mapC encodeUtf8 decodeUtf8C :: MonadThrow m => Conduit ByteString m Text@@ -754,7 +750,7 @@ => Conduit seq m seq unlinesAsciiC = concatMapC (: [Seq.singleton 10]) -linesUnboundedC_ :: forall m seq. (Monad m, IsSequence seq, Eq (Element seq))+linesUnboundedC_ :: forall m seq. (Monad m, IsSequence seq, Eq (Element seq), Semigroup seq) => Element seq -> Conduit seq m seq linesUnboundedC_ sep src = source $ \z yield -> EitherT $ do eres <- runEitherT $ runSource src (z, n) (go yield)@@ -778,19 +774,19 @@ where (x, y) = Seq.break (== sep) t -linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char)+linesUnboundedC :: (Monad m, IsSequence seq, Element seq ~ Char, Semigroup seq) => Conduit seq m seq linesUnboundedC = linesUnboundedC_ '\n' -linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8)+linesUnboundedAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8, Semigroup seq) => Conduit seq m seq linesUnboundedAsciiC = linesUnboundedC_ 10 -linesC :: (Monad m, IsSequence seq, Element seq ~ Char)+linesC :: (Monad m, IsSequence seq, Element seq ~ Char, Semigroup seq) => Conduit seq m seq linesC = linesUnboundedC -linesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8)+linesAsciiC :: (Monad m, IsSequence seq, Element seq ~ Word8, Semigroup seq) => Conduit seq m seq linesAsciiC = linesUnboundedAsciiC
simple-conduit.cabal view
@@ -1,5 +1,5 @@ Name: simple-conduit-Version: 0.5.1+Version: 0.6.0 Synopsis: A simple streaming I/O library based on monadic folds Description: @simple-conduit@ follows a similar UI to the more capable @conduit@ library,@@ -36,8 +36,8 @@ , lifted-async , lifted-base >= 0.1 , mmorph- , monad-control >= 0.3.1 && < 0.4- , mono-traversable+ , monad-control >= 1.0.0+ , mono-traversable >= 1.0 && < 1.1 , mtl , mwc-random , primitive@@ -45,8 +45,8 @@ , stm , streaming-commons , text- , transformers >= 0.2.2 && < 0.5- , transformers-base >= 0.4.1 && < 0.5+ , transformers >= 0.2.2 && < 0.6+ , transformers-base >= 0.4.1 && < 0.6 , vector benchmark bench