50a3012 · streamly · git.iko.soy

core/src/Streamly/Internal/Data/Stream/Eliminate.hs−14

compare with master

unifiedsplit

@@ -56,7 +56,6 @@ module Streamly.Internal.Data.Stream.Eliminate

56 -- * Left Folds

57 -- Lazy left folds are useful only for reversing the stream

58 , foldlS

59− , foldlT

60

59

61 -- * Multi-Stream folds

60 -- * Multi-Stream folds

62 -- Full equivalence

61 -- Full equivalence

@@ -80,7 +79,6 @@ where

80

79

81import Control.Monad.Catch (MonadThrow)

80import Control.Monad.Catch (MonadThrow)

82import Control.Monad.IO.Class (MonadIO(..))

81import Control.Monad.IO.Class (MonadIO(..))

83−import Control.Monad.Trans.Class (MonadTrans(..))

84import Streamly.Internal.Data.Parser (Parser (..))

82import Streamly.Internal.Data.Parser (Parser (..))

85import Streamly.Internal.Data.Unboxed (Unbox)

83import Streamly.Internal.Data.Unboxed (Unbox)

86

84

@@ -209,18 +207,6 @@ foldlS f z =

209 (toStreamK z)

207 (toStreamK z)

210 . toStreamK

208 . toStreamK

211

209

212−-- | Lazy left fold to a transformer monad.

213−--

214−-- For example, to reverse a stream:

215−--

216−-- >>> input = Stream.fromList [1..5] :: Stream IO Int

217−-- >>> rev = Stream.fold Fold.toList $ Stream.foldlT (flip Stream.cons) Stream.nil input

218−--

219−{-# INLINE foldlT #-}

220−foldlT :: (Monad m, Monad (s m), MonadTrans s)

221− => (s m b -> a -> s m b) -> s m b -> Stream m a -> s m b

222−foldlT f z s = D.foldlT f z (toStreamD s)

223−

224------------------------------------------------------------------------------

210------------------------------------------------------------------------------

225-- Running a Parser

211-- Running a Parser

226------------------------------------------------------------------------------

212------------------------------------------------------------------------------

core/src/Streamly/Internal/Data/Stream/Transform.hs+2−2

@@ -220,9 +220,9 @@ transform pipe xs = fromStreamD $ D.transform pipe (toStreamD xs)

220--

221-- Find if any element in the stream is 'True':

222--

223−-- >>> step x xs = if odd x then return True else xs

223+-- >>> step x xs = if odd x then Stream.fromPure True else xs

224-- >>> input = Stream.fromList (2:4:5:undefined) :: Stream IO Int

225−-- >>> Stream.fold Fold.toList $ Stream.foldrS step (return False) input

225+-- >>> Stream.fold Fold.toList $ Stream.foldrS step (Stream.fromPure False) input

226-- [True]

227--

228-- Map (+2) on odd elements and filter out the even elements:

core/src/Streamly/Internal/Data/Stream/Transformer.hs+9−1

@@ -8,7 +8,8 @@

8

9module Streamly.Internal.Data.Stream.Transformer

10 (

11+ foldlT

11− foldrT

12+ , foldrT

12

13

13 , liftInner

14 , liftInner

14 , usingReaderT

15 , usingReaderT

@@ -32,6 +33,13 @@ import qualified Streamly.Internal.Data.Stream.StreamD.Transformer as D

32-- >>> import Control.Monad.Trans.Identity (runIdentityT)

33-- >>> import Control.Monad.Trans.Identity (runIdentityT)

33-- >>> import qualified Streamly.Internal.Data.Stream as Stream

34-- >>> import qualified Streamly.Internal.Data.Stream as Stream

34

35

36+-- | Lazy left fold to a transformer monad.

37+--

38+{-# INLINE foldlT #-}

39+foldlT :: (Monad m, Monad (s m), MonadTrans s)

40+ => (s m b -> a -> s m b) -> s m b -> Stream m a -> s m b

41+foldlT f z s = D.foldlT f z (toStreamD s)

42+

35-- | Right fold to a transformer monad. This is the most general right fold

43-- | Right fold to a transformer monad. This is the most general right fold

36-- function. 'foldrS' is a special case of 'foldrT', however 'foldrS'

44-- function. 'foldrS' is a special case of 'foldrT', however 'foldrS'

37-- implementation can be more efficient:

45-- implementation can be more efficient: