conduit 1.0.6 → 1.0.7

raw patch · 3 files changed

+110/−2 lines, 3 filesdep +mtlPVP ok

version bump matches the API change (PVP)

Dependencies added: mtl

API changes (from Hackage documentation)

Files

• Data/Conduit/Internal.hs +88/−1
• conduit.cabal +3/−1
• test/main.hs +19/−0

@@ -1,5 +1,6 @@ {-# OPTIONS_HADDOCK not-home #-} {-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE RankNTypes #-}@@ -52,6 +53,11 @@  import Control.Applicative (Applicative (..)) import Control.Monad ((>=>), liftM, ap, when)+import Control.Monad.Error.Class(MonadError(..))+import Control.Monad.Reader.Class(MonadReader(..))+import Control.Monad.RWS.Class(MonadRWS())+import Control.Monad.Writer.Class(MonadWriter(..))+import Control.Monad.State.Class(MonadState(..)) import Control.Monad.Trans.Class (MonadTrans (lift)) import Control.Monad.IO.Class (MonadIO (liftIO)) import Control.Monad.Base (MonadBase (liftBase))@@ -60,7 +66,7 @@ import Control.Monad.Trans.Resource import qualified GHC.Exts import qualified Data.IORef as I-import Control.Monad.Morph+import Control.Monad.Morph (MFunctor (..))  -- | The underlying datatype for all the types in this package.  In has six -- type parameters:@@ -140,6 +146,60 @@ instance MonadResource m => MonadResource (Pipe l i o u m) where     liftResourceT = lift . liftResourceT +instance MonadReader r m => MonadReader r (Pipe l i o u m) where+    ask = lift ask+    local f (HaveOutput p c o) = HaveOutput (local f p) c o+    local f (NeedInput p c) = NeedInput (\i -> local f (p i)) (\u -> local f (c u))+    local _ (Done x) = Done x+    local f (PipeM mp) = PipeM (local f mp)+    local f (Leftover p i) = Leftover (local f p) i++-- Provided for doctest+#ifndef MIN_VERSION_mtl+#define MIN_VERSION_mtl(x, y, z) 0+#endif++instance MonadWriter w m => MonadWriter w (Pipe l i o u m) where+#if MIN_VERSION_mtl(2, 1, 0)+    writer = lift . writer+#endif++    tell = lift . tell++    listen (HaveOutput p c o) = HaveOutput (listen p) c o+    listen (NeedInput p c) = NeedInput (\i -> listen (p i)) (\u -> listen (c u))+    listen (Done x) = Done (x,mempty)+    listen (PipeM mp) =+      PipeM $+      do (p,w) <- listen mp+         return $ do (x,w') <- listen p+                     return (x, w `mappend` w')+    listen (Leftover p i) = Leftover (listen p) i++    pass (HaveOutput p c o) = HaveOutput (pass p) c o+    pass (NeedInput p c) = NeedInput (\i -> pass (p i)) (\u -> pass (c u))+    pass (PipeM mp) = PipeM $ mp >>= (return . pass)+    pass (Done (x,_)) = Done x+    pass (Leftover p i) = Leftover (pass p) i++instance MonadState s m => MonadState s (Pipe l i o u m) where+    get = lift get+    put = lift . put+#if MIN_VERSION_mtl(2, 1, 0)+    state = lift . state+#endif++instance MonadRWS r w s m => MonadRWS r w s (Pipe l i o u m)++instance MonadError e m => MonadError e (Pipe l i o u m) where+    throwError = lift . throwError+    catchError (HaveOutput p c o) f = HaveOutput (catchError p f) c o+    catchError (NeedInput p c) f = NeedInput (\i -> catchError (p i) f) (\u -> catchError (c u) f)+    catchError (Done x) _ = Done x+    catchError (PipeM mp) f =+      PipeM $ catchError (liftM (flip catchError f) mp) (\e -> return (f e))+    catchError (Leftover p i) f = Leftover (catchError p f) i+ -- | Core datatype of the conduit package. This type represents a general -- component which can consume a stream of input values @i@, produce a stream -- of output values @o@, perform actions in the @m@ monad, and produce a final@@ -149,8 +209,35 @@ -- Since 1.0.0 newtype ConduitM i o m r = ConduitM { unConduitM :: Pipe i i o () m r }     deriving (Functor, Applicative, Monad, MonadIO, MonadTrans, MonadThrow, MonadActive, MonadResource, MFunctor)++instance MonadReader r m => MonadReader r (ConduitM i o m) where+    ask = ConduitM ask+    local f (ConduitM m) = ConduitM (local f m)++instance MonadWriter w m => MonadWriter w (ConduitM i o m) where+#if MIN_VERSION_mtl(2, 1, 0)+    writer = ConduitM . writer+#endif+    tell = ConduitM . tell+    listen (ConduitM m) = ConduitM (listen m)+    pass (ConduitM m) = ConduitM (pass m)++instance MonadState s m => MonadState s (ConduitM i o m) where+    get = ConduitM get+    put = ConduitM . put+#if MIN_VERSION_mtl(2, 1, 0)+    state = ConduitM . state+#endif++instance MonadRWS r w s m => MonadRWS r w s (ConduitM i o m)++instance MonadError e m => MonadError e (ConduitM i o m) where+    throwError = ConduitM . throwError+    catchError (ConduitM m) f = ConduitM $ catchError m (unConduitM . f)+ instance MonadBase base m => MonadBase base (ConduitM i o m) where     liftBase = lift . liftBase+ instance Monad m => Monoid (ConduitM i o m ()) where     mempty = return ()     mappend = (>>)

@@ -1,5 +1,5 @@ Name:                conduit-Version:             1.0.6+Version:             1.0.7 Synopsis:            Streaming data processing library. Description:     @conduit@ is a solution to the streaming data problem, allowing for production, transformation, and consumption of streams of data in constant memory. It is an alternative to lazy I\/O which guarantees deterministic resource handling, and fits in the same general solution space as @enumerator@\/@iteratee@ and @pipes@. For a tutorial, please visit <https://haskell.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview>.@@ -54,6 +54,7 @@                      , monad-control            >= 0.3.1        && < 0.4                      , containers                      , transformers             >= 0.2.2        && < 0.4+                     , mtl                      , bytestring               >= 0.9                      , text                     >= 0.11                      , void                     >= 0.5.5@@ -72,6 +73,7 @@                    , QuickCheck                    , bytestring                    , transformers+                   , mtl                    , text                    , resourcet                    , void

@@ -35,6 +35,7 @@ import Control.Monad (forever) import Data.Void (Void) import qualified Control.Concurrent.MVar as M+import Control.Monad.Error (catchError, throwError, Error)  (@=?) :: (Eq a, Show a) => a -> a -> IO () (@=?) = flip shouldBe@@ -913,5 +914,23 @@                 lbs' `shouldBe` lbs                 fromIntegral len `shouldBe` L.length lbs' +    describe "mtl instances" $ do+        it "ErrorT" $ do+            let src = flip catchError (const $ C.yield 4) $ do+                    lift $ return ()+                    C.yield 1+                    lift $ return ()+                    C.yield 2+                    lift $ return ()+                    () <- throwError DummyError+                    lift $ return ()+                    C.yield 3+                    lift $ return ()+            (src C.$$ CL.consume) `shouldBe` Right [1, 2, 4 :: Int]+ it' :: String -> IO () -> Spec it' = it++data DummyError = DummyError+    deriving (Show, Eq)+instance Error DummyError