@@ -1,5 +1,5 @@
11-- |
2−-- Module : Serial.Transformation
2+-- Module : Stream.Transformation
33-- Copyright : (c) 2018 Composewell Technologies
44-- License : BSD-3-Clause
55-- Maintainer : streamly@composewell.com
@@ -18,29 +18,35 @@
1818{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}
1919#endif
2020
21−module Serial.Transformation (benchmarks) where
21+module Stream.Transformation (benchmarks) where
2222
23−import Control.DeepSeq (NFData(..))
2423import Control.Monad.IO.Class (MonadIO(..))
25−import Data.Functor.Identity (Identity)
24+
2625import System.Random (randomRIO)
2726
28−#ifdef INSPECTION
29−import Test.Inspection
30−#endif
27+import qualified Streamly.Internal.Data.Fold as FL
3128
29+#ifdef USE_PRELUDE
30+import Streamly.Prelude (fromSerial, MonadAsync)
31+import Streamly.Benchmark.Prelude
32+import Streamly.Internal.Data.Time.Units
33+import qualified Streamly.Benchmark.Prelude as BP
3234import qualified Streamly.Prelude as S
33−import qualified Streamly.Internal.Data.Stream as Stream
3435import qualified Streamly.Internal.Data.Stream.IsStream as Internal
35−import qualified Streamly.Internal.Data.Fold as FL
3636import qualified Streamly.Internal.Data.Unfold as Unfold
37+#else
38+import Control.DeepSeq (NFData(..))
39+import Data.Functor.Identity (Identity)
40+import Stream.Common
41+import 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
3744import qualified Prelude
45+#endif
3846
3947import Gauge
40−import Streamly.Prelude (SerialT, fromSerial, MonadAsync)
48+import Streamly.Internal.Data.Stream.Serial (SerialT)
4149import Streamly.Benchmark.Common
42−import Streamly.Benchmark.Prelude
43−import Streamly.Internal.Data.Time.Units
4450import Prelude hiding (sequence, mapM, fmap)
4551
4652-------------------------------------------------------------------------------
@@ -54,7 +60,7 @@ import Prelude hiding (sequence, mapM, fmap)
5460-------------------------------------------------------------------------------
5561-- Traversable Instance
5662-------------------------------------------------------------------------------
57−
63+#ifndef USE_PRELUDE
5864{-# INLINE traversableTraverse #-}
5965traversableTraverse :: SerialT Identity Int -> IO (SerialT Identity Int)
6066traversableTraverse = traverse return
@@ -89,42 +95,69 @@ o_n_space_traversable value =
8995 , benchPureSinkIO value "sequence" traversableSequence
9096 ]
9197 ]
98+#endif
9299
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
93119-------------------------------------------------------------------------------
94120-- maps and scans
95121-------------------------------------------------------------------------------
96122
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+
132+#ifdef USE_PRELUDE
97133{-# INLINE scanl' #-}
98134scanl' :: MonadIO m => Int -> SerialT m Int -> m ()
99−scanl' n = composeN n $ S.scanl' (+) 0
135+scanl' n = composeNG n $ S.scanl' (+) 0
100136
101137{-# INLINE scanlM' #-}
102138scanlM' :: MonadIO m => Int -> SerialT m Int -> m ()
103−scanlM' n = composeN n $ S.scanlM' (\b a -> return $ b + a) (return 0)
139+scanlM' n = composeNG n $ S.scanlM' (\b a -> return $ b + a) (return 0)
104140
105141{-# INLINE scanl1' #-}
106142scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()
107−scanl1' n = composeN n $ S.scanl1' (+)
143+scanl1' n = composeNG n $ S.scanl1' (+)
108144
109145{-# INLINE scanl1M' #-}
110146scanl1M' :: MonadIO m => Int -> SerialT m Int -> m ()
111−scanl1M' n = composeN n $ S.scanl1M' (\b a -> return $ b + a)
112−
113−{-# INLINE scan #-}
114−scan :: MonadIO m => Int -> SerialT m Int -> m ()
115−scan n = composeN n $ S.scan FL.sum
147+scanl1M' n = composeNG n $ S.scanl1M' (\b a -> return $ b + a)
116148
117149{-# INLINE postscanl' #-}
118150postscanl' :: MonadIO m => Int -> SerialT m Int -> m ()
119−postscanl' n = composeN n $ S.postscanl' (+) 0
151+postscanl' n = composeNG n $ S.postscanl' (+) 0
120152
121153{-# INLINE postscanlM' #-}
122154postscanlM' :: MonadIO m => Int -> SerialT m Int -> m ()
123−postscanlM' n = composeN n $ S.postscanlM' (\b a -> return $ b + a) (return 0)
155+postscanlM' n = composeNG n $ S.postscanlM' (\b a -> return $ b + a) (return 0)
156+
124157
125158{-# INLINE postscan #-}
126159postscan :: MonadIO m => Int -> SerialT m Int -> m ()
127−postscan n = composeN n $ S.postscan FL.sum
160+postscan n = composeNG n $ S.postscan FL.sum
128161
129162{-# INLINE sequence #-}
130163sequence ::
@@ -134,10 +167,6 @@ sequence ::
134167 -> m ()
135168sequence t = S.drain . t . S.sequence
136169
137−{-# INLINE tap #-}
138−tap :: MonadIO m => Int -> SerialT m Int -> m ()
139−tap n = composeN n $ S.tap FL.sum
140−
141170{-# INLINE pollCounts #-}
142171pollCounts :: Int -> SerialT IO Int -> IO ()
143172pollCounts n =
@@ -151,26 +180,26 @@ pollCounts n =
151180timestamped :: (S.MonadAsync m) => SerialT m Int -> m ()
152181timestamped = S.drain . Internal.timestamped
153182
183+{-# INLINE trace #-}
184+trace :: MonadAsync m => Int -> SerialT m Int -> m ()
185+trace n = composeNG n $ Internal.trace return
186+#endif
187+
154188{-# INLINE foldrS #-}
155189foldrS :: MonadIO m => Int -> SerialT m Int -> m ()
156−foldrS n = composeN n $ Internal.foldrS S.cons S.nil
190+foldrS n = composeNG n $ Internal.foldrS S.cons S.nil
157191
158192{-# INLINE foldrSMap #-}
159193foldrSMap :: MonadIO m => Int -> SerialT m Int -> m ()
160−foldrSMap n = composeN n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
194+foldrSMap n = composeNG n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
161195
162196{-# INLINE foldrT #-}
163197foldrT :: MonadIO m => Int -> SerialT m Int -> m ()
164−foldrT n = composeN n $ Internal.foldrT S.cons S.nil
198+foldrT n = composeNG n $ Internal.foldrT S.cons S.nil
165199
166200{-# INLINE foldrTMap #-}
167201foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()
168−foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
169−
170−
171−{-# INLINE trace #-}
172−trace :: MonadAsync m => Int -> SerialT m Int -> m ()
173−trace n = composeN n $ Internal.trace return
202+foldrTMap n = composeNG n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
174203
175204o_1_space_mapping :: Int -> [Benchmark]
176205o_1_space_mapping value =
@@ -182,13 +211,13 @@ o_1_space_mapping value =
182211 , benchIOSink value "foldrSMap" (foldrSMap 1)
183212 , benchIOSink value "foldrT" (foldrT 1)
184213 , benchIOSink value "foldrTMap" (foldrTMap 1)
185−
214+#ifdef USE_PRELUDE
186215 -- Mapping
187216 , benchIOSink value "map" (mapN fromSerial 1)
188217 , bench "sequence" $ nfIO $ randomRIO (1, 1000) >>= \n ->
189218 sequence fromSerial (sourceUnfoldrAction value n)
190219 , benchIOSink value "mapM" (mapM fromSerial 1)
191− , benchIOSink value "tap" (tap 1)
220+
192221 , benchIOSink value "pollCounts 1 second" (pollCounts 1)
193222 , benchIOSink value "timestamped" timestamped
194223
@@ -199,12 +228,15 @@ o_1_space_mapping value =
199228 , benchIOSink value "scanl1M'" (scanl1M' 1)
200229 , benchIOSink value "postscanl'" (postscanl' 1)
201230 , benchIOSink value "postscanlM'" (postscanlM' 1)
202−
203− , benchIOSink value "scan" (scan 1)
204231 , benchIOSink value "postscan" (postscan 1)
232+#endif
233+ , benchIOSink value "scan" (scan 1)
234+ , benchIOSink value "tap" (tap 1)
205235 ]
206236 ]
207237
238+
239+#ifdef USE_PRELUDE
208240o_1_space_mappingX4 :: Int -> [Benchmark]
209241o_1_space_mappingX4 value =
210242 [ bgroup "mappingX4"
@@ -218,10 +250,10 @@ o_1_space_mappingX4 value =
218250 , benchIOSink value "scanl1M'" (scanl1M' 4)
219251 , benchIOSink value "postscanl'" (postscanl' 4)
220252 , benchIOSink value "postscanlM'" (postscanlM' 4)
221−
222253 ]
223254 ]
224255
256+
225257{-# INLINE sieveScan #-}
226258sieveScan :: Monad m => SerialT m Int -> SerialT m Int
227259sieveScan =
@@ -252,85 +284,89 @@ o_1_space_functor value =
252284 , benchIOSink value "fmap x 4" (fmapN fromSerial 4)
253285 ]
254286 ]
255−
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
256292-------------------------------------------------------------------------------
257293-- Size reducing transformations (filtering)
258294-------------------------------------------------------------------------------
259295
260296{-# INLINE filterEven #-}
261297filterEven :: MonadIO m => Int -> SerialT m Int -> m ()
262−filterEven n = composeN n $ S.filter even
298+filterEven n = composeNG n $ S.filter even
263299
264300{-# INLINE filterAllOut #-}
265301filterAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
266−filterAllOut value n = composeN n $ S.filter (> (value + 1))
302+filterAllOut value n = composeNG n $ S.filter (> (value + 1))
267303
268304{-# INLINE filterAllIn #-}
269305filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
270−filterAllIn value n = composeN n $ S.filter (<= (value + 1))
306+filterAllIn value n = composeNG n $ S.filter (<= (value + 1))
271307
272308{-# INLINE filterMEven #-}
273309filterMEven :: MonadIO m => Int -> SerialT m Int -> m ()
274−filterMEven n = composeN n $ S.filterM (return . even)
310+filterMEven n = composeNG n $ S.filterM (return . even)
275311
276312{-# INLINE filterMAllOut #-}
277313filterMAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
278−filterMAllOut value n = composeN n $ S.filterM (\x -> return $ x > (value + 1))
314+filterMAllOut value n = composeNG n $ S.filterM (\x -> return $ x > (value + 1))
279315
280316{-# INLINE filterMAllIn #-}
281317filterMAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
282−filterMAllIn value n = composeN n $ S.filterM (\x -> return $ x <= (value + 1))
283−
284−{-# INLINE foldFilterEven #-}
285−foldFilterEven :: MonadIO m => Int -> SerialT m Int -> m ()
286−foldFilterEven n = composeN n $ Stream.foldFilter (FL.satisfy even)
318+filterMAllIn value n = composeNG n $ S.filterM (\x -> return $ x <= (value + 1))
287319
288320{-# INLINE _takeOne #-}
289321_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()
290−_takeOne n = composeN n $ S.take 1
322+_takeOne n = composeNG n $ S.take 1
291323
292324{-# INLINE takeAll #-}
293325takeAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
294−takeAll value n = composeN n $ S.take (value + 1)
326+takeAll value n = composeNG n $ S.take (value + 1)
295327
296328{-# INLINE takeWhileTrue #-}
297329takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
298−takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))
330+takeWhileTrue value n = composeNG n $ S.takeWhile (<= (value + 1))
299331
300332{-# INLINE takeWhileMTrue #-}
301333takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
302−takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))
334+takeWhileMTrue value n = composeNG n $ S.takeWhileM (return . (<= (value + 1)))
303335
336+#ifdef USE_PRELUDE
304337{-# INLINE takeInterval #-}
305338takeInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()
306339takeInterval i n = composeN n (Internal.takeInterval i)
307340
341+
308342#ifdef INSPECTION
309343-- inspect $ hasNoType 'takeInterval ''SPEC
310344inspect $ hasNoTypeClasses 'takeInterval
311345-- inspect $ 'takeInterval `hasNoType` ''D.Step
312346#endif
347+#endif
313348
314349{-# INLINE dropOne #-}
315350dropOne :: MonadIO m => Int -> SerialT m Int -> m ()
316−dropOne n = composeN n $ S.drop 1
351+dropOne n = composeNG n $ S.drop 1
317352
318353{-# INLINE dropAll #-}
319354dropAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
320−dropAll value n = composeN n $ S.drop (value + 1)
355+dropAll value n = composeNG n $ S.drop (value + 1)
321356
322357{-# INLINE dropWhileTrue #-}
323358dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
324−dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))
359+dropWhileTrue value n = composeNG n $ S.dropWhile (<= (value + 1))
325360
326361{-# INLINE dropWhileMTrue #-}
327362dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
328−dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))
363+dropWhileMTrue value n = composeNG n $ S.dropWhileM (return . (<= (value + 1)))
329364
330365{-# INLINE dropWhileFalse #-}
331366dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
332−dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))
367+dropWhileFalse value n = composeNG n $ S.dropWhile (> (value + 1))
333368
369+#ifdef USE_PRELUDE
334370-- XXX Decide on the time interval
335371{-# INLINE _intervalsOfSum #-}
336372_intervalsOfSum :: MonadAsync m => Double -> Int -> SerialT m Int -> m ()
@@ -344,28 +380,30 @@ dropInterval i n = composeN n (Internal.dropInterval i)
344380inspect $ hasNoTypeClasses 'dropInterval
345381-- inspect $ 'dropInterval `hasNoType` ''D.Step
346382#endif
383+#endif
347384
348385{-# INLINE findIndices #-}
349386findIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
350−findIndices value n = composeN n $ S.findIndices (== (value + 1))
387+findIndices value n = composeNG n $ S.findIndices (== (value + 1))
351388
352389{-# INLINE elemIndices #-}
353390elemIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
354−elemIndices value n = composeN n $ S.elemIndices (value + 1)
391+elemIndices value n = composeNG n $ S.elemIndices (value + 1)
355392
356393{-# INLINE deleteBy #-}
357394deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
358−deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)
395+deleteBy value n = composeNG n $ S.deleteBy (>=) (value + 1)
359396
360397-- uniq . uniq == uniq, composeN 2 ~ composeN 1
361398{-# INLINE uniq #-}
362399uniq :: MonadIO m => Int -> SerialT m Int -> m ()
363−uniq n = composeN n S.uniq
400+uniq n = composeNG n S.uniq
364401
402+#ifdef USE_PRELUDE
365403{-# INLINE mapMaybe #-}
366404mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()
367405mapMaybe n =
368− composeN n $
406+ composeNG n $
369407 S.mapMaybe
370408 (\x ->
371409 if odd x
@@ -375,12 +413,13 @@ mapMaybe n =
375413{-# INLINE mapMaybeM #-}
376414mapMaybeM :: S.MonadAsync m => Int -> SerialT m Int -> m ()
377415mapMaybeM n =
378− composeN n $
416+ composeNG n $
379417 S.mapMaybeM
380418 (\x ->
381419 if odd x
382420 then return Nothing
383421 else return $ Just x)
422+#endif
384423
385424o_1_space_filtering :: Int -> [Benchmark]
386425o_1_space_filtering value =
@@ -392,23 +431,26 @@ o_1_space_filtering value =
392431 , benchIOSink value "filterM-even" (filterMEven 1)
393432 , benchIOSink value "filterM-all-out" (filterMAllOut value 1)
394433 , benchIOSink value "filterM-all-in" (filterMAllIn value 1)
395−
396− , benchIOSink value "foldFilter-even" (foldFilterEven 1)
434+#ifndef USE_PRELUDE
435+ , benchIOSink value "foldFilter-even" foldFilterEven
436+#endif
397437
398438 -- Trimming
399439 , benchIOSink value "take-all" (takeAll value 1)
400− , benchIOSink
401− value
402− "takeInterval-all"
403− (takeInterval (NanoSecond64 maxBound) 1)
404440 , benchIOSink value "takeWhile-true" (takeWhileTrue value 1)
405441 -- , benchIOSink value "takeWhileM-true" (_takeWhileMTrue value 1)
406442 , benchIOSink value "drop-one" (dropOne 1)
407443 , benchIOSink value "drop-all" (dropAll value 1)
444+#ifdef USE_PRELUDE
445+ , benchIOSink
446+ value
447+ "takeInterval-all"
448+ (takeInterval (NanoSecond64 maxBound) 1)
408449 , benchIOSink
409450 value
410451 "dropInterval-all"
411452 (dropInterval (NanoSecond64 maxBound) 1)
453+#endif
412454 , benchIOSink value "dropWhile-true" (dropWhileTrue value 1)
413455 -- , benchIOSink value "dropWhileM-true" (_dropWhileMTrue value 1)
414456 , benchIOSink
@@ -418,17 +460,18 @@ o_1_space_filtering value =
418460 , benchIOSink value "deleteBy" (deleteBy value 1)
419461
420462 , benchIOSink value "uniq" (uniq 1)
421−
463+#ifdef USE_PRELUDE
422464 -- Map and filter
423465 , benchIOSink value "mapMaybe" (mapMaybe 1)
424466 , benchIOSink value "mapMaybeM" (mapMaybeM 1)
425−
467+#endif
426468 -- Searching (stateful map and filter)
427469 , benchIOSink value "findIndices" (findIndices value 1)
428470 , benchIOSink value "elemIndices" (elemIndices value 1)
429471 ]
430472 ]
431473
474+
432475o_1_space_filteringX4 :: Int -> [Benchmark]
433476o_1_space_filteringX4 value =
434477 [ bgroup "filteringX4"
@@ -440,7 +483,7 @@ o_1_space_filteringX4 value =
440483 , benchIOSink value "filterM-all-out" (filterMAllOut value 4)
441484 , benchIOSink value "filterM-all-in" (filterMAllIn value 4)
442485
443− , benchIOSink value "foldFilter-even" (foldFilterEven 4)
486+ --, benchIOSink value "foldFilter-even" (foldFilterEven 4)
444487
445488 -- trimming
446489 , benchIOSink value "take-all" (takeAll value 4)
@@ -458,10 +501,11 @@ o_1_space_filteringX4 value =
458501
459502 , benchIOSink value "uniq" (uniq 4)
460503
504+#ifdef USE_PRELUDE
461505 -- map and filter
462506 , benchIOSink value "mapMaybe" (mapMaybe 4)
463507 , benchIOSink value "mapMaybeM" (mapMaybeM 4)
464−
508+#endif
465509 -- searching
466510 , benchIOSink value "findIndices" (findIndices value 4)
467511 , benchIOSink value "elemIndices" (elemIndices value 4)
@@ -471,28 +515,29 @@ o_1_space_filteringX4 value =
471515-------------------------------------------------------------------------------
472516-- Size increasing transformations (insertions)
473517-------------------------------------------------------------------------------
474−
518+#ifdef USE_PRELUDE
475519{-# INLINE intersperse #-}
476520intersperse :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
477−intersperse value n = composeN n $ S.intersperse (value + 1)
521+intersperse value n = composeNG n $ S.intersperse (value + 1)
478522
479523{-# INLINE intersperseM #-}
480524intersperseM :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
481−intersperseM value n = composeN n $ S.intersperseM (return $ value + 1)
482−
483−{-# INLINE insertBy #-}
484−insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()
485−insertBy value n = composeN n $ S.insertBy compare (value + 1)
525+intersperseM value n = composeNG n $ S.intersperseM (return $ value + 1)
486526
487527{-# INLINE interposeSuffix #-}
488528interposeSuffix :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
489529interposeSuffix value n =
490− composeN n $ Internal.interposeSuffix (value + 1) Unfold.identity
530+ composeNG n $ Internal.interposeSuffix (value + 1) Unfold.identity
491531
492532{-# INLINE intercalateSuffix #-}
493533intercalateSuffix :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()
494534intercalateSuffix value n =
495− composeN n $ Internal.intercalateSuffix Unfold.identity (value + 1)
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+
496541
497542o_1_space_inserting :: Int -> [Benchmark]
498543o_1_space_inserting value =
@@ -509,14 +554,14 @@ o_1_space_insertingX4 :: Int -> [Benchmark]
509554o_1_space_insertingX4 value =
510555 [ bgroup "insertingX4"
511556 [ benchIOSink value "intersperse" (intersperse value 4)
512− , benchIOSink value "insertBy" (insertBy value 4)
557+ -- , benchIOSink value "insertBy" (insertBy value 4)
513558 ]
514559 ]
515−
560+#endif
516561-------------------------------------------------------------------------------
517562-- Indexing
518563-------------------------------------------------------------------------------
519−
564+#ifdef USE_PRELUDE
520565{-# INLINE indexed #-}
521566indexed :: MonadIO m => Int -> SerialT m Int -> m ()
522567indexed n = composeN n (S.map snd . S.indexed)
@@ -541,6 +586,24 @@ o_1_space_indexingX4 value =
541586 ]
542587 ]
543588
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+
544607-------------------------------------------------------------------------------
545608-- Main
546609-------------------------------------------------------------------------------
@@ -551,18 +614,23 @@ o_1_space_indexingX4 value =
551614benchmarks :: String -> Int -> [Benchmark]
552615benchmarks moduleName size =
553616 [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat
554− [ o_1_space_functor size
555− , o_1_space_mapping size
556− , o_1_space_mappingX4 size
617+ [ o_1_space_mapping size
618+ , o_1_space_indexing size
557619 , o_1_space_filtering size
558620 , o_1_space_filteringX4 size
621+#ifdef USE_PRELUDE
622+ , o_1_space_functor size
623+ , o_1_space_mappingX4 size
559624 , o_1_space_inserting size
560625 , o_1_space_insertingX4 size
561− , o_1_space_indexing size
562626 , o_1_space_indexingX4 size
627+#endif
563628 ]
564− , bgroup (o_n_space_prefix moduleName) $ Prelude.concat
565− [ o_n_space_traversable size
566− , o_n_space_mapping size
567− ]
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
568636 ]