cd29e5e · streamly · git.iko.soy

git.iko.soy/streamly

Add toStreamK and toStreamKRev

commitcd29e5e2df06f09536a0f463f5e3b2f04c43058c authorHarendra Kumar <harendra@composewell.com> dateThu 7 Oct 2021, 16:34 (5 years ago) parent0f3e545

3 files changed+50−9

compare with master

unifiedsplit

benchmark/Streamly/Benchmark/Data/Fold.hs+7−2 src/Streamly/Internal/Data/Fold.hs+8−7 src/Streamly/Internal/Data/Fold/Type.hs+35

benchmark/Streamly/Benchmark/Data/Fold.hs+7−2

@@ -10,6 +10,7 @@

1010module Main (main) where

1111

1212import Control.DeepSeq (NFData(..))

13+import Data.Functor.Identity (Identity)

1314import Data.Map.Strict (Map)

1415import Data.Monoid (Last(..), Sum(..))

1516import System.Random (randomRIO)

@@ -352,8 +353,12 @@ o_n_heap_serial value =

352353 [

353354 benchIOSink value "toList" (S.fold FL.toList)

354355 , benchIOSink value "toListRev" (S.fold FL.toListRev)

355− , benchIOSink value "toStream" (S.fold FL.toStream)

356− , benchIOSink value "toStreamRev" (S.fold FL.toStreamRev)

356+ , benchIOSink value "toStream"

357+ (S.fold FL.toStream

358+ :: SerialT IO a -> IO (SerialT Identity a))

359+ , benchIOSink value "toStreamRev"

360+ (S.fold FL.toStreamRev

361+ :: SerialT IO a -> IO (SerialT Identity a))

357362 ]

358363 ]

359364

src/Streamly/Internal/Data/Fold.hs+8−7

@@ -256,7 +256,6 @@ import Streamly.Internal.Data.Stream.Serial (SerialT(..))

256256import qualified Data.Map.Strict as Map

257257import qualified Streamly.Internal.Data.Pipe.Type as Pipe

258258-- import qualified Streamly.Internal.Data.Stream.IsStream.Enumeration as Stream

259−import qualified Streamly.Internal.Data.Stream.StreamK.Type as K

260259import qualified Prelude

261260

262261import Prelude hiding

@@ -275,7 +274,9 @@ import Streamly.Internal.Data.Fold.Type

275274-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream (parse, foldMany)

276275-- >>> import qualified Streamly.Data.Fold as Fold

277276-- >>> import qualified Streamly.Internal.Data.Fold as Fold

277+-- >>> import qualified Streamly.Internal.Data.Fold.Type as Fold

278278-- >>> import qualified Streamly.Internal.Data.Parser as Parser

279+-- >>> import Streamly.Internal.Data.Stream.Serial (SerialT(..))

279280-- >>> import Data.IORef (newIORef, readIORef, writeIORef)

280281

281282------------------------------------------------------------------------------

@@ -1694,12 +1695,12 @@ chunksBetween _low _high _f1 _f2 = undefined

16941695-- /Warning!/ working on large streams accumulated as buffers in memory could

16951696-- be very inefficient, consider using "Streamly.Data.Array" instead.

16961697--

1697−-- > toStream = foldr K.cons K.nil

1698+-- >>> toStream = fmap SerialT Fold.toStreamK

16981699--

16991700-- /Pre-release/

17001701{-# INLINE toStream #-}

1701−toStream :: Monad m => Fold m a (SerialT Identity a)

1702−toStream = fmap SerialT $ foldr K.cons K.nil

1702+toStream :: Monad m => Fold m a (SerialT n a)

1703+toStream = fmap SerialT toStreamK

17031704

17041705-- This is more efficient than 'toStream'. toStream is exactly the same as

17051706-- reversing the stream after toStreamRev.

@@ -1707,7 +1708,7 @@ toStream = fmap SerialT $ foldr K.cons K.nil

17071708-- | Buffers the input stream to a pure stream in the reverse order of the

17081709-- input.

17091710--

1710−-- > toStreamRev = foldl' (flip K.cons) K.nil

1711+-- >>> toStreamRev = fmap SerialT Fold.toStreamKRev

17111712--

17121713-- /Warning!/ working on large streams accumulated as buffers in memory could

17131714-- be very inefficient, consider using "Streamly.Data.Array" instead.

@@ -1716,5 +1717,5 @@ toStream = fmap SerialT $ foldr K.cons K.nil

17161717

17171718-- xn : ... : x2 : x1 : []

17181719{-# INLINABLE toStreamRev #-}

1719−toStreamRev :: Monad m => Fold m a (SerialT Identity a)

1720−toStreamRev = fmap SerialT $ foldl' (flip K.cons) K.nil

1720+toStreamRev :: Monad m => Fold m a (SerialT n a)

1721+toStreamRev = fmap SerialT toStreamKRev

src/Streamly/Internal/Data/Fold/Type.hs+35

@@ -211,6 +211,8 @@ module Streamly.Internal.Data.Fold.Type

211211 , fromEffect

212212 , drain

213213 , toList

214+ , toStreamK

215+ , toStreamKRev

214216

215217 -- * Combinators

216218

@@ -270,15 +272,23 @@ import Fusion.Plugin.Types (Fuse(..))

270272import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)

271273import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))

272274

275+import qualified Streamly.Internal.Data.Stream.StreamK.Type as K

276+

273277import Prelude hiding (concatMap, filter, foldr, map, take)

274278

275279-- $setup

276280-- >>> :m

277281-- >>> :set -XFlexibleContexts

282+-- >>> import Streamly.Data.Fold (Fold)

278283-- >>> import Prelude hiding (concatMap, filter, map)

284+-- >>> import Streamly.Prelude (SerialT)

285+-- >>> import qualified Data.Foldable as Foldable

279286-- >>> import qualified Streamly.Prelude as Stream

280287-- >>> import qualified Streamly.Data.Fold as Fold

281288-- >>> import qualified Streamly.Internal.Data.Fold as Fold

289+-- >>> import qualified Streamly.Internal.Data.Fold.Type as Fold

290+-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream

291+-- >>> import qualified Streamly.Internal.Data.Stream.StreamK as StreamK

282292

283293------------------------------------------------------------------------------

284294-- Step of a fold

@@ -603,6 +613,31 @@ drain = foldl' (\_ _ -> ()) ()

603613toList :: Monad m => Fold m a [a]

604614toList = foldr (:) []

605615

616+-- | Buffers the input stream to a pure stream in the reverse order of the

617+-- input.

618+--

619+-- >>> toStreamKRev = Foldable.foldl' (flip StreamK.cons) StreamK.nil

620+--

621+-- This is more efficient than 'toStreamK'. toStreamK has exactly the same

622+-- performance as reversing the stream after toStreamKRev.

623+--

624+-- /Pre-release/

625+

626+-- xn : ... : x2 : x1 : []

627+{-# INLINABLE toStreamKRev #-}

628+toStreamKRev :: Monad m => Fold m a (K.Stream n a)

629+toStreamKRev = foldl' (flip K.cons) K.nil

630+

631+-- | A fold that buffers its input to a pure stream.

632+--

633+-- >>> toStreamK = foldr StreamK.cons StreamK.nil

634+-- >>> toStreamK = fmap StreamK.reverse Fold.toStreamKRev

635+--

636+-- /Internal/

637+{-# INLINE toStreamK #-}

638+toStreamK :: Monad m => Fold m a (K.Stream n a)

639+toStreamK = foldr K.cons K.nil

640+

606641------------------------------------------------------------------------------

607642-- Instances

608643------------------------------------------------------------------------------