cd29e5e · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Add toStreamK and toStreamKRev

cd29e5eHarendra Kumar5 years ago

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

compare with master

unifiedsplit

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

10module Main (main) where

12import Control.DeepSeq (NFData(..))

13+import Data.Functor.Identity (Identity)

13import Data.Map.Strict (Map)

14import Data.Map.Strict (Map)

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

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

15import System.Random (randomRIO)

16import System.Random (randomRIO)

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

352 [

353 [

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

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

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

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

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

356+ , benchIOSink value "toStream"

357+ (S.fold FL.toStream

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

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

359+ , benchIOSink value "toStreamRev"

360+ (S.fold FL.toStreamRev

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

357 ]

362 ]

358 ]

363 ]

359

364

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

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

256import qualified Data.Map.Strict as Map

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

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

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

260import qualified Prelude

259import qualified Prelude

261

260

262import Prelude hiding

261import Prelude hiding

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

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

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

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

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

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

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

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

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

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

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

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

280

281

281------------------------------------------------------------------------------

282------------------------------------------------------------------------------

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

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

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

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

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

1696--

1697--

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

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

1698--

1699--

1699-- /Pre-release/

1700-- /Pre-release/

1700{-# INLINE toStream #-}

1701{-# INLINE toStream #-}

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

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

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

1703+toStream = fmap SerialT toStreamK

1703

1704

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

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

1705-- reversing the stream after toStreamRev.

1706-- reversing the stream after toStreamRev.

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

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

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

1708-- input.

1709-- input.

1709--

1710--

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

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

1711--

1712--

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

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

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

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

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

1716

1717

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

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

1718{-# INLINABLE toStreamRev #-}

1719{-# INLINABLE toStreamRev #-}

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

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

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

1721+toStreamRev = fmap SerialT toStreamKRev

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

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

211 , fromEffect

212 , drain

213 , toList

214+ , toStreamK

215+ , toStreamKRev

214

216

215 -- * Combinators

217 -- * Combinators

216

218

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

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

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

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

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

272

274

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

276+

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

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

274

278

275-- $setup

279-- $setup

276-- >>> :m

280-- >>> :m

277-- >>> :set -XFlexibleContexts

281-- >>> :set -XFlexibleContexts

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

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

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

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

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

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

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

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

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

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

288-- >>> 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

282

292

283------------------------------------------------------------------------------

293------------------------------------------------------------------------------

284-- Step of a fold

294-- Step of a fold

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

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

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

604toList = foldr (:) []

614toList = foldr (:) []

605

615

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+

606------------------------------------------------------------------------------

641------------------------------------------------------------------------------

607-- Instances

642-- Instances

608------------------------------------------------------------------------------

643------------------------------------------------------------------------------