@@ -1,5 +1,5 @@
11-- |
2−-- Module : Stream.Transformation
2+-- Module : Stream.Transform
33-- Copyright : (c) 2018 Composewell Technologies
44-- License : BSD-3-Clause
55-- Maintainer : streamly@composewell.com
@@ -18,36 +18,37 @@
1818{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}
1919#endif
2020
21−module Stream.Transformation (benchmarks) where
21+module Stream.Transform (benchmarks) where
2222
23+import Control.DeepSeq (NFData(..))
2324import Control.Monad.IO.Class (MonadIO(..))
25+import Data.Functor.Identity (Identity)
2426
2527import System.Random (randomRIO)
2628
2729import qualified Streamly.Internal.Data.Fold as FL
2830
31+import qualified Prelude
32+import qualified Stream.Common as Common
33+import qualified Streamly.Internal.Data.Unfold as Unfold
2934#ifdef USE_PRELUDE
30−import Streamly.Prelude (fromSerial, MonadAsync)
31−import Streamly.Benchmark.Prelude
35+import Streamly.Benchmark.Prelude hiding
36+ ( benchIOSrc, sourceUnfoldrM, apDiscardFst, apDiscardSnd, apLiftA2, toNullAp
37+ , monadThen, toNullM, toNullM3, filterAllInM, filterAllOutM, filterSome
38+ , breakAfterSome, toListM, toListSome, transformMapM, transformComposeMapM
39+ , transformTeeMapM, transformZipMapM, mapN, mapM)
40+import qualified Streamly.Internal.Data.Stream.IsStream as Stream
3241import Streamly.Internal.Data.Time.Units
33−import qualified Streamly.Benchmark.Prelude as BP
34−import qualified Streamly.Prelude as S
35−import qualified Streamly.Internal.Data.Stream.IsStream as Internal
36−import qualified Streamly.Internal.Data.Unfold as Unfold
3742#else
38−import Control.DeepSeq (NFData(..))
39−import Data.Functor.Identity (Identity)
40−import Stream.Common
43+import Streamly.Benchmark.Prelude (benchIO)
4144import qualified Streamly.Internal.Data.Stream as Stream
42−import qualified Streamly.Internal.Data.Stream as S
43−import qualified Streamly.Internal.Data.Stream as Internal
44−import qualified Prelude
4545#endif
4646
4747import Gauge
4848import Streamly.Internal.Data.Stream.Serial (SerialT)
49+import Stream.Common hiding (scanl')
4950import Streamly.Benchmark.Common
50−import Prelude hiding (sequence, mapM, fmap)
51+import Prelude hiding (sequence, mapM)
5152
5253-------------------------------------------------------------------------------
5354-- Pipelines (stream-to-stream transformations)
@@ -60,7 +61,7 @@ import Prelude hiding (sequence, mapM, fmap)
6061-------------------------------------------------------------------------------
6162-- Traversable Instance
6263-------------------------------------------------------------------------------
63−#ifndef USE_PRELUDE
64+
6465{-# INLINE traversableTraverse #-}
6566traversableTraverse :: SerialT Identity Int -> IO (SerialT Identity Int)
6667traversableTraverse = traverse return
@@ -95,111 +96,89 @@ o_n_space_traversable value =
9596 , benchPureSinkIO value "sequence" traversableSequence
9697 ]
9798 ]
98−#endif
9999
100−#ifdef USE_PRELUDE
101−{-# INLINE composeNG #-}
102−composeNG ::
103− (S.IsStream t, Monad m)
104− => Int
105− -> (t m Int -> S.SerialT m Int)
106− -> t m Int
107− -> m ()
108−composeNG = BP.composeN
109−#else
110−{-# INLINE composeNG #-}
111−composeNG ::
112− (Monad m)
113− => Int
114− -> (SerialT m Int -> SerialT m Int)
115− -> SerialT m Int
116− -> m ()
117−composeNG _n = return $ Stream.fold FL.drain
118−#endif
119100-------------------------------------------------------------------------------
120101-- maps and scans
121102-------------------------------------------------------------------------------
122103
123−
124−{-# INLINE scan #-}
125−scan :: MonadIO m => Int -> SerialT m Int -> m ()
126−scan n = composeNG n $ S.scan FL.sum
127−
128−{-# INLINE tap #-}
129−tap :: MonadIO m => Int -> SerialT m Int -> m ()
130−tap n = composeNG n $ S.tap FL.sum
131−
132104#ifdef USE_PRELUDE
133105{-# INLINE scanl' #-}
134106scanl' :: MonadIO m => Int -> SerialT m Int -> m ()
135−scanl' n = composeNG n $ S.scanl' (+) 0
107+scanl' n = composeN n $ Stream.scanl' (+) 0
136108
137109{-# INLINE scanlM' #-}
138110scanlM' :: MonadIO m => Int -> SerialT m Int -> m ()
139−scanlM' n = composeNG n $ S.scanlM' (\b a -> return $ b + a) (return 0)
111+scanlM' n = composeN n $ Stream.scanlM' (\b a -> return $ b + a) (return 0)
140112
141113{-# INLINE scanl1' #-}
142114scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()
143−scanl1' n = composeNG n $ S.scanl1' (+)
115+scanl1' n = composeN n $ Stream.scanl1' (+)
144116
145117{-# INLINE scanl1M' #-}
146118scanl1M' :: MonadIO m => Int -> SerialT m Int -> m ()
147−scanl1M' n = composeNG n $ S.scanl1M' (\b a -> return $ b + a)
119+scanl1M' n = composeN n $ Stream.scanl1M' (\b a -> return $ b + a)
120+#endif
121+
122+{-# INLINE scan #-}
123+scan :: MonadIO m => Int -> SerialT m Int -> m ()
124+scan n = composeN n $ Stream.scan FL.sum
148125
126+#ifdef USE_PRELUDE
149127{-# INLINE postscanl' #-}
150128postscanl' :: MonadIO m => Int -> SerialT m Int -> m ()
151−postscanl' n = composeNG n $ S.postscanl' (+) 0
129+postscanl' n = composeN n $ Stream.postscanl' (+) 0
152130
153131{-# INLINE postscanlM' #-}
154132postscanlM' :: MonadIO m => Int -> SerialT m Int -> m ()
155−postscanlM' n = composeNG n $ S.postscanlM' (\b a -> return $ b + a) (return 0)
156−
133+postscanlM' n = composeN n $ Stream.postscanlM' (\b a -> return $ b + a) (return 0)
134+#endif
157135
158136{-# INLINE postscan #-}
159137postscan :: MonadIO m => Int -> SerialT m Int -> m ()
160−postscan n = composeNG n $ S.postscan FL.sum
138+postscan n = composeN n $ Stream.postscan FL.sum
161139
162140{-# INLINE sequence #-}
163−sequence ::
164− (S.IsStream t, S.MonadAsync m)
165− => (t m Int -> S.SerialT m Int)
166− -> t m (m Int)
167− -> m ()
168−sequence t = S.drain . t . S.sequence
141+sequence :: MonadAsync m => SerialT m (m Int) -> m ()
142+sequence = Common.drain . Stream.sequence
143+
144+{-# INLINE tap #-}
145+tap :: MonadIO m => Int -> SerialT m Int -> m ()
146+tap n = composeN n $ Stream.tap FL.sum
169147
148+#ifdef USE_PRELUDE
170149{-# INLINE pollCounts #-}
171150pollCounts :: Int -> SerialT IO Int -> IO ()
172151pollCounts n =
173− composeN n (Internal.pollCounts (const True) f)
152+ composeN n (Stream.pollCounts (const True) f)
174153
175154 where
176155
177− f = S.drain . Internal.rollingMap2 (-) . Internal.delayPost 1
156+ f = Stream.drain . Stream.rollingMap2 (-) . Stream.delayPost 1
178157
179158{-# INLINE timestamped #-}
180−timestamped :: (S.MonadAsync m) => SerialT m Int -> m ()
181−timestamped = S.drain . Internal.timestamped
182−
183−{-# INLINE trace #-}
184−trace :: MonadAsync m => Int -> SerialT m Int -> m ()
185−trace n = composeNG n $ Internal.trace return
159+timestamped :: (MonadAsync m) => SerialT m Int -> m ()
160+timestamped = Stream.drain . Stream.timestamped
186161#endif
187162
188163{-# INLINE foldrS #-}
189164foldrS :: MonadIO m => Int -> SerialT m Int -> m ()
190−foldrS n = composeNG n $ Internal.foldrS S.cons S.nil
165+foldrS n = composeN n $ Stream.foldrS Stream.cons Stream.nil
191166
192167{-# INLINE foldrSMap #-}
193168foldrSMap :: MonadIO m => Int -> SerialT m Int -> m ()
194−foldrSMap n = composeNG n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
169+foldrSMap n = composeN n $ Stream.foldrS (\x xs -> x + 1 `Stream.cons` xs) Stream.nil
195170
196171{-# INLINE foldrT #-}
197172foldrT :: MonadIO m => Int -> SerialT m Int -> m ()
198−foldrT n = composeNG n $ Internal.foldrT S.cons S.nil
173+foldrT n = composeN n $ Stream.foldrT Stream.cons Stream.nil
199174
200175{-# INLINE foldrTMap #-}
201176foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()
202−foldrTMap n = composeNG n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
177+foldrTMap n = composeN n $ Stream.foldrT (\x xs -> x + 1 `Stream.cons` xs) Stream.nil
178+
179+{-# INLINE trace #-}
180+trace :: MonadAsync m => Int -> SerialT m Int -> m ()
181+trace n = composeN n $ Stream.trace return
203182
204183o_1_space_mapping :: Int -> [Benchmark]
205184o_1_space_mapping value =
@@ -211,13 +190,14 @@ o_1_space_mapping value =
211190 , benchIOSink value "foldrSMap" (foldrSMap 1)
212191 , benchIOSink value "foldrT" (foldrT 1)
213192 , benchIOSink value "foldrTMap" (foldrTMap 1)
214−#ifdef USE_PRELUDE
193+
215194 -- Mapping
216− , benchIOSink value "map" (mapN fromSerial 1)
195+ , benchIOSink value "map" (mapN 1)
217196 , bench "sequence" $ nfIO $ randomRIO (1, 1000) >>= \n ->
218− sequence fromSerial (sourceUnfoldrAction value n)
219− , benchIOSink value "mapM" (mapM fromSerial 1)
220−
197+ sequence (sourceUnfoldrAction value n)
198+ , benchIOSink value "mapM" (mapM 1)
199+ , benchIOSink value "tap" (tap 1)
200+#ifdef USE_PRELUDE
221201 , benchIOSink value "pollCounts 1 second" (pollCounts 1)
222202 , benchIOSink value "timestamped" timestamped
223203
@@ -228,48 +208,46 @@ o_1_space_mapping value =
228208 , benchIOSink value "scanl1M'" (scanl1M' 1)
229209 , benchIOSink value "postscanl'" (postscanl' 1)
230210 , benchIOSink value "postscanlM'" (postscanlM' 1)
231− , benchIOSink value "postscan" (postscan 1)
232211#endif
233212 , benchIOSink value "scan" (scan 1)
234− , benchIOSink value "tap" (tap 1)
213+ , benchIOSink value "postscan" (postscan 1)
235214 ]
236215 ]
237216
238−
239−#ifdef USE_PRELUDE
240217o_1_space_mappingX4 :: Int -> [Benchmark]
241218o_1_space_mappingX4 value =
242219 [ bgroup "mappingX4"
243− [ benchIOSink value "map" (mapN fromSerial 4)
244− , benchIOSink value "mapM" (mapM fromSerial 4)
220+ [ benchIOSink value "map" (mapN 4)
221+ , benchIOSink value "mapM" (mapM 4)
245222 , benchIOSink value "trace" (trace 4)
246223
224+#ifdef USE_PRELUDE
247225 , benchIOSink value "scanl'" (scanl' 4)
248226 , benchIOSink value "scanl1'" (scanl1' 4)
249227 , benchIOSink value "scanlM'" (scanlM' 4)
250228 , benchIOSink value "scanl1M'" (scanl1M' 4)
251229 , benchIOSink value "postscanl'" (postscanl' 4)
252230 , benchIOSink value "postscanlM'" (postscanlM' 4)
231+#endif
253232 ]
254233 ]
255234
256−
257235{-# INLINE sieveScan #-}
258236sieveScan :: Monad m => SerialT m Int -> SerialT m Int
259237sieveScan =
260− S.mapMaybe snd
261− . S.scanlM' (\(primes, _) n -> do
238+ Stream.mapMaybe snd
239+ . Stream.scan (FL.foldlM' (\(primes, _) n -> do
262240 return $
263241 let ps = takeWhile (\p -> p * p <= n) primes
264242 in if all (\p -> n `mod` p /= 0) ps
265243 then (primes ++ [n], Just n)
266− else (primes, Nothing)) (return ([2], Just 2))
244+ else (primes, Nothing)) (return ([2], Just 2)))
267245
268246o_n_space_mapping :: Int -> [Benchmark]
269247o_n_space_mapping value =
270248 [ bgroup "mapping"
271249 [ benchIO "naive prime sieve"
272− (\n -> S.sum $ sieveScan $ S.enumerateFromTo 2 (value + n))
250+ (\n -> Stream.fold FL.sum $ sieveScan $ Common.enumerateFromTo 2 (value + n))
273251 ]
274252 ]
275253
@@ -280,64 +258,59 @@ o_n_space_mapping value =
280258o_1_space_functor :: Int -> [Benchmark]
281259o_1_space_functor value =
282260 [ bgroup "Functor"
283− [ benchIOSink value "fmap" (fmapN fromSerial 1)
284− , benchIOSink value "fmap x 4" (fmapN fromSerial 4)
261+ [ benchIOSink value "fmap" (mapN 1)
262+ , benchIOSink value "fmap x 4" (mapN 4)
285263 ]
286264 ]
287−#else
288−{-# INLINE foldFilterEven #-}
289−foldFilterEven :: MonadIO m => SerialT m Int -> m ()
290−foldFilterEven = Stream.fold FL.drain . Stream.foldFilter (FL.satisfy even)
291−#endif
265+
292266-------------------------------------------------------------------------------
293267-- Size reducing transformations (filtering)
294268-------------------------------------------------------------------------------
295269
296270{-# INLINE filterEven #-}
297271filterEven :: MonadIO m => Int -> SerialT m Int -> m ()
298−filterEven n = composeNG n $ S.filter even
272+filterEven n = composeN n $ Stream.filter even
299273
300274{-# INLINE filterAllOut #-}
301275filterAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
302−filterAllOut value n = composeNG n $ S.filter (> (value + 1))
276+filterAllOut value n = composeN n $ Stream.filter (> (value + 1))
303277
304278{-# INLINE filterAllIn #-}
305279filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
306−filterAllIn value n = composeNG n $ S.filter (<= (value + 1))
280+filterAllIn value n = composeN n $ Stream.filter (<= (value + 1))
307281
308282{-# INLINE filterMEven #-}
309283filterMEven :: MonadIO m => Int -> SerialT m Int -> m ()
310−filterMEven n = composeNG n $ S.filterM (return . even)
284+filterMEven n = composeN n $ Stream.filterM (return . even)
311285
312286{-# INLINE filterMAllOut #-}
313287filterMAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
314−filterMAllOut value n = composeNG n $ S.filterM (\x -> return $ x > (value + 1))
288+filterMAllOut value n = composeN n $ Stream.filterM (\x -> return $ x > (value + 1))
315289
316290{-# INLINE filterMAllIn #-}
317291filterMAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
318−filterMAllIn value n = composeNG n $ S.filterM (\x -> return $ x <= (value + 1))
292+filterMAllIn value n = composeN n $ Stream.filterM (\x -> return $ x <= (value + 1))
319293
320294{-# INLINE _takeOne #-}
321295_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()
322−_takeOne n = composeNG n $ S.take 1
296+_takeOne n = composeN n $ Stream.take 1
323297
324298{-# INLINE takeAll #-}
325299takeAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
326−takeAll value n = composeNG n $ S.take (value + 1)
300+takeAll value n = composeN n $ Stream.take (value + 1)
327301
328302{-# INLINE takeWhileTrue #-}
329303takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
330−takeWhileTrue value n = composeNG n $ S.takeWhile (<= (value + 1))
304+takeWhileTrue value n = composeN n $ Stream.takeWhile (<= (value + 1))
331305
332306{-# INLINE takeWhileMTrue #-}
333307takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
334−takeWhileMTrue value n = composeNG n $ S.takeWhileM (return . (<= (value + 1)))
308+takeWhileMTrue value n = composeN n $ Stream.takeWhileM (return . (<= (value + 1)))
335309
336310#ifdef USE_PRELUDE
337311{-# INLINE takeInterval #-}
338312takeInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()
339−takeInterval i n = composeN n (Internal.takeInterval i)
340−
313+takeInterval i n = composeN n (Stream.takeInterval i)
341314
342315#ifdef INSPECTION
343316-- inspect $ hasNoType 'takeInterval ''SPEC
@@ -348,33 +321,33 @@ inspect $ hasNoTypeClasses 'takeInterval
348321
349322{-# INLINE dropOne #-}
350323dropOne :: MonadIO m => Int -> SerialT m Int -> m ()
351−dropOne n = composeNG n $ S.drop 1
324+dropOne n = composeN n $ Stream.drop 1
352325
353326{-# INLINE dropAll #-}
354327dropAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
355−dropAll value n = composeNG n $ S.drop (value + 1)
328+dropAll value n = composeN n $ Stream.drop (value + 1)
356329
357330{-# INLINE dropWhileTrue #-}
358331dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
359−dropWhileTrue value n = composeNG n $ S.dropWhile (<= (value + 1))
332+dropWhileTrue value n = composeN n $ Stream.dropWhile (<= (value + 1))
360333
361334{-# INLINE dropWhileMTrue #-}
362335dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
363−dropWhileMTrue value n = composeNG n $ S.dropWhileM (return . (<= (value + 1)))
336+dropWhileMTrue value n = composeN n $ Stream.dropWhileM (return . (<= (value + 1)))
364337
365338{-# INLINE dropWhileFalse #-}
366339dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
367−dropWhileFalse value n = composeNG n $ S.dropWhile (> (value + 1))
340+dropWhileFalse value n = composeN n $ Stream.dropWhile (> (value + 1))
368341
369342#ifdef USE_PRELUDE
370343-- XXX Decide on the time interval
371344{-# INLINE _intervalsOfSum #-}
372345_intervalsOfSum :: MonadAsync m => Double -> Int -> SerialT m Int -> m ()
373−_intervalsOfSum i n = composeN n (S.intervalsOf i FL.sum)
346+_intervalsOfSum i n = composeN n (Stream.intervalsOf i FL.sum)
374347
375348{-# INLINE dropInterval #-}
376349dropInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()
377−dropInterval i n = composeN n (Internal.dropInterval i)
350+dropInterval i n = composeN n (Stream.dropInterval i)
378351
379352#ifdef INSPECTION
380353inspect $ hasNoTypeClasses 'dropInterval
@@ -384,42 +357,40 @@ inspect $ hasNoTypeClasses 'dropInterval
384357
385358{-# INLINE findIndices #-}
386359findIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
387−findIndices value n = composeNG n $ S.findIndices (== (value + 1))
360+findIndices value n = composeN n $ Stream.findIndices (== (value + 1))
388361
389362{-# INLINE elemIndices #-}
390363elemIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
391−elemIndices value n = composeNG n $ S.elemIndices (value + 1)
364+elemIndices value n = composeN n $ Stream.elemIndices (value + 1)
392365
393366{-# INLINE deleteBy #-}
394367deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
395−deleteBy value n = composeNG n $ S.deleteBy (>=) (value + 1)
368+deleteBy value n = composeN n $ Stream.deleteBy (>=) (value + 1)
396369
397370-- uniq . uniq == uniq, composeN 2 ~ composeN 1
398371{-# INLINE uniq #-}
399372uniq :: MonadIO m => Int -> SerialT m Int -> m ()
400−uniq n = composeNG n S.uniq
373+uniq n = composeN n Stream.uniq
401374
402−#ifdef USE_PRELUDE
403375{-# INLINE mapMaybe #-}
404376mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()
405377mapMaybe n =
406− composeNG n $
407− S.mapMaybe
378+ composeN n $
379+ Stream.mapMaybe
408380 (\x ->
409381 if odd x
410382 then Nothing
411383 else Just x)
412384
413385{-# INLINE mapMaybeM #-}
414−mapMaybeM :: S.MonadAsync m => Int -> SerialT m Int -> m ()
386+mapMaybeM :: MonadAsync m => Int -> SerialT m Int -> m ()
415387mapMaybeM n =
416− composeNG n $
417− S.mapMaybeM
388+ composeN n $
389+ Stream.mapMaybeM
418390 (\x ->
419391 if odd x
420392 then return Nothing
421393 else return $ Just x)
422−#endif
423394
424395o_1_space_filtering :: Int -> [Benchmark]
425396o_1_space_filtering value =
@@ -431,9 +402,6 @@ o_1_space_filtering value =
431402 , benchIOSink value "filterM-even" (filterMEven 1)
432403 , benchIOSink value "filterM-all-out" (filterMAllOut value 1)
433404 , benchIOSink value "filterM-all-in" (filterMAllIn value 1)
434−#ifndef USE_PRELUDE
435− , benchIOSink value "foldFilter-even" foldFilterEven
436−#endif
437405
438406 -- Trimming
439407 , benchIOSink value "take-all" (takeAll value 1)
@@ -460,18 +428,17 @@ o_1_space_filtering value =
460428 , benchIOSink value "deleteBy" (deleteBy value 1)
461429
462430 , benchIOSink value "uniq" (uniq 1)
463−#ifdef USE_PRELUDE
431+
464432 -- Map and filter
465433 , benchIOSink value "mapMaybe" (mapMaybe 1)
466434 , benchIOSink value "mapMaybeM" (mapMaybeM 1)
467−#endif
435+
468436 -- Searching (stateful map and filter)
469437 , benchIOSink value "findIndices" (findIndices value 1)
470438 , benchIOSink value "elemIndices" (elemIndices value 1)
471439 ]
472440 ]
473441
474−
475442o_1_space_filteringX4 :: Int -> [Benchmark]
476443o_1_space_filteringX4 value =
477444 [ bgroup "filteringX4"
@@ -483,8 +450,6 @@ o_1_space_filteringX4 value =
483450 , benchIOSink value "filterM-all-out" (filterMAllOut value 4)
484451 , benchIOSink value "filterM-all-in" (filterMAllIn value 4)
485452
486− --, benchIOSink value "foldFilter-even" (foldFilterEven 4)
487−
488453 -- trimming
489454 , benchIOSink value "take-all" (takeAll value 4)
490455 , benchIOSink value "takeWhile-true" (takeWhileTrue value 4)
@@ -501,11 +466,10 @@ o_1_space_filteringX4 value =
501466
502467 , benchIOSink value "uniq" (uniq 4)
503468
504−#ifdef USE_PRELUDE
505469 -- map and filter
506470 , benchIOSink value "mapMaybe" (mapMaybe 4)
507471 , benchIOSink value "mapMaybeM" (mapMaybeM 4)
508−#endif
472+
509473 -- searching
510474 , benchIOSink value "findIndices" (findIndices value 4)
511475 , benchIOSink value "elemIndices" (elemIndices value 4)
@@ -515,29 +479,28 @@ o_1_space_filteringX4 value =
515479-------------------------------------------------------------------------------
516480-- Size increasing transformations (insertions)
517481-------------------------------------------------------------------------------
518−#ifdef USE_PRELUDE
482+
519483{-# INLINE intersperse #-}
520−intersperse :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
521−intersperse value n = composeNG n $ S.intersperse (value + 1)
484+intersperse :: MonadAsync m => Int -> Int -> SerialT m Int -> m ()
485+intersperse value n = composeN n $ Stream.intersperse (value + 1)
522486
523487{-# INLINE intersperseM #-}
524−intersperseM :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
525−intersperseM value n = composeNG n $ S.intersperseM (return $ value + 1)
488+intersperseM :: MonadAsync m => Int -> Int -> SerialT m Int -> m ()
489+intersperseM value n = composeN n $ Stream.intersperseM (return $ value + 1)
490+
491+{-# INLINE insertBy #-}
492+insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
493+insertBy value n = composeN n $ Stream.insertBy compare (value + 1)
526494
527495{-# INLINE interposeSuffix #-}
528−interposeSuffix :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
496+interposeSuffix :: Monad m => Int -> Int -> SerialT m Int -> m ()
529497interposeSuffix value n =
530− composeNG n $ Internal.interposeSuffix (value + 1) Unfold.identity
498+ composeN n $ Stream.interposeSuffix (value + 1) Unfold.identity
531499
532500{-# INLINE intercalateSuffix #-}
533−intercalateSuffix :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
501+intercalateSuffix :: Monad m => Int -> Int -> SerialT m Int -> m ()
534502intercalateSuffix value n =
535− composeNG n $ Internal.intercalateSuffix Unfold.identity (value + 1)
536−
537−{-# INLINE insertBy #-}
538−insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
539−insertBy value n = composeNG n $ S.insertBy compare (value + 1)
540−
503+ composeN n $ Stream.intercalateSuffix Unfold.identity (value + 1)
541504
542505o_1_space_inserting :: Int -> [Benchmark]
543506o_1_space_inserting value =
@@ -554,21 +517,21 @@ o_1_space_insertingX4 :: Int -> [Benchmark]
554517o_1_space_insertingX4 value =
555518 [ bgroup "insertingX4"
556519 [ benchIOSink value "intersperse" (intersperse value 4)
557− -- , benchIOSink value "insertBy" (insertBy value 4)
520+ , benchIOSink value "insertBy" (insertBy value 4)
558521 ]
559522 ]
560−#endif
523+
561524-------------------------------------------------------------------------------
562525-- Indexing
563526-------------------------------------------------------------------------------
564−#ifdef USE_PRELUDE
527+
565528{-# INLINE indexed #-}
566529indexed :: MonadIO m => Int -> SerialT m Int -> m ()
567−indexed n = composeN n (S.map snd . S.indexed)
530+indexed n = composeN n (fmap snd . Stream.indexed)
568531
569532{-# INLINE indexedR #-}
570533indexedR :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
571−indexedR value n = composeN n (S.map snd . S.indexedR value)
534+indexedR value n = composeN n (fmap snd . Stream.indexedR value)
572535
573536o_1_space_indexing :: Int -> [Benchmark]
574537o_1_space_indexing value =
@@ -586,24 +549,6 @@ o_1_space_indexingX4 value =
586549 ]
587550 ]
588551
589−#else
590−{-# INLINE indexed #-}
591−indexed :: MonadIO m => SerialT m Int -> m ()
592−indexed = Stream.fold FL.drain . Prelude.fmap snd . Stream.indexed
593−
594−{-# INLINE indexedR #-}
595−indexedR :: MonadIO m => Int -> SerialT m Int -> m ()
596−indexedR value = Stream.fold FL.drain . (Prelude.fmap snd . Stream.indexedR value)
597−
598−o_1_space_indexing :: Int -> [Benchmark]
599−o_1_space_indexing value =
600− [ bgroup "indexing"
601− [ benchIOSink value "indexed" indexed
602− , benchIOSink value "indexedR" (indexedR value)
603− ]
604− ]
605−#endif
606−
607552-------------------------------------------------------------------------------
608553-- Main
609554-------------------------------------------------------------------------------
@@ -614,23 +559,18 @@ o_1_space_indexing value =
614559benchmarks :: String -> Int -> [Benchmark]
615560benchmarks moduleName size =
616561 [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat
617− [ o_1_space_mapping size
618− , o_1_space_indexing size
562+ [ o_1_space_functor size
563+ , o_1_space_mapping size
564+ , o_1_space_mappingX4 size
619565 , o_1_space_filtering size
620566 , o_1_space_filteringX4 size
621−#ifdef USE_PRELUDE
622− , o_1_space_functor size
623− , o_1_space_mappingX4 size
624567 , o_1_space_inserting size
625568 , o_1_space_insertingX4 size
569+ , o_1_space_indexing size
626570 , o_1_space_indexingX4 size
627−#endif
628571 ]
629−
630− , bgroup (o_n_space_prefix moduleName) $
631−#ifdef USE_PRELUDE
632− o_n_space_mapping size
633−#else
634− o_n_space_traversable size
635−#endif
572+ , bgroup (o_n_space_prefix moduleName) $ Prelude.concat
573+ [ o_n_space_traversable size
574+ , o_n_space_mapping size
575+ ]
636576 ]