conduit 0.2.0 → 0.2.1

raw patch · 5 files changed

+97/−3 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Data/Conduit/List.hs +2/−2
• Data/Conduit/Util/Conduit.hs +38/−0
• Data/Conduit/Util/Source.hs +27/−0
• conduit.cabal +1/−1
• test/main.hs +29/−0

@@ -217,7 +217,7 @@     push = fmap (Producing conduit) . lift . f     close = return [] --- | 'concatMap' with accumerator.+-- | 'concatMap' with an accumulator. -- -- Since 0.2.0 concatMapAccum :: Resource m => (a -> accum -> (accum, [b])) -> accum -> Conduit a m b@@ -227,7 +227,7 @@                        in return $ StateProducing state' result     close _ = return [] --- | 'concatMapM' with accumerator.+-- | 'concatMapM' with an accumulator. -- -- Since 0.2.0 concatMapAccumM :: Resource m => (a -> accum -> m (accum, [b])) -> accum -> Conduit a m b

@@ -13,9 +13,11 @@       -- *** Sequencing     , SequencedSink     , sequenceSink+    , sequence     , SequencedSinkResponse (..)     ) where +import Prelude hiding (sequence) import Control.Monad.Trans.Resource import Control.Monad.Trans.Class import Data.Conduit.Types.Conduit@@ -206,3 +208,39 @@         Emit _ os -> return os         Stop -> return []         StartConduit c -> conduitClose c++-- | Specialised version of 'sequenceSink'+--+-- Note that this function will return an infinite stream if provided a+-- @SinkNoData@ constructor. In other words, you probably don\'t want to do+-- @sequence . return@.+--+-- Since 0.2.1+sequence :: Resource m => Sink input m output -> Conduit input m output+sequence (SinkData spush sclose) = Conduit (push spush) (close sclose)+  where+    push spush' input = do+        res <- spush' input+        case res of+            Processing spush'' sclose'' ->+                return $ Producing (Conduit (push spush'') (close sclose'')) []+            Done Nothing output ->+                return $ Producing (Conduit (push spush) (close sclose)) [output]+            Done (Just input') output -> do+                res' <- push spush input'+                case res' of+                    Producing conduit' output' ->+                        return $ Producing conduit' (output:output')+                    Finished _ _ -> error "impossible [sequence]"+    close sclose' = fmap (:[]) sclose'++sequence (SinkNoData output) = Conduit+    { conduitPush = \input -> return $ Finished (Just input) (repeat output)+    , conduitClose = return $ repeat output+    }+sequence (SinkLift msink) = Conduit+    { conduitPush = \input -> do+        sink <- msink+        conduitPush (sequence sink) input+    , conduitClose = return []+    }

@@ -7,6 +7,7 @@ -- on the base types. module Data.Conduit.Util.Source     ( sourceState+    , sourceStateIO     , SourceStateResult (..)     , sourceIO     , SourceIOResult (..)@@ -74,6 +75,32 @@                 release key                 return Closed             IOOpen val -> return $ Open (src key state) val++-- | A combination of 'sourceIO' and 'sourceState'.+--+-- Since 0.2.1+sourceStateIO :: ResourceIO m+              => IO state -- ^ resource and/or state allocation+              -> (state -> IO ()) -- ^ resource and/or state cleanup+              -> (state -> m (SourceStateResult state output)) -- ^ Pull function. Note that this need not explicitly perform any cleanup.+              -> Source m output+sourceStateIO alloc cleanup pull0 =+    Source+        { sourcePull = do+            (key, state) <- withIO alloc cleanup+            pull key state+        , sourceClose = return ()+        }+  where+    src key state = Source (pull key state) (release key)++    pull key state = do+        res <- lift $ pull0 state+        case res of+            StateClosed -> do+                release key+                return Closed+            StateOpen state' val -> return $ Open (src key state') val  -- | Transform the monad a 'Source' lives in. --

@@ -1,5 +1,5 @@ Name:                conduit-Version:             0.2.0+Version:             0.2.1 Synopsis:            Streaming data processing library. Description: 	Conduits are an approach to the streaming data problem. It is meant as an alternative to enumerators\/iterators, hoping to address the same issues with different trade-offs based on real-world experience with enumerators. For more information, see <http://www.yesodweb.com/book/conduit>.

@@ -11,6 +11,7 @@ import qualified Data.Conduit.Binary as CB import qualified Data.Conduit.Text as CT import Data.Conduit (runResourceT)+import Data.Maybe (fromMaybe) import qualified Data.List as DL import Control.Monad.ST (runST) import Data.Monoid@@ -241,6 +242,34 @@                             )             nums <- CLazy.lazyConsume $ mconcat $ map incr [1..10]             liftIO $ nums @?= [1..10]++    describe "sequence" $ do+        it "simple sink" $ do+            let sumSink :: C.Resource m => C.Sink Int m Int+                sumSink = do+                    ma <- CL.head+                    case ma of+                        Nothing -> return 0+                        Just a  -> (+a) . fromMaybe 0 <$> CL.head++            res <- runResourceT $ CL.sourceList [1..11]+                             C.$= C.sequence sumSink+                             C.$$ CL.consume+            res @?= [3, 7, 11, 15, 19, 11]++        it "sink with unpull behaviour" $ do+            let sumSink :: C.Resource m => C.Sink Int m Int+                sumSink = do+                    ma <- CL.head+                    case ma of+                        Nothing -> return 0+                        Just a  -> (+a) . fromMaybe 0 <$> CL.peek++            res <- runResourceT $ CL.sourceList [1..11]+                             C.$= C.sequence sumSink+                             C.$$ CL.consume+            res @?= [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 11]+                 describe "sequenceSink" $ do         it "simple sink" $ do