430f06d · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Add toList fold to Data.Stream module

430f06dHarendra Kumar4 years ago

core/src/Streamly/Data/Stream.hs+12−5

compare with master

unifiedsplit

@@ -232,7 +232,7 @@ module Streamly.Data.Stream

232 -- ending in the general shape @Stream m a -> m (b, Stream m a)@

233 , uncons

234

235− -- ** Folding

235+ -- ** Strict Left Folds

236 -- XXX Need to have a general parse operation here which can be used to

237 -- express all others.

238 , fold -- XXX rename to run? We can have a Stream.run and Fold.run.

@@ -248,15 +248,22 @@ module Streamly.Data.Stream

248 , parse

249 -- , parseBreak

250

251− -- -- ** Lazy Right Folds

251+ -- ** Lazy Right Folds

252− -- Consuming a stream to build a right associated expression, suitable

252+ -- | Consuming a stream to build a right associated expression, suitable

253 -- for lazy evaluation. Evaluation of the input happens when the output of

254 -- the fold is evaluated, the fold output is a lazy thunk.

255 --

256 -- This is suitable for stream transformation operations, for example,

257 -- operations like mapping a function over the stream.

258− -- , foldrM

258+ , foldrM

259− -- , foldr

259+ , foldr

260+

261+ -- ** Specific Folds

262+ -- | Usually you can use the folds in "Streamly.Data.Fold". However, some

263+ -- folds that may be commonly used or may have an edge in performance in

264+ -- some cases are provided here.

265+ -- , drain

266+ , toList

260

267

261 -- * Mapping

268 -- * Mapping

262 -- | Stateless one-to-one transformations. Use 'fmap' for mapping a pure

269 -- | Stateless one-to-one transformations. Use 'fmap' for mapping a pure

core/src/Streamly/Internal/Data/Stream/StreamD/Type.hs+49−1

@@ -677,7 +677,16 @@ foldl' fstep begin = foldlM' (\b a -> return (fstep b a)) (return begin)

677-- Special folds

678------------------------------------------------------------------------------

679

680−-- | Run a streaming composition, discard the results.

680+-- >>> drain = mapM_ (\_ -> return ())

681+

682+-- |

683+-- Definitions:

684+--

685+-- >>> drain = Stream.fold Fold.drain

686+-- >>> drain = Stream.foldrM (\_ xs -> xs) (return ())

687+--

688+-- Run a stream, discarding the results.

689+--

681{-# INLINE_LATE drain #-}

690{-# INLINE_LATE drain #-}

682drain :: Monad m => Stream m a -> m ()

691drain :: Monad m => Stream m a -> m ()

683-- drain = foldrM (\_ xs -> xs) (return ())

692-- drain = foldrM (\_ xs -> xs) (return ())

@@ -694,6 +703,45 @@ drain (Stream step state) = go SPEC state

694-- To Containers

703-- To Containers

695------------------------------------------------------------------------------

704------------------------------------------------------------------------------

696

705

706+-- This toList impl is faster (30% on streaming-benchmarks) than the

707+-- corresponding left fold. The left fold retains an additional argument in the

708+-- recursive loop.

709+--

710+-- Core for the right fold loop:

711+--

712+-- main_$s$wgo1

713+-- = \ sc_s3e6 sc1_s3e5 ->

714+-- case ># sc1_s3e5 100000# of {

715+-- __DEFAULT ->

716+-- case main_$s$wgo1 sc_s3e6 (+# sc1_s3e5 1#) of

717+--

718+-- Core for the left fold loop:

719+--

720+-- main_$s$wgo1

721+-- = \ sc_s3oT sc1_s3oS sc2_s3oR ->

722+-- case sc2_s3oR of fs2_a2lw { __DEFAULT ->

723+-- case ># sc1_s3oS 100000# of {

724+-- __DEFAULT ->

725+-- let { wild_a2og = I# sc1_s3oS } in

726+-- main_$s$wgo1

727+-- sc_s3oT (+# sc1_s3oS 1#) (\ x_X9 -> fs2_a2lw (: wild_a2og x_X9));

728+

729+-- |

730+-- Definitions:

731+--

732+-- >>> toList = Stream.foldr (:) []

733+-- >>> toList = Stream.fold Fold.toList

734+--

735+-- Convert a stream into a list in the underlying monad. The list can be

736+-- consumed lazily in a lazy monad (e.g. 'Identity'). In a strict monad (e.g.

737+-- IO) the whole list is generated and buffered before it can be consumed.

738+--

739+-- /Warning!/ working on large lists accumulated as buffers in memory could be

740+-- very inefficient, consider using "Streamly.Data.Array" instead.

741+--

742+-- Note that this could a bit more efficient compared to @Stream.fold

743+-- Fold.toList@, and it can fuse with pure list consumers.

744+--

697{-# INLINE_NORMAL toList #-}

745{-# INLINE_NORMAL toList #-}

698toList :: Monad m => Stream m a -> m [a]

746toList :: Monad m => Stream m a -> m [a]

699toList = Streamly.Internal.Data.Stream.StreamD.Type.foldr (:) []

747toList = Streamly.Internal.Data.Stream.StreamD.Type.foldr (:) []