@@ -1,6 +1,3 @@
1−{-# LANGUAGE UndecidableInstances #-}
2−{-# OPTIONS_GHC -Wno-orphans #-}
5-- Module : Streamly.Internal.Data.Stream.Serial
2-- Module : Streamly.Internal.Data.Stream.Serial
6-- Copyright : (c) 2017 Composewell Technologies
3-- Copyright : (c) 2017 Composewell Technologies
@@ -17,64 +14,36 @@
17module Streamly.Internal.Data.Stream.Serial
14module Streamly.Internal.Data.Stream.Serial
19 -- * Serial appending stream
16 -- * Serial appending stream
20− SerialT(..)
17+ SerialT
24 -- * Construction
21 -- * Construction
25− , cons
22+ , Stream.cons
26− , consM
23+ , Stream.consM
28 , unfoldrM
25 , unfoldrM
29 , fromList
26 , fromList
32 -- * Elimination
28 -- * Elimination
37 -- * Transformation
31 -- * Transformation
39− , mapM
33+ , Stream.mapM
45−import Control.Applicative (liftA2)
46−import Control.DeepSeq (NFData(..), NFData1(..))
47−import Control.Monad.Base (MonadBase(..), liftBaseDefault)
48−import Control.Monad.Catch (MonadThrow, throwM)
49−import Control.Monad.IO.Class (MonadIO(..))
50−import Control.Monad.Reader.Class (MonadReader(..))
51−import Control.Monad.State.Class (MonadState(..))
52−import Control.Monad.Trans.Class (MonadTrans(lift))
53−import Data.Foldable (Foldable(foldl'), fold)
54−import Data.Functor.Identity (Identity(..), runIdentity)
55−import Data.Maybe (fromMaybe)
56−import Data.Semigroup (Endo(..))
57#if __GLASGOW_HASKELL__ < 808
37#if __GLASGOW_HASKELL__ < 808
58import Data.Semigroup (Semigroup(..))
38import Data.Semigroup (Semigroup(..))
60−import GHC.Exts (IsList(..), IsString(..), oneShot)
40+import GHC.Exts (IsList(..))
62− ( Lexeme(Ident), lexP, parens, prec, readPrec, readListPrec
63− , readListPrecDefault)
64−import Streamly.Internal.BaseCompat ((#.))
65−import Streamly.Internal.Data.Fold.Type (Fold)
66−import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)
67−import Streamly.Internal.Data.Stream.StreamK.Type (Stream)
69−import qualified Streamly.Internal.Data.Stream.Common as P
70import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D
42import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D
71−import qualified Streamly.Internal.Data.Stream.StreamD.Transform as D
43+import qualified Streamly.Internal.Data.Stream as Stream
72−import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
73−import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
75−import Prelude hiding (map, mapM, repeat, filter)
45+import Prelude hiding (map, mapM, repeat)
77−#include "Instances.hs"
78#include "inline.hs"
47#include "inline.hs"
@@ -84,38 +53,7 @@ import Prelude hiding (map, mapM, repeat, filter)
85------------------------------------------------------------------------------
54------------------------------------------------------------------------------
87−-- | For 'SerialT' streams:
56+type SerialT = Stream.Stream
90−-- (<>) = 'Streamly.Prelude.serial' -- 'Semigroup'
91−-- (>>=) = flip . 'Streamly.Prelude.concatMapWith' 'Streamly.Prelude.serial' -- 'Monad'
94−-- A single 'Monad' bind behaves like a @for@ loop:
98−-- x <- Stream.fromList [1,2] -- foreach x in stream
103−-- Nested monad binds behave like nested @for@ loops:
106−-- Stream.toList $ do
107−-- x <- Stream.fromList [1,2] -- foreach x in stream
108−-- y <- Stream.fromList [3,4] -- foreach y in stream
111−-- [(1,3),(1,4),(2,3),(2,4)]
113−-- /Since: 0.2.0 ("Streamly")/
116−newtype SerialT m a = SerialT {getSerialT :: Stream m a}
117− -- XXX when deriving do we inherit an INLINE?
118− deriving (Semigroup, Monoid, MonadTrans)
120-- | A serial IO stream of elements of type @a@. See 'SerialT' documentation
58-- | A serial IO stream of elements of type @a@. See 'SerialT' documentation
121-- for more details.
59-- for more details.
@@ -129,21 +67,12 @@ type Serial = SerialT IO
129-- Generation
67-- Generation
130------------------------------------------------------------------------------
68------------------------------------------------------------------------------
133−cons :: a -> SerialT m a -> SerialT m a
134−cons x (SerialT ms) = SerialT $ K.cons x ms
137−{-# SPECIALIZE consM :: IO a -> SerialT IO a -> SerialT IO a #-}
138−consM :: Monad m => m a -> SerialT m a -> SerialT m a
139−consM m (SerialT ms) = SerialT $ K.consM m ms
142-- Generate an infinite stream by repeating a pure value.
71-- Generate an infinite stream by repeating a pure value.
144{-# INLINE_NORMAL repeat #-}
73{-# INLINE_NORMAL repeat #-}
145repeat :: Monad m => a -> SerialT m a
74repeat :: Monad m => a -> SerialT m a
146−repeat = SerialT . D.toStreamK . D.repeat
75+repeat = Stream.fromStreamD . D.repeat
148------------------------------------------------------------------------------
77------------------------------------------------------------------------------
149-- Combining
78-- Combining
@@ -153,37 +82,6 @@ repeat = SerialT . D.toStreamK . D.repeat
153serial :: SerialT m a -> SerialT m a -> SerialT m a
82serial :: SerialT m a -> SerialT m a -> SerialT m a
154serial = (<>)
83serial = (<>)
156−------------------------------------------------------------------------------
158−------------------------------------------------------------------------------
160−instance Monad m => Monad (SerialT m) where
163− -- Benchmarks better with StreamD bind and pure:
164− -- toList, filterAllout, *>, *<, >> (~2x)
166− -- pure = SerialT . D.fromStreamD . D.fromPure
167− -- m >>= f = D.fromStreamD $ D.concatMap (D.toStreamD . f) (D.toStreamD m)
169− -- Benchmarks better with CPS bind and pure:
170− -- Prime sieve (25x)
171− -- n binds, breakAfterSome, filterAllIn, state transformer (~2x)
173− {-# INLINE (>>=) #-}
174− (>>=) (SerialT m) f = SerialT $ K.bindWith K.serial m (getSerialT . f)
179−------------------------------------------------------------------------------
181−------------------------------------------------------------------------------
184−mapM :: Monad m => (a -> m b) -> SerialT m a -> SerialT m b
185−mapM f (SerialT m) = SerialT $ D.toStreamK $ D.mapM f $ D.fromStreamK m
189-- map = fmap
87-- map = fmap
@@ -199,120 +97,7 @@ mapM f (SerialT m) = SerialT $ D.toStreamK $ D.mapM f $ D.fromStreamK m
199-- @since 0.4.0
97-- @since 0.4.0
200{-# INLINE map #-}
98{-# INLINE map #-}
201map :: Monad m => (a -> b) -> SerialT m a -> SerialT m b
99map :: Monad m => (a -> b) -> SerialT m a -> SerialT m b
202−map f = mapM (return . f)
100+map f = Stream.mapM (return . f)
204−{-# INLINE apSerial #-}
205−apSerial :: Monad m => SerialT m (a -> b) -> SerialT m a -> SerialT m b
206−apSerial (SerialT m1) (SerialT m2) =
207− SerialT $ D.toStreamK $ D.fromStreamK m1 <*> D.fromStreamK m2
209−{-# INLINE apSequence #-}
210−apSequence :: Monad m => SerialT m a -> SerialT m b -> SerialT m b
211−apSequence (SerialT m1) (SerialT m2) =
212− SerialT $ D.toStreamK $ D.fromStreamK m1 *> D.fromStreamK m2
214−{-# INLINE apDiscardSnd #-}
215−apDiscardSnd :: Monad m => SerialT m a -> SerialT m b -> SerialT m a
216−apDiscardSnd (SerialT m1) (SerialT m2) =
217− SerialT $ D.toStreamK $ D.fromStreamK m1 <* D.fromStreamK m2
219−-- Note: we need to define all the typeclass operations because we want to
221−instance Monad m => Applicative (SerialT m) where
223− pure = SerialT . K.fromPure
225− {-# INLINE (<*>) #-}
227− -- (<*>) = K.apSerial
229− {-# INLINE liftA2 #-}
230− liftA2 f x = (<*>) (fmap f x)
234− -- (*>) = K.apSerialDiscardFst
238− -- (<*) = K.apSerialDiscardSnd
240−MONAD_COMMON_INSTANCES(SerialT,)
241−LIST_INSTANCES(SerialT)
242−NFDATA1_INSTANCE(SerialT)
243−FOLDABLE_INSTANCE(SerialT)
244−TRAVERSABLE_INSTANCE(SerialT)
246−{-# INLINE toStreamD #-}
247−toStreamD :: Applicative m => SerialT m a -> D.Stream m a
248−toStreamD (SerialT m) = D.fromStreamK m
250−{-# INLINE fromStreamD #-}
251−fromStreamD :: Monad m => D.Stream m a -> SerialT m a
252−fromStreamD m = SerialT $ D.toStreamK m
254−-- XXX We should only export generation and combinators from this module.
256−-- | Include only those elements that pass a predicate.
258−{-# INLINE filter #-}
259−filter :: Monad m => (a -> Bool) -> SerialT m a -> SerialT m a
260−filter p = fromStreamD . D.filter p . toStreamD
262−-- | Use a filtering fold on a stream.
264−-- > Stream.sum $ Stream.foldFilter (Fold.satisfy (> 5)) $ Stream.fromList [1..10]
267−{-# INLINE foldFilter #-}
268−foldFilter :: Monad m => Fold m a (Maybe b) -> SerialT m a -> SerialT m b
269−foldFilter p = fromStreamD . D.foldFilter p . toStreamD
271−-- XXX Renamed to foldWith because SerialT has a Foldable instance having
274−-- | Fold a stream using the supplied left 'Fold' and reducing the resulting
275−-- expression strictly at each step. The behavior is similar to 'foldl''. A
276−-- 'Fold' can terminate early without consuming the full stream. See the
277−-- documentation of individual 'Fold's for termination behavior.
279−-- >>> Stream.foldWith Fold.sum (Stream.enumerateFromTo 1 100)
282−-- Folds never fail, therefore, they produce a default value even when no input
283−-- is provided. It means we can always fold an empty stream and get a valid
284−-- result. For example:
286−-- >>> Stream.foldWith Fold.sum Stream.nil
289−-- However, 'foldMany' on an empty stream results in an empty stream.
290−-- Therefore, @Stream.foldWith f@ is not the same as @Stream.head . Stream.foldMany
293−-- @foldWith f = Stream.parse (Parser.fromFold f)@
296−{-# INLINE foldWith #-}
297−foldWith :: Monad m => Fold m a b -> SerialT m a -> m b
298−foldWith fld m = D.fold fld $ toStreamD m
300−-- XXX Renamed to "list" because fromList is present in IsList instance.
304−-- fromList = 'Prelude.foldr' 'K.cons' 'K.nil'
307−-- Construct a stream from a list of pure values. This is more efficient than
308−-- 'K.fromFoldable' for serial streams.
311−{-# INLINE_EARLY list #-}
312−list :: Monad m => [a] -> SerialT m a
313−list = fromStreamD . D.fromList
314−{-# RULES "list fallback to StreamK" [1]
315− forall a. D.toStreamK (D.fromList a) = K.fromFoldable a #-}
317------------------------------------------------------------------------------
102------------------------------------------------------------------------------
318-- Construction
103-- Construction
@@ -341,10 +126,4 @@ list = fromStreamD . D.fromList
342{-# INLINE unfoldrM #-}
127{-# INLINE unfoldrM #-}
343unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> SerialT m a
128unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> SerialT m a
344−unfoldrM step seed = SerialT $ D.toStreamK (D.unfoldrM step seed)
129+unfoldrM step seed = Stream.fromStreamD (D.unfoldrM step seed)
346−{-# INLINE_EARLY drain #-}
347−drain :: Monad m => SerialT m a -> m ()
348−drain (SerialT m) = D.drain $ D.fromStreamK m
349−{-# RULES "drain fallback to CPS" [1]
350− forall a. D.drain (D.fromStreamK a) = K.drain a #-}