conduit 1.3.4.2 → 1.3.4.3

raw patch · 7 files changed

+43/−55 lines, 7 filesdep ~resourcetPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: resourcet

API changes (from Hackage documentation)

Files

• ChangeLog.md +4/−0
• conduit.cabal +1/−1
• src/Data/Conduit/Combinators.hs +1/−1
• src/Data/Conduit/Internal/Conduit.hs +32/−30
• src/Data/Conduit/List.hs +1/−4
• test/Spec.hs +0/−15
• test/main.hs +4/−4

@@ -1,5 +1,9 @@ # ChangeLog for conduit +## 1.3.4.3++* Fix space leak in `*>` [#496](https://github.com/snoyberg/conduit/issues/496) [#497](https://github.com/snoyberg/conduit/pull/497)+ ## 1.3.4.2  * Fix GHC 9.2 build [#473](https://github.com/snoyberg/conduit/pull/473)

@@ -1,5 +1,5 @@ Name:                conduit-Version:             1.3.4.2+Version:             1.3.4.3 Synopsis:            Streaming data processing library. description:     `conduit` is a solution to the streaming data problem, allowing for production,

@@ -2431,7 +2431,7 @@ -- Under the surface, this function uses a number of tricks to get high -- performance. For more information on both usage and implementation, -- please see:--- <https://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilder>+-- <https://www.schoolofhaskell.com/user/snoyberg/library-documentation/vectorbuilder> -- -- @since 1.3.0 vectorBuilder :: (PrimMonad m, PrimMonad n, V.Vector v e, PrimState m ~ PrimState n)

@@ -148,6 +148,8 @@     {-# INLINE pure #-}     (<*>) = ap     {-# INLINE (<*>) #-}+    (*>) = (>>)+    {-# INLINE (*>) #-}  instance Monad (ConduitT i o m) where     return = pure@@ -327,7 +329,7 @@       where         recurse = goLeft rp rc -sourceToPipe :: Monad m => Source m o -> Pipe l i o u m ()+sourceToPipe :: Monad m => ConduitT () o m () -> Pipe l i o u m () sourceToPipe (ConduitT k) =     go $ k Done   where@@ -337,7 +339,7 @@     go (PipeM mp) = PipeM (liftM go mp)     go (Leftover p ()) = go p -sinkToPipe :: Monad m => Sink i m r -> Pipe l i o u m r+sinkToPipe :: Monad m => ConduitT i Void m r -> Pipe l i o u m r sinkToPipe (ConduitT k) =     go $ injectLeftovers $ k Done   where@@ -347,7 +349,7 @@     go (PipeM mp) = PipeM (liftM go mp)     go (Leftover _ l) = absurd l -conduitToPipe :: Monad m => Conduit i m o -> Pipe l i o u m ()+conduitToPipe :: Monad m => ConduitT i o m () -> Pipe l i o u m () conduitToPipe (ConduitT k) =     go $ injectLeftovers $ k Done   where@@ -360,7 +362,7 @@ -- | Generalize a 'Source' to a 'Producer'. -- -- Since 1.0.0-toProducer :: Monad m => Source m a -> ConduitT i a m ()+toProducer :: Monad m => ConduitT () a m () -> ConduitT i a m () toProducer (ConduitT c0) = ConduitT $ \rest -> let     go (HaveOutput p o) = HaveOutput (go p) o     go (NeedInput _ c) = go (c ())@@ -372,7 +374,7 @@ -- | Generalize a 'Sink' to a 'Consumer'. -- -- Since 1.0.0-toConsumer :: Monad m => Sink a m b -> Consumer a m b+toConsumer :: Monad m => ConduitT a Void m b -> ConduitT a o m b toConsumer (ConduitT c0) = ConduitT $ \rest -> let     go (HaveOutput _ o) = absurd o     go (NeedInput p c) = NeedInput (go . p) (go . c)@@ -436,7 +438,7 @@ -- Any leftovers are discarded. -- -- Since 0.4.1-zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r')+zipSinks :: Monad m => ConduitT i Void m r -> ConduitT i Void m r' -> ConduitT i Void m (r, r') zipSinks (ConduitT x0) (ConduitT y0) = ConduitT $ \rest -> let     Leftover _  i    >< _                = absurd i     _                >< Leftover _  i    = absurd i@@ -455,7 +457,7 @@ --   source has been exhausted. -- -- Since 1.0.13-zipSources :: Monad m => Source m a -> Source m b -> Source m (a, b)+zipSources :: Monad m => ConduitT () a m () -> ConduitT () b m () -> ConduitT () (a, b) m () zipSources (ConduitT left0) (ConduitT right0) = ConduitT $ \rest -> let     go (Leftover left ()) right = go left right     go left (Leftover right ())  = go left right@@ -476,7 +478,7 @@ --   source has been exhausted. -- -- Since 1.0.13-zipSourcesApp :: Monad m => Source m (a -> b) -> Source m a -> Source m b+zipSourcesApp :: Monad m => ConduitT () (a -> b) m () -> ConduitT () a m () -> ConduitT () b m () zipSourcesApp (ConduitT left0) (ConduitT right0) = ConduitT $ \rest -> let     go (Leftover left ()) right = go left right     go left (Leftover right ())  = go left right@@ -601,11 +603,11 @@ -- The new conduit will stop processing once either source or upstream have been exhausted. mergeSource   :: Monad m-  => Source m i-  -> Conduit a m (i, a)+  => ConduitT () i m ()+  -> ConduitT a (i, a) m () mergeSource = loop . sealConduitT   where-    loop :: Monad m => SealedConduitT () i m () -> Conduit a m (i, a)+    loop :: Monad m => SealedConduitT () i m () -> ConduitT a (i, a) m ()     loop src0 = await >>= maybe (return ()) go       where         go a = do@@ -629,9 +631,9 @@ -- -- Since 1.1.0 passthroughSink :: Monad m-                => Sink i m r+                => ConduitT i Void m r                 -> (r -> m ()) -- ^ finalizer-                -> Conduit i m i+                -> ConduitT i i m () passthroughSink (ConduitT sink0) final = ConduitT $ \rest -> let     -- A bit of explanation is in order, this function is     -- non-obvious. The purpose of go is to keep track of the sink@@ -689,11 +691,11 @@ -- However, @sourceToList@ is able to produce its results lazily, which cannot -- be done when running a conduit pipeline in general. Unlike the -- @Data.Conduit.Lazy@ module (in conduit-extra), this function performs no--- unsafe I\/O operations, and therefore can only be as lazily as the+-- unsafe I\/O operations, and therefore can only be as lazy as the -- underlying monad. -- -- Since 1.2.6-sourceToList :: Monad m => Source m a -> m [a]+sourceToList :: Monad m => ConduitT () a m () -> m [a] sourceToList (ConduitT k) =     go $ k Done   where@@ -763,7 +765,7 @@ -- deprecated and will be removed in a future version. -- -- Since 1.2.3-fuse :: Monad m => Conduit a m b -> ConduitM b c m r -> ConduitM a c m r+fuse :: Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r fuse = (=$=)  -- | Combine two @Conduit@s together into a new @Conduit@ (aka 'fuse').@@ -794,9 +796,9 @@ -- -- @since 1.2.8 (.|) :: Monad m-     => ConduitM a b m () -- ^ upstream-     -> ConduitM b c m r -- ^ downstream-     -> ConduitM a c m r+     => ConduitT a b m () -- ^ upstream+     -> ConduitT b c m r -- ^ downstream+     -> ConduitT a c m r (.|) = fuse {-# INLINE (.|) #-} @@ -864,7 +866,7 @@ -- also return @Nothing@. -- -- Since 0.5.0-await :: Monad m => Consumer i m (Maybe i)+await :: Monad m => ConduitT i o m (Maybe i) await = ConduitT $ \f -> NeedInput (f . Just) (const $ f Nothing) {-# INLINE [0] await #-} @@ -1051,14 +1053,14 @@ -- Mnemonic: connect + do more. -- -- Since 0.5.0-($$+) :: Monad m => Source m a -> Sink a m b -> m (SealedConduitT () a m (), b)+($$+) :: Monad m => ConduitT () a m () -> ConduitT a Void m b -> m (SealedConduitT () a m (), b) src $$+ sink = connectResume (sealConduitT src) sink {-# INLINE ($$+) #-}  -- | Continue processing after usage of @$$+@. -- -- Since 0.5.0-($$++) :: Monad m => SealedConduitT () a m () -> Sink a m b -> m (SealedConduitT () a m (), b)+($$++) :: Monad m => SealedConduitT () a m () -> ConduitT a Void m b -> m (SealedConduitT () a m (), b) ($$++) = connectResume {-# INLINE ($$++) #-} @@ -1069,7 +1071,7 @@ -- run. Since version 1.3.0, there are no finalizers in conduit. -- -- Since 0.5.0-($$+-) :: Monad m => SealedConduitT () a m () -> Sink a m b -> m b+($$+-) :: Monad m => SealedConduitT () a m () -> ConduitT a Void m b -> m b rsrc $$+- sink = do     (_, res) <- connectResume rsrc sink     return res@@ -1078,7 +1080,7 @@ -- | Left fusion for a sealed source. -- -- Since 1.0.16-($=+) :: Monad m => SealedConduitT () a m () -> Conduit a m b -> SealedConduitT () b m ()+($=+) :: Monad m => SealedConduitT () a m () -> ConduitT a b m () -> SealedConduitT () b m () SealedConduitT src $=+ ConduitT sink = SealedConduitT (src `pipeL` sink Done)  -- | Provide for a stream of data that can be flushed.@@ -1100,7 +1102,7 @@ -- producing output. -- -- Since 1.0.13-newtype ZipSource m o = ZipSource { getZipSource :: Source m o }+newtype ZipSource m o = ZipSource { getZipSource :: ConduitT () o m () }  instance Monad m => Functor (ZipSource m) where     fmap f = ZipSource . mapOutput f . getZipSource@@ -1116,7 +1118,7 @@ -- multiple sources, use `sequence_`. -- -- Since 1.0.13-sequenceSources :: (Traversable f, Monad m) => f (Source m o) -> Source m (f o)+sequenceSources :: (Traversable f, Monad m) => f (ConduitT () o m ()) -> ConduitT () (f o) m () sequenceSources = getZipSource . sequenceA . fmap ZipSource  -- | A wrapper for defining an 'Applicative' instance for 'Sink's which allows@@ -1126,7 +1128,7 @@ -- -- @ -- sequenceSinks :: (Monad m)---           => [Sink i m r] -> Sink i m [r]+--           => [ConduitT i Void m r] -> ConduitT i Void m [r] -- sequenceSinks = getZipSink . sequenceA . fmap ZipSink -- @ --@@ -1141,7 +1143,7 @@ -- understood). -- -- Since 1.0.13-newtype ZipSink i m r = ZipSink { getZipSink :: Sink i m r }+newtype ZipSink i m r = ZipSink { getZipSink :: ConduitT i Void m r }  instance Monad m => Functor (ZipSink i m) where     fmap f (ZipSink x) = ZipSink (liftM f x)@@ -1156,7 +1158,7 @@ -- Implemented on top of @ZipSink@, see that data type for more details. -- -- Since 1.0.13-sequenceSinks :: (Traversable f, Monad m) => f (Sink i m r) -> Sink i m (f r)+sequenceSinks :: (Traversable f, Monad m) => f (ConduitT i Void m r) -> ConduitT i Void m (f r) sequenceSinks = getZipSink . sequenceA . fmap ZipSink  -- | The connect-and-resume operator. This does not close the @Conduit@, but@@ -1282,7 +1284,7 @@ -- @Conduit@. Same caveats of forced consumption apply. -- -- Since 1.1.5-fuseUpstream :: Monad m => ConduitT a b m r -> Conduit b m c -> ConduitT a c m r+fuseUpstream :: Monad m => ConduitT a b m r -> ConduitT b c m () -> ConduitT a c m r fuseUpstream up down = fmap fst (fuseBoth up down) {-# INLINE fuseUpstream #-} 

@@ -8,9 +8,6 @@ -- Higher-level functions to interact with the elements of a stream. Most of -- these are based on list functions. ----- For many purposes, it's recommended to use the conduit-combinators library,--- which provides a more complete set of functions.--- -- Note that these functions all deal with individual elements of a stream as a -- sort of \"black box\", where there is no introspection of the contained -- elements. Values such as @ByteString@ and @Text@ will likely need to be@@ -466,7 +463,7 @@ {- {-# RULES "conduit: source/map fusion .|" forall f src. src .| map f = mapFuseRight src f #-} -mapFuseRight :: Monad m => Source m a -> (a -> b) -> Source m b+mapFuseRight :: Monad m => ConduitT () a m () -> (a -> b) -> ConduitT () b m () mapFuseRight src f = CIC.mapOutput f src {-# INLINE mapFuseRight #-} -}

@@ -36,7 +36,6 @@ import Data.Textual.Encoding #endif import qualified Data.NonNull as NN-import System.IO.Silently (hCapture) import GHC.IO.Handle (hDuplicateTo) import qualified Data.ByteString as S import Data.ByteString.Builder (byteString, toLazyByteString)@@ -342,20 +341,6 @@         runConduitRes $ yield contents .| sinkIOHandle open         res <- S.readFile fp         res `shouldBe` contents-    prop "print" $ \vals -> do-        let expected = Prelude.unlines $ map showInt vals-        (actual, ()) <- hCapture [IO.stdout] $ runConduit $ yieldMany vals .| printC-        actual `shouldBe` expected-#ifndef WINDOWS-    prop "stdout" $ \ (vals :: [String]) -> do-        let expected = concat vals-        (actual, ()) <- hCapture [IO.stdout] $ runConduit $ yieldMany (map T.pack vals) .| encodeUtf8C .| stdoutC-        actual `shouldBe` expected-    prop "stderr" $ \ (vals :: [String]) -> do-        let expected = concat vals-        (actual, ()) <- hCapture [IO.stderr] $ runConduit $ yieldMany (map T.pack vals) .| encodeUtf8C .| stderrC-        actual `shouldBe` expected-#endif     prop "map" $ \input ->         runConduitPure (yieldMany input .| mapC succChar .| sinkList)         `shouldBe` map succChar input

@@ -264,7 +264,7 @@             x <- runConduitRes $                 CI.ConduitT                     ((CI.unConduitT (CL.sourceList [1..10]) CI.Done-                    CI.>+> CI.injectLeftovers ((`CI.unConduitT` CI.Done) $ CL.map (* 2))) >>=)+                    CI.>+> CI.injectLeftovers ((\c -> c `CI.unConduitT` CI.Done) $ CL.map (* 2))) >>=)                     .| CL.fold (+) 0             x `shouldBe` 2 * sum [1..10 :: Int] @@ -580,8 +580,8 @@             y <- runConduit $ CL.sourceList [1..10 :: Int] .| CL.fold (+) 0             x `shouldBe` y         it' "right identity" $ do-            x <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (`CI.unConduitT` CI.Done) $ CL.fold (+) 0) CI.>+> CI.idP-            y <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (`CI.unConduitT` CI.Done) $ CL.fold (+) 0)+            x <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (\c -> c `CI.unConduitT` CI.Done) $ CL.fold (+) 0) CI.>+> CI.idP+            y <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (\c -> c `CI.unConduitT` CI.Done) $ CL.fold (+) 0)             x `shouldBe` y      describe "generalizing" $ do@@ -630,7 +630,7 @@     describe "injectLeftovers" $ do         it "works" $ do             let src = mapM_ CI.yield [1..10 :: Int]-                conduit = CI.injectLeftovers $ (`CI.unConduitT` CI.Done) $ C.awaitForever $ \i -> do+                conduit = CI.injectLeftovers $ (\c -> c `CI.unConduitT` CI.Done) $ C.awaitForever $ \i -> do                     js <- CL.take 2                     mapM_ C.leftover $ reverse js                     C.yield i