3157

pending completion

Build # 3157

Build Type

Pull #657

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/composewell/streamly/commit/<a class=hub.com/composewell/streamly/commit/8df4d7a6c3618ed1d1e702bad1f449710c7e9a94">8df4d7a6c<a href="https://github.com/composewell/streamly/commit/8df4d7a6c3618ed1d1e702bad1f449710c7e9a94">">Merge </a><a class="double-link" href="https://github.com/composewell/streamly/commit/<a class="double-link" href="https://github.com/composewell/streamly/commit/9ecd3bc29da40da032a6f80c82e648f05d85ee37">9ecd3bc29</a>">9ecd3bc29</a><a href="https://github.com/composewell/streamly/commit/8df4d7a6c3618ed1d1e702bad1f449710c7e9a94"> into bf91f48e9">bf91f48e9</a>

Pull Request Pull Request #657: Move combinators from Streamly module to other modules.

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

3481 of 9369 relevant lines covered (37.15%)

0.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.84

/src/Streamly/Internal/Data/Stream/Prelude.hs

{-# OPTIONS_GHC -Wno-orphans #-}

#include "inline.hs"

-- |
-- Module      : Streamly.Internal.Data.Stream.Prelude
-- Copyright   : (c) 2017 Harendra Kumar
--
-- License     : BSD3
-- Maintainer  : streamly@composewell.com
-- Stability   : experimental
-- Portability : GHC
--
--
module Streamly.Internal.Data.Stream.Prelude
    (
    -- * Stream Conversion
      fromStreamS
    , toStreamS

    -- * Running Effects
    , drain

    -- * Conversion operations
    , fromList
    , toList

    -- * Fold operations
    , foldrM
    , foldrMx
    , foldr

    , foldlx'
    , foldlMx'
    , foldl'
    , runFold
    , parselMx'

    -- Lazy left folds are useful only for reversing the stream
    , foldlS
    , foldlT

    , scanlx'
    , scanlMx'
    , postscanlx'
    , postscanlMx'

    -- * Zip style operations
    , eqBy
    , cmpBy

    -- * Foldable instance
    , minimum
    , maximum

    -- * Nesting
    , K.concatMapBy
    , K.concatMap

    -- * Fold Utilities
    , concatFoldableWith
    , concatMapFoldableWith
    , concatForFoldableWith
    )
where

import Control.Monad.Catch (MonadThrow)
import Control.Monad.Trans.Class (MonadTrans(..))
import Prelude hiding (foldr, minimum, maximum)
import qualified Prelude

import Streamly.Internal.Data.Fold.Types (Fold (..))
import Streamly.Internal.Data.Parser (Step)

#ifdef USE_STREAMK_ONLY
import qualified Streamly.Internal.Data.Stream.StreamK as S
#else
import qualified Streamly.Internal.Data.Stream.StreamD as S
#endif

import Streamly.Internal.Data.Stream.StreamK (IsStream(..))
import qualified Streamly.Internal.Data.Stream.StreamK as K
import qualified Streamly.Internal.Data.Stream.StreamD as D

------------------------------------------------------------------------------
-- Conversion to and from direct style stream
------------------------------------------------------------------------------

-- These definitions are dependent on what is imported as S
{-# INLINE fromStreamS #-}
fromStreamS :: (IsStream t, Monad m) => S.Stream m a -> t m a
fromStreamS = fromStream . S.toStreamK

{-# INLINE toStreamS #-}
toStreamS :: (IsStream t, Monad m) => t m a -> S.Stream m a
toStreamS = S.fromStreamK . toStream

------------------------------------------------------------------------------
-- Conversions
------------------------------------------------------------------------------

{-# INLINE_EARLY drain #-}
drain :: (IsStream t, Monad m) => t m a -> m ()
drain m = D.drain $ D.fromStreamK (toStream m)
{-# RULES "drain fallback to CPS" [1]
    forall a. D.drain (D.fromStreamK a) = K.drain a #-}

------------------------------------------------------------------------------
-- Conversions
------------------------------------------------------------------------------

-- |
-- @
-- fromList = 'Prelude.foldr' 'K.cons' 'K.nil'
-- @
--
-- Construct a stream from a list of pure values. This is more efficient than
-- 'K.fromFoldable' for serial streams.
--
-- @since 0.4.0
{-# INLINE_EARLY fromList #-}
fromList :: (Monad m, IsStream t) => [a] -> t m a
fromList = fromStreamS . S.fromList
{-# RULES "fromList fallback to StreamK" [1]
    forall a. S.toStreamK (S.fromList a) = K.fromFoldable a #-}

-- | Convert a stream into a list in the underlying monad.
--
-- @since 0.1.0
{-# INLINE toList #-}
toList :: (Monad m, IsStream t) => t m a -> m [a]
toList m = S.toList $ toStreamS m

------------------------------------------------------------------------------
-- Folds
------------------------------------------------------------------------------

{-# INLINE foldrM #-}
foldrM :: (Monad m, IsStream t) => (a -> m b -> m b) -> m b -> t m a -> m b
foldrM step acc m = S.foldrM step acc $ toStreamS m

{-# INLINE foldrMx #-}
foldrMx :: (Monad m, IsStream t)
    => (a -> m x -> m x) -> m x -> (m x -> m b) -> t m a -> m b
foldrMx step final project m = D.foldrMx step final project $ D.toStreamD m

{-# INLINE foldr #-}
foldr :: (Monad m, IsStream t) => (a -> b -> b) -> b -> t m a -> m b
foldr f z = foldrM (\a b -> f a <$> b) (return z)

-- | Like 'foldlx'', but with a monadic step function.
--
-- @since 0.7.0
{-# INLINE foldlMx' #-}
foldlMx' :: (IsStream t, Monad m)
    => (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b
foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m

{-# INLINE parselMx' #-}
parselMx'
    :: (IsStream t, MonadThrow m)
    => (s -> a -> m (Step s b))
    -> m s
    -> (s -> m b)
    -> t m a
    -> m b
parselMx' step initial extract m =
    D.parselMx' step initial extract $ D.toStreamD m

-- | Strict left fold with an extraction function. Like the standard strict
-- left fold, but applies a user supplied extraction function (the third
-- argument) to the folded value at the end. This is designed to work with the
-- @foldl@ library. The suffix @x@ is a mnemonic for extraction.
--
-- @since 0.7.0
{-# INLINE foldlx' #-}
foldlx' :: (IsStream t, Monad m)
    => (x -> a -> x) -> x -> (x -> b) -> t m a -> m b
foldlx' step begin done m = S.foldlx' step begin done $ toStreamS m

-- | Strict left associative fold.
--
-- @since 0.2.0
{-# INLINE foldl' #-}
foldl' :: (Monad m, IsStream t) => (b -> a -> b) -> b -> t m a -> m b
foldl' step begin m = S.foldl' step begin $ toStreamS m

{-# INLINE foldlS #-}
foldlS :: IsStream t => (t m b -> a -> t m b) -> t m b -> t m a -> t m b
foldlS = K.foldlS

-- | Lazy left fold to a transformer monad.
--
-- For example, to reverse a stream:
--
-- > S.toList $ S.foldlT (flip S.cons) S.nil $ (S.fromList [1..5] :: SerialT IO Int)
--
{-# INLINE foldlT #-}
foldlT :: (Monad m, IsStream t, Monad (s m), MonadTrans s)
    => (s m b -> a -> s m b) -> s m b -> t m a -> s m b
foldlT f z s = S.foldlT f z (toStreamS s)

{-# INLINE runFold #-}
runFold :: (Monad m, IsStream t) => Fold m a b -> t m a -> m b
runFold (Fold step begin done) = foldlMx' step begin done

------------------------------------------------------------------------------
-- Scans
------------------------------------------------------------------------------

-- postscanlM' followed by mapM
{-# INLINE postscanlMx' #-}
postscanlMx' :: (IsStream t, Monad m)
    => (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> t m b
postscanlMx' step begin done m =
    D.fromStreamD $ D.postscanlMx' step begin done $ D.toStreamD m

-- postscanl' followed by map
{-# INLINE postscanlx' #-}
postscanlx' :: (IsStream t, Monad m)
    => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
postscanlx' step begin done m =
    D.fromStreamD $ D.postscanlx' step begin done $ D.toStreamD m

-- scanlM' followed by mapM
--
{-# INLINE scanlMx' #-}
scanlMx' :: (IsStream t, Monad m)
    => (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> t m b
scanlMx' step begin done m =
    D.fromStreamD $ D.scanlMx' step begin done $ D.toStreamD m

-- scanl followed by map
--
-- | Strict left scan with an extraction function. Like 'scanl'', but applies a
-- user supplied extraction function (the third argument) at each step. This is
-- designed to work with the @foldl@ library. The suffix @x@ is a mnemonic for
-- extraction.
--
-- @since 0.7.0
{-# INLINE scanlx' #-}
scanlx' :: (IsStream t, Monad m)
    => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
scanlx' step begin done m =
    fromStreamS $ S.scanlx' step begin done $ toStreamS m

------------------------------------------------------------------------------
-- Comparison
------------------------------------------------------------------------------

-- | Compare two streams for equality
--
-- @since 0.5.3
{-# INLINE eqBy #-}
eqBy :: (IsStream t, Monad m) => (a -> b -> Bool) -> t m a -> t m b -> m Bool
eqBy f m1 m2 = D.eqBy f (D.toStreamD m1) (D.toStreamD m2)

-- | Compare two streams
--
-- @since 0.5.3
{-# INLINE cmpBy #-}
cmpBy
    :: (IsStream t, Monad m)
    => (a -> b -> Ordering) -> t m a -> t m b -> m Ordering
cmpBy f m1 m2 = D.cmpBy f (D.toStreamD m1) (D.toStreamD m2)

{-# INLINE minimum #-}
minimum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
minimum m = S.minimum (toStreamS m)

{-# INLINE maximum #-}
maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
maximum m = S.maximum (toStreamS m)

------------------------------------------------------------------------------
-- Fold Utilities
------------------------------------------------------------------------------

{-
-- XXX do we have facilities in Foldable to fold any Foldable in this manner?
--
-- | Perform a pair wise bottom up hierarchical fold of elements in the
-- container using the given function as the merge function.
--
-- This will perform a balanced merge sort if the merge function is
-- 'mergeBy compare'.
--
-- @since 0.7.0
{-# INLINABLE foldbWith #-}
foldbWith :: IsStream t
    => (t m a -> t m a -> t m a) -> SerialT Identity (t m a) -> t m a
foldbWith f = K.foldb f K.nil
-}

-- /Since: 0.8.0 ("foldWith => concatFoldableWith")/
--
-- /Since: 0.7.0 ("Streamly.Prelude")/
--
-- | A variant of 'Data.Foldable.fold' that allows you to fold a 'Foldable'
-- container of streams using the specified stream sum operation.
--
-- @concatFoldableWith 'async' $ map return [1..3]@
--
-- Equivalent to:
--
-- @
-- concatFoldableWith f = S.concatMapFoldableWith f id
-- @
--
-- /Since: 0.1.0 ("Streamly")/
{-# INLINABLE concatFoldableWith #-}
concatFoldableWith :: (IsStream t, Foldable f)
    => (t m a -> t m a -> t m a) -> f (t m a) -> t m a
concatFoldableWith f = Prelude.foldr f K.nil

-- /Since: 0.8.0 ("foldMapWith => concatMapFoldableWith")/
--
-- /Since: 0.7.0 ("Streamly.Prelude")/
--
-- | A variant of 'foldMap' that allows you to map a monadic streaming action
-- on a 'Foldable' container and then fold it using the specified stream merge
-- operation.
--
-- @concatMapFoldableWith 'async' return [1..3]@
--
-- Equivalent to:
--
-- @
-- concatMapFoldableWith f g xs = S.concatMapWith f g (S.fromFoldable xs)
-- @
--
-- /Since: 0.1.0 ("Streamly")/
{-# INLINABLE concatMapFoldableWith #-}
concatMapFoldableWith :: (IsStream t, Foldable f)
    => (t m b -> t m b -> t m b) -> (a -> t m b) -> f a -> t m b
concatMapFoldableWith f g = Prelude.foldr (f . g) K.nil

-- /Since: 0.8.0 ("forEachWith => concatForFoldableWith")/
--
-- /Since: 0.7.0 ("Streamly.Prelude")/
--
-- | Like 'concatMapFoldableWith' but with the last two arguments reversed i.e. the
-- monadic streaming function is the last argument.
--
-- Equivalent to:
--
-- @
-- concatForFoldableWith = flip S.concatMapFoldableWith
-- @
--
-- /Since: 0.1.0 ("Streamly")/
{-# INLINABLE concatForFoldableWith #-}
concatForFoldableWith :: (IsStream t, Foldable f)
    => (t m b -> t m b -> t m b) -> f a -> (a -> t m b) -> t m b
concatForFoldableWith f xs g = Prelude.foldr (f . g) K.nil xs

1	{-# OPTIONS_GHC -Wno-orphans #-}
2
3	#include "inline.hs"
4
5	-- \|
6	-- Module : Streamly.Internal.Data.Stream.Prelude
7	-- Copyright : (c) 2017 Harendra Kumar
8	--
9	-- License : BSD3
10	-- Maintainer : streamly@composewell.com
11	-- Stability : experimental
12	-- Portability : GHC
13	--
14	--
15	module Streamly.Internal.Data.Stream.Prelude
16	(
17	-- * Stream Conversion
18	fromStreamS
19	, toStreamS
20
21	-- * Running Effects
22	, drain
23
24	-- * Conversion operations
25	, fromList
26	, toList
27
28	-- * Fold operations
29	, foldrM
30	, foldrMx
31	, foldr
32
33	, foldlx'
34	, foldlMx'
35	, foldl'
36	, runFold
37	, parselMx'
38
39	-- Lazy left folds are useful only for reversing the stream
40	, foldlS
41	, foldlT
42
43	, scanlx'
44	, scanlMx'
45	, postscanlx'
46	, postscanlMx'
47
48	-- * Zip style operations
49	, eqBy
50	, cmpBy
51
52	-- * Foldable instance
53	, minimum
54	, maximum
55
56	-- * Nesting
57	, K.concatMapBy
58	, K.concatMap
59
60	-- * Fold Utilities
61	, concatFoldableWith
62	, concatMapFoldableWith
63	, concatForFoldableWith
64	)
65	where
66
67	import Control.Monad.Catch (MonadThrow)
68	import Control.Monad.Trans.Class (MonadTrans(..))
69	import Prelude hiding (foldr, minimum, maximum)
70	import qualified Prelude
71
72	import Streamly.Internal.Data.Fold.Types (Fold (..))
73	import Streamly.Internal.Data.Parser (Step)
74
75	#ifdef USE_STREAMK_ONLY
76	import qualified Streamly.Internal.Data.Stream.StreamK as S
77	#else
78	import qualified Streamly.Internal.Data.Stream.StreamD as S
79	#endif
80
81	import Streamly.Internal.Data.Stream.StreamK (IsStream(..))
82	import qualified Streamly.Internal.Data.Stream.StreamK as K
83	import qualified Streamly.Internal.Data.Stream.StreamD as D
84
85	------------------------------------------------------------------------------
86	-- Conversion to and from direct style stream
87	------------------------------------------------------------------------------
88
89	-- These definitions are dependent on what is imported as S
90	{-# INLINE fromStreamS #-}
91	fromStreamS :: (IsStream t, Monad m) => S.Stream m a -> t m a
92	fromStreamS = fromStream . S.toStreamK	1✔
93
94	{-# INLINE toStreamS #-}
95	toStreamS :: (IsStream t, Monad m) => t m a -> S.Stream m a
96	toStreamS = S.fromStreamK . toStream	1✔
97
98	------------------------------------------------------------------------------
99	-- Conversions
100	------------------------------------------------------------------------------
101
102	{-# INLINE_EARLY drain #-}
103	drain :: (IsStream t, Monad m) => t m a -> m ()
104	drain m = D.drain $ D.fromStreamK (toStream m)	1✔
105	{-# RULES "drain fallback to CPS" [1]
106	forall a. D.drain (D.fromStreamK a) = K.drain a #-}
107
108	------------------------------------------------------------------------------
109	-- Conversions
110	------------------------------------------------------------------------------
111
112	-- \|
113	-- @
114	-- fromList = 'Prelude.foldr' 'K.cons' 'K.nil'
115	-- @
116	--
117	-- Construct a stream from a list of pure values. This is more efficient than
118	-- 'K.fromFoldable' for serial streams.
119	--
120	-- @since 0.4.0
121	{-# INLINE_EARLY fromList #-}
122	fromList :: (Monad m, IsStream t) => [a] -> t m a
123	fromList = fromStreamS . S.fromList	1✔
124	{-# RULES "fromList fallback to StreamK" [1]
125	forall a. S.toStreamK (S.fromList a) = K.fromFoldable a #-}
126
127	-- \| Convert a stream into a list in the underlying monad.
128	--
129	-- @since 0.1.0
130	{-# INLINE toList #-}
131	toList :: (Monad m, IsStream t) => t m a -> m [a]
132	toList m = S.toList $ toStreamS m	1✔
133
134	------------------------------------------------------------------------------
135	-- Folds
136	------------------------------------------------------------------------------
137
138	{-# INLINE foldrM #-}
139	foldrM :: (Monad m, IsStream t) => (a -> m b -> m b) -> m b -> t m a -> m b
140	foldrM step acc m = S.foldrM step acc $ toStreamS m	1✔
141
142	{-# INLINE foldrMx #-}
143	foldrMx :: (Monad m, IsStream t)
144	=> (a -> m x -> m x) -> m x -> (m x -> m b) -> t m a -> m b
145	foldrMx step final project m = D.foldrMx step final project $ D.toStreamD m	×
146
147	{-# INLINE foldr #-}
148	foldr :: (Monad m, IsStream t) => (a -> b -> b) -> b -> t m a -> m b
149	foldr f z = foldrM (\a b -> f a <$> b) (return z)	1✔
150
151	-- \| Like 'foldlx'', but with a monadic step function.
152	--
153	-- @since 0.7.0
154	{-# INLINE foldlMx' #-}
155	foldlMx' :: (IsStream t, Monad m)
156	=> (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b
157	foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m	1✔
158
159	{-# INLINE parselMx' #-}
160	parselMx'
161	:: (IsStream t, MonadThrow m)
162	=> (s -> a -> m (Step s b))
163	-> m s
164	-> (s -> m b)
165	-> t m a
166	-> m b
167	parselMx' step initial extract m =	1✔
168	D.parselMx' step initial extract $ D.toStreamD m	1✔
169
170	-- \| Strict left fold with an extraction function. Like the standard strict
171	-- left fold, but applies a user supplied extraction function (the third
172	-- argument) to the folded value at the end. This is designed to work with the
173	-- @foldl@ library. The suffix @x@ is a mnemonic for extraction.
174	--
175	-- @since 0.7.0
176	{-# INLINE foldlx' #-}
177	foldlx' :: (IsStream t, Monad m)
178	=> (x -> a -> x) -> x -> (x -> b) -> t m a -> m b
179	foldlx' step begin done m = S.foldlx' step begin done $ toStreamS m	×
180
181	-- \| Strict left associative fold.
182	--
183	-- @since 0.2.0
184	{-# INLINE foldl' #-}
185	foldl' :: (Monad m, IsStream t) => (b -> a -> b) -> b -> t m a -> m b
186	foldl' step begin m = S.foldl' step begin $ toStreamS m	1✔
187
188	{-# INLINE foldlS #-}
189	foldlS :: IsStream t => (t m b -> a -> t m b) -> t m b -> t m a -> t m b
190	foldlS = K.foldlS	×
191
192	-- \| Lazy left fold to a transformer monad.
193	--
194	-- For example, to reverse a stream:
195	--
196	-- > S.toList $ S.foldlT (flip S.cons) S.nil $ (S.fromList [1..5] :: SerialT IO Int)
197	--
198	{-# INLINE foldlT #-}
199	foldlT :: (Monad m, IsStream t, Monad (s m), MonadTrans s)
200	=> (s m b -> a -> s m b) -> s m b -> t m a -> s m b
201	foldlT f z s = S.foldlT f z (toStreamS s)	×
202
203	{-# INLINE runFold #-}
204	runFold :: (Monad m, IsStream t) => Fold m a b -> t m a -> m b
205	runFold (Fold step begin done) = foldlMx' step begin done	1✔
206
207	------------------------------------------------------------------------------
208	-- Scans
209	------------------------------------------------------------------------------
210
211	-- postscanlM' followed by mapM
212	{-# INLINE postscanlMx' #-}
213	postscanlMx' :: (IsStream t, Monad m)
214	=> (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> t m b
215	postscanlMx' step begin done m =	×
216	D.fromStreamD $ D.postscanlMx' step begin done $ D.toStreamD m	×
217
218	-- postscanl' followed by map
219	{-# INLINE postscanlx' #-}
220	postscanlx' :: (IsStream t, Monad m)
221	=> (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
222	postscanlx' step begin done m =	×
223	D.fromStreamD $ D.postscanlx' step begin done $ D.toStreamD m	×
224
225	-- scanlM' followed by mapM
226	--
227	{-# INLINE scanlMx' #-}
228	scanlMx' :: (IsStream t, Monad m)
229	=> (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> t m b
230	scanlMx' step begin done m =	×
231	D.fromStreamD $ D.scanlMx' step begin done $ D.toStreamD m	×
232
233	-- scanl followed by map
234	--
235	-- \| Strict left scan with an extraction function. Like 'scanl'', but applies a
236	-- user supplied extraction function (the third argument) at each step. This is
237	-- designed to work with the @foldl@ library. The suffix @x@ is a mnemonic for
238	-- extraction.
239	--
240	-- @since 0.7.0
241	{-# INLINE scanlx' #-}
242	scanlx' :: (IsStream t, Monad m)
243	=> (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
244	scanlx' step begin done m =	×
245	fromStreamS $ S.scanlx' step begin done $ toStreamS m	×
246
247	------------------------------------------------------------------------------
248	-- Comparison
249	------------------------------------------------------------------------------
250
251	-- \| Compare two streams for equality
252	--
253	-- @since 0.5.3
254	{-# INLINE eqBy #-}
255	eqBy :: (IsStream t, Monad m) => (a -> b -> Bool) -> t m a -> t m b -> m Bool
256	eqBy f m1 m2 = D.eqBy f (D.toStreamD m1) (D.toStreamD m2)	1✔
257
258	-- \| Compare two streams
259	--
260	-- @since 0.5.3
261	{-# INLINE cmpBy #-}
262	cmpBy
263	:: (IsStream t, Monad m)
264	=> (a -> b -> Ordering) -> t m a -> t m b -> m Ordering
265	cmpBy f m1 m2 = D.cmpBy f (D.toStreamD m1) (D.toStreamD m2)	1✔
266
267	{-# INLINE minimum #-}
268	minimum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
269	minimum m = S.minimum (toStreamS m)	×
270
271	{-# INLINE maximum #-}
272	maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
273	maximum m = S.maximum (toStreamS m)	1✔
274
275	------------------------------------------------------------------------------
276	-- Fold Utilities
277	------------------------------------------------------------------------------
278
279	{-
280	-- XXX do we have facilities in Foldable to fold any Foldable in this manner?
281	--
282	-- \| Perform a pair wise bottom up hierarchical fold of elements in the
283	-- container using the given function as the merge function.
284	--
285	-- This will perform a balanced merge sort if the merge function is
286	-- 'mergeBy compare'.
287	--
288	-- @since 0.7.0
289	{-# INLINABLE foldbWith #-}
290	foldbWith :: IsStream t
291	=> (t m a -> t m a -> t m a) -> SerialT Identity (t m a) -> t m a
292	foldbWith f = K.foldb f K.nil
293	-}
294
295	-- /Since: 0.8.0 ("foldWith => concatFoldableWith")/
296	--
297	-- /Since: 0.7.0 ("Streamly.Prelude")/
298	--
299	-- \| A variant of 'Data.Foldable.fold' that allows you to fold a 'Foldable'
300	-- container of streams using the specified stream sum operation.
301	--
302	-- @concatFoldableWith 'async' $ map return [1..3]@
303	--
304	-- Equivalent to:
305	--
306	-- @
307	-- concatFoldableWith f = S.concatMapFoldableWith f id
308	-- @
309	--
310	-- /Since: 0.1.0 ("Streamly")/
311	{-# INLINABLE concatFoldableWith #-}
312	concatFoldableWith :: (IsStream t, Foldable f)
313	=> (t m a -> t m a -> t m a) -> f (t m a) -> t m a
314	concatFoldableWith f = Prelude.foldr f K.nil	×
315
316	-- /Since: 0.8.0 ("foldMapWith => concatMapFoldableWith")/
317	--
318	-- /Since: 0.7.0 ("Streamly.Prelude")/
319	--
320	-- \| A variant of 'foldMap' that allows you to map a monadic streaming action
321	-- on a 'Foldable' container and then fold it using the specified stream merge
322	-- operation.
323	--
324	-- @concatMapFoldableWith 'async' return [1..3]@
325	--
326	-- Equivalent to:
327	--
328	-- @
329	-- concatMapFoldableWith f g xs = S.concatMapWith f g (S.fromFoldable xs)
330	-- @
331	--
332	-- /Since: 0.1.0 ("Streamly")/
333	{-# INLINABLE concatMapFoldableWith #-}
334	concatMapFoldableWith :: (IsStream t, Foldable f)
335	=> (t m b -> t m b -> t m b) -> (a -> t m b) -> f a -> t m b
336	concatMapFoldableWith f g = Prelude.foldr (f . g) K.nil	1✔
337
338	-- /Since: 0.8.0 ("forEachWith => concatForFoldableWith")/
339	--
340	-- /Since: 0.7.0 ("Streamly.Prelude")/
341	--
342	-- \| Like 'concatMapFoldableWith' but with the last two arguments reversed i.e. the
343	-- monadic streaming function is the last argument.
344	--
345	-- Equivalent to:
346	--
347	-- @
348	-- concatForFoldableWith = flip S.concatMapFoldableWith
349	-- @
350	--
351	-- /Since: 0.1.0 ("Streamly")/
352	{-# INLINABLE concatForFoldableWith #-}
353	concatForFoldableWith :: (IsStream t, Foldable f)
354	=> (t m b -> t m b -> t m b) -> f a -> (a -> t m b) -> t m b
355	concatForFoldableWith f xs g = Prelude.foldr (f . g) K.nil xs	1✔

composewell / streamly / 3157

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous