git.iko.soy/streamly
on master help sign in
Rename concatPairsWith to mergeMapWith and expose it
6bffc84Harendra Kumar
benchmark/Streamly/Benchmark/Data/Stream/Common.hs+6−6
compare with master
unifiedsplit
@@ -42,7 +42,7 @@ module Stream.Common
42
42
43 -- Benchmarking functions
43 -- Benchmarking functions
44 , concatStreamsWith
44 , concatStreamsWith
45− , concatPairsWith
45+ , mergeMapWith
46 , apDiscardFst
46 , apDiscardFst
47 , apDiscardSnd
47 , apDiscardSnd
48 , apLiftA2
48 , apLiftA2
@@ -83,7 +83,7 @@ import qualified Streamly.Internal.Data.Stream.IsStream as Stream
83import qualified Streamly.Prelude as Stream
83import qualified Streamly.Prelude as Stream
84import Streamly.Benchmark.Prelude
84import Streamly.Benchmark.Prelude
85 ( composeN, sourceConcatMapId, benchIOSink
85 ( composeN, sourceConcatMapId, benchIOSink
86− , concatStreamsWith, concatPairsWith
86+ , concatStreamsWith, mergeMapWith
87 )
87 )
88#else
88#else
89import qualified Streamly.Internal.Data.Stream as Stream
89import qualified Streamly.Internal.Data.Stream as Stream
@@ -206,15 +206,15 @@ concatStreamsWith op outer inner n =
206 (sourceUnfoldrM inner)
206 (sourceUnfoldrM inner)
207 (sourceUnfoldrM outer n)
207 (sourceUnfoldrM outer n)
208
208
209−{-# INLINE concatPairsWith #-}
209+{-# INLINE mergeMapWith #-}
210−concatPairsWith
210+mergeMapWith
211 :: (Stream IO Int -> Stream IO Int -> Stream IO Int)
211 :: (Stream IO Int -> Stream IO Int -> Stream IO Int)
212 -> Int
212 -> Int
213 -> Int
213 -> Int
214 -> Int
214 -> Int
215 -> IO ()
215 -> IO ()
216−concatPairsWith op outer inner n =
216+mergeMapWith op outer inner n =
217− drain $ Stream.concatPairsWith op
217+ drain $ Stream.mergeMapWith op
218 (sourceUnfoldrM inner)
218 (sourceUnfoldrM inner)
219 (sourceUnfoldrM outer n)
219 (sourceUnfoldrM outer n)
220
220
benchmark/Streamly/Benchmark/Data/Stream/Expand.hs+19−19
@@ -246,15 +246,15 @@ inspect $ hasNoTypeClasses 'concatMapWithAppend
246inspect $ 'concatMapWithAppend `hasNoType` ''SPEC
246inspect $ 'concatMapWithAppend `hasNoType` ''SPEC
247#endif
247#endif
248
248
249−-- concatPairWith
249+-- mergeMapWith
250
250
251−{-# INLINE concatPairWithSerial #-}
251+{-# INLINE mergeMapWithSerial #-}
252−concatPairWithSerial :: Int -> Int -> Int -> IO ()
252+mergeMapWithSerial :: Int -> Int -> Int -> IO ()
253−concatPairWithSerial = concatPairsWith Common.append
253+mergeMapWithSerial = mergeMapWith Common.append
254
254
255−{-# INLINE concatPairWithAppend #-}
255+{-# INLINE mergeMapWithAppend #-}
256−concatPairWithAppend :: Int -> Int -> Int -> IO ()
256+mergeMapWithAppend :: Int -> Int -> Int -> IO ()
257−concatPairWithAppend = concatPairsWith Common.append2
257+mergeMapWithAppend = mergeMapWith Common.append2
258
258
259-- unfoldMany
259-- unfoldMany
260
260
@@ -334,21 +334,21 @@ o_n_space_concat :: Int -> [Benchmark]
334o_n_space_concat value = sqrtVal `seq`
334o_n_space_concat value = sqrtVal `seq`
335 [ bgroup "concat"
335 [ bgroup "concat"
336 [
336 [
337− -------------------concatPairsWith-----------------
337+ -------------------mergeMapWith-----------------
338
338
339 -- Use large number of streams to check scalability
339 -- Use large number of streams to check scalability
340
340
341− benchIOSrc1 "concatPairWithSerial (n of 1)"
341+ benchIOSrc1 "mergeMapWithSerial (n of 1)"
342− (concatPairWithSerial value 1)
342+ (mergeMapWithSerial value 1)
343− , benchIOSrc1 "concatPairWithSerial (sqrtVal of sqrtVal)"
343+ , benchIOSrc1 "mergeMapWithSerial (sqrtVal of sqrtVal)"
344− (concatPairWithSerial sqrtVal sqrtVal)
344+ (mergeMapWithSerial sqrtVal sqrtVal)
345− , benchIOSrc1 "concatPairWithSerial (2 of n/2)"
345+ , benchIOSrc1 "mergeMapWithSerial (2 of n/2)"
346− (concatPairWithSerial 2 (value `div` 2))
346+ (mergeMapWithSerial 2 (value `div` 2))
347−
347+
348− , benchIOSrc1 "concatPairWithAppend (n of 1)"
348+ , benchIOSrc1 "mergeMapWithAppend (n of 1)"
349− (concatPairWithAppend value 1)
349+ (mergeMapWithAppend value 1)
350− , benchIOSrc1 "concatPairWithAppend (sqrtVal of sqrtVal)"
350+ , benchIOSrc1 "mergeMapWithAppend (sqrtVal of sqrtVal)"
351− (concatPairWithAppend sqrtVal sqrtVal)
351+ (mergeMapWithAppend sqrtVal sqrtVal)
352 ]
352 ]
353 ]
353 ]
354
354
core/src/Streamly/Data/Stream.hs+5−8
@@ -359,10 +359,8 @@ module Streamly.Data.Stream
359
359
360 -- ** Merging
360 -- ** Merging
361 -- | Merging of @n@ streams can be performed by combining the streams pair
361 -- | Merging of @n@ streams can be performed by combining the streams pair
362− -- wise using
363− -- 'Streamly.Internal.Data.Stream.IsStream.Expand.concatPairsWith' to give
364− -- O(n * log n) time complexity.
362+ -- wise using 'mergeMapWith' to give O(n * log n) time complexity. If used
365− -- If used with 'concatMapWith' it will have O(n^2) performance.
363+ -- with 'concatMapWith' it will have O(n^2) performance.
366
364
367 , mergeBy
365 , mergeBy
368 , mergeByM
366 , mergeByM
@@ -371,10 +369,8 @@ module Streamly.Data.Stream
371
369
372 -- ** Zipping
370 -- ** Zipping
373 -- | Zipping of @n@ streams can be performed by combining the streams pair
371 -- | Zipping of @n@ streams can be performed by combining the streams pair
374− -- wise using
375− -- 'Streamly.Internal.Data.Stream.IsStream.Expand.concatPairsWith' with
376− -- O(n * log n) time complexity.
372+ -- wise using 'mergeMapWith' with O(n * log n) time complexity. If used
377− -- If used with 'concatMapWith' it will have O(n^2) performance.
373+ -- with 'concatMapWith' it will have O(n^2) performance.
378 , zipWith
374 , zipWith
379 , zipWithM
375 , zipWithM
380 -- , zipWith2
376 -- , zipWith2
@@ -410,6 +406,7 @@ module Streamly.Data.Stream
410 , concatMapWith
406 , concatMapWith
411 , concatMap
407 , concatMap
412 , concatMapM
408 , concatMapM
409+ , mergeMapWith
413
410
414 -- * Repeated Fold
411 -- * Repeated Fold
415 , foldMany -- XXX Rename to foldRepeat
412 , foldMany -- XXX Rename to foldRepeat
core/src/Streamly/Internal/Data/Stream/Expand.hs+13−13
@@ -22,7 +22,7 @@ module Streamly.Internal.Data.Stream.Expand
22 -- complexity (instead O(n^2) for pair wise combinators described in the
22 -- complexity (instead O(n^2) for pair wise combinators described in the
23 -- next section. These functions can be used efficiently with
23 -- next section. These functions can be used efficiently with
24 -- 'concatMapWith' et. al. combinators that combine streams in a linear
24 -- 'concatMapWith' et. al. combinators that combine streams in a linear
25− -- fashion (contrast with 'concatPairsWith' which combines streams as a
25+ -- fashion (contrast with 'mergeMapWith' which combines streams as a
26 -- binary tree).
26 -- binary tree).
27
27
28 append
28 append
@@ -30,7 +30,7 @@ module Streamly.Internal.Data.Stream.Expand
30 -- | Like the functions in the section above these functions also combine
30 -- | Like the functions in the section above these functions also combine
31 -- two streams into a single stream but when used @n@ times linearly they
31 -- two streams into a single stream but when used @n@ times linearly they
32 -- exhibit O(n^2) complexity. They are best combined in a binary tree
32 -- exhibit O(n^2) complexity. They are best combined in a binary tree
33− -- fashion using 'concatPairsWith' giving a @n * log n@ complexity. Avoid
33+ -- fashion using 'mergeMapWith' giving a @n * log n@ complexity. Avoid
34 -- using these with 'concatMapWith' when combining a large or infinite
34 -- using these with 'concatMapWith' when combining a large or infinite
35 -- number of streams.
35 -- number of streams.
36
36
@@ -104,7 +104,7 @@ module Streamly.Internal.Data.Stream.Expand
104 -- simultaneously anyway.
104 -- simultaneously anyway.
105 --
105 --
106 -- However, in cases where the merging consumes streams in a round robin
106 -- However, in cases where the merging consumes streams in a round robin
107− -- fashion, a pair wise merging using 'concatPairsWith' would be more
107+ -- fashion, a pair wise merging using 'mergeMapWith' would be more
108 -- efficient. These cases include operations like 'mergeBy' or 'zipWith'.
108 -- efficient. These cases include operations like 'mergeBy' or 'zipWith'.
109
109
110 , concatMapWith
110 , concatMapWith
@@ -114,7 +114,7 @@ module Streamly.Internal.Data.Stream.Expand
114 -- * ConcatPairsWith
114 -- * ConcatPairsWith
115 -- | See the notes about suitable merge functions in the 'concatMapWith'
115 -- | See the notes about suitable merge functions in the 'concatMapWith'
116 -- section.
116 -- section.
117− , concatPairsWith
117+ , mergeMapWith
118
118
119 -- * IterateMap
119 -- * IterateMap
120 -- | Map and flatten Trees of Streams
120 -- | Map and flatten Trees of Streams
@@ -165,7 +165,7 @@ infixr 6 `append2`
165-- 'append' when combining two fusible streams. However, it slows down
165-- 'append' when combining two fusible streams. However, it slows down
166-- quadratically with the number of streams being appended. Therefore, it is
166-- quadratically with the number of streams being appended. Therefore, it is
167-- suitable for ad-hoc append of a few streams, and should not be used with
167-- suitable for ad-hoc append of a few streams, and should not be used with
168−-- 'concatMapWith' or 'concatPairsWith'.
168+-- 'concatMapWith' or 'mergeMapWith'.
169--
169--
170-- /Fused/
170-- /Fused/
171--
171--
@@ -360,7 +360,7 @@ mergeByM f m1 m2 = fromStreamK $ K.mergeByM f (toStreamK m1) (toStreamK m2)
360-- | Like 'mergeByM' but much faster, works best when merging statically known
360-- | Like 'mergeByM' but much faster, works best when merging statically known
361-- number of streams. When merging more than two streams try to merge pairs and
361-- number of streams. When merging more than two streams try to merge pairs and
362-- pair of pairs in a tree like structure.'mergeByM' works better with variable
362-- pair of pairs in a tree like structure.'mergeByM' works better with variable
363−-- number of streams being merged using 'concatPairsWith'.
363+-- number of streams being merged using 'mergeMapWith'.
364--
364--
365-- /Internal/
365-- /Internal/
366{-# INLINE mergeByM2 #-}
366{-# INLINE mergeByM2 #-}
@@ -400,7 +400,7 @@ mergeFstBy _f _m1 _m2 = undefined
400unfoldMany ::Monad m => Unfold m a b -> Stream m a -> Stream m b
400unfoldMany ::Monad m => Unfold m a b -> Stream m a -> Stream m b
401unfoldMany u m = fromStreamD $ D.unfoldMany u (toStreamD m)
401unfoldMany u m = fromStreamD $ D.unfoldMany u (toStreamD m)
402
402
403−-- | This does not pair streams like concatPairsWith, instead, it goes through
403+-- | This does not pair streams like mergeMapWith, instead, it goes through
404-- each stream one by one and yields one element from each stream. After it
404-- each stream one by one and yields one element from each stream. After it
405-- goes to the last stream it reverses the traversal to come back to the first
405-- goes to the last stream it reverses the traversal to come back to the first
406-- stream yielding elements from each stream on its way back to the first
406-- stream yielding elements from each stream on its way back to the first
@@ -411,7 +411,7 @@ unfoldMany u m = fromStreamD $ D.unfoldMany u (toStreamD m)
411-- >>> Stream.fold Fold.toList interleaved
411-- >>> Stream.fold Fold.toList interleaved
412-- [1,2,3,4,5,5,4,3,2,1]
412-- [1,2,3,4,5,5,4,3,2,1]
413--
413--
414−-- Note that this is order of magnitude more efficient than "concatPairsWith
414+-- Note that this is order of magnitude more efficient than "mergeMapWith
415-- wSerial" because of fusion.
415-- wSerial" because of fusion.
416--
416--
417-- /Fused/
417-- /Fused/
@@ -581,24 +581,24 @@ concatSmapMWith combine f initial =
581-- >>> s = Stream.fromList [5,1,7,9,2]
581-- >>> s = Stream.fromList [5,1,7,9,2]
582-- >>> generate = Stream.fromPure
582-- >>> generate = Stream.fromPure
583-- >>> combine = Stream.mergeBy compare
583-- >>> combine = Stream.mergeBy compare
584−-- >>> Stream.fold Fold.toList $ Stream.concatPairsWith combine generate s
584+-- >>> Stream.fold Fold.toList $ Stream.mergeMapWith combine generate s
585-- [1,2,5,7,9]
585-- [1,2,5,7,9]
586--
586--
587-- Note that if the stream length is not a power of 2, the binary tree composed
587-- Note that if the stream length is not a power of 2, the binary tree composed
588−-- by concatPairsWith would not be balanced, which may or may not be important
588+-- by mergeMapWith would not be balanced, which may or may not be important
589-- depending on what you are trying to achieve.
589-- depending on what you are trying to achieve.
590--
590--
591-- /Caution: the stream of streams must be finite/
591-- /Caution: the stream of streams must be finite/
592--
592--
593-- /Pre-release/
593-- /Pre-release/
594--
594--
595−{-# INLINE concatPairsWith #-}
595+{-# INLINE mergeMapWith #-}
596−concatPairsWith ::
596+mergeMapWith ::
597 (Stream m b -> Stream m b -> Stream m b)
597 (Stream m b -> Stream m b -> Stream m b)
598 -> (a -> Stream m b)
598 -> (a -> Stream m b)
599 -> Stream m a
599 -> Stream m a
600 -> Stream m b
600 -> Stream m b
601−concatPairsWith par f m =
601+mergeMapWith par f m =
602 fromStreamK
602 fromStreamK
603 $ K.concatPairsWith
603 $ K.concatPairsWith
604 (\s1 s2 -> toStreamK $ fromStreamK s1 `par` fromStreamK s2)
604 (\s1 s2 -> toStreamK $ fromStreamK s1 `par` fromStreamK s2)
core/src/Streamly/Internal/Data/Stream/Top.hs+1−1
@@ -114,7 +114,7 @@ sortBy cmp =
114 (\x -> (< GT) . cmp x)
114 (\x -> (< GT) . cmp x)
115 Fold.toStreamRev
115 Fold.toStreamRev
116 Fold.toStream
116 Fold.toStream
117− in Stream.concatPairsWith (Stream.mergeBy cmp) id
117+ in Stream.mergeMapWith (Stream.mergeBy cmp) id
118 . Stream.catRights . Stream.parseMany (fmap (either id id) p)
118 . Stream.catRights . Stream.parseMany (fmap (either id id) p)
119
119
120------------------------------------------------------------------------------
120------------------------------------------------------------------------------