@@ -8,6 +8,7 @@
8{-# LANGUAGE CPP #-}
8{-# LANGUAGE CPP #-}
9{-# LANGUAGE FlexibleContexts #-}
9{-# LANGUAGE FlexibleContexts #-}
10{-# LANGUAGE ScopedTypeVariables #-}
10{-# LANGUAGE ScopedTypeVariables #-}
11+{-# OPTIONS_GHC -Wno-orphans #-}
12#ifdef __HADDOCK_VERSION__
13#ifdef __HADDOCK_VERSION__
13#undef INSPECTION
14#undef INSPECTION
@@ -20,19 +21,23 @@
21module Main (main) where
22module Main (main) where
24+#if !MIN_VERSION_base(4,18,0)
25+import Control.Applicative (liftA2)
23import Control.Monad (when)
27import Control.Monad (when)
24import Data.Maybe (isJust)
28import Data.Maybe (isJust)
25import System.Random (randomRIO)
29import System.Random (randomRIO)
26import Prelude hiding
30import Prelude hiding
27− (tail, mapM_, foldl, last, map, mapM, concatMap, zip, init)
31+ ( Foldable(..), tail, mapM_, last, map, mapM, concatMap, zipWith, init, iterate
29import qualified Prelude as P
35import qualified Prelude as P
30import qualified Data.List as List
36import qualified Data.List as List
32−import qualified Streamly.Internal.Data.Stream.StreamK as S
38+import qualified Streamly.Internal.Data.StreamK as S
33−import qualified Streamly.Internal.Data.SVar as S
35−import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)
40+import Test.Tasty.Bench (bench, nfIO, bgroup, Benchmark, defaultMain)
37import Streamly.Benchmark.Common
42import Streamly.Benchmark.Common
@@ -40,70 +45,161 @@ import Streamly.Benchmark.Common
40import Test.Inspection
45import Test.Inspection
50+Benchmarks that need to be added
109+-- toStreamK (Probably can be skipped)
43-------------------------------------------------------------------------------
116-------------------------------------------------------------------------------
44-- Stream generation and elimination
117-- Stream generation and elimination
45-------------------------------------------------------------------------------
118-------------------------------------------------------------------------------
47−type Stream m a = S.Stream m a
120+type Stream m a = S.StreamK m a
49−{-# INLINE sourceUnfoldr #-}
122+{-# INLINE unfoldr #-}
50−sourceUnfoldr :: Int -> Int -> Stream m Int
123+unfoldr :: Int -> Int -> Stream m Int
51−sourceUnfoldr streamLen n = S.unfoldr step n
124+unfoldr streamLen n = S.unfoldr step n
53 step cnt =
126 step cnt =
54 if cnt > n + streamLen
127 if cnt > n + streamLen
55 then Nothing
128 then Nothing
56 else Just (cnt, cnt + 1)
129 else Just (cnt, cnt + 1)
58−{-# INLINE sourceUnfoldrM #-}
131+{-# INLINE unfoldrM #-}
59−sourceUnfoldrM :: S.MonadAsync m => Int -> Int -> Stream m Int
132+unfoldrM :: Monad m => Int -> Int -> Stream m Int
60−sourceUnfoldrM streamLen n = S.unfoldrM step n
133+unfoldrM streamLen n = S.unfoldrMWith S.consM step n
62 step cnt =
135 step cnt =
63 if cnt > n + streamLen
136 if cnt > n + streamLen
64 then return Nothing
137 then return Nothing
65 else return (Just (cnt, cnt + 1))
138 else return (Just (cnt, cnt + 1))
67−{-# INLINE sourceFromFoldable #-}
140+{-# INLINE repeat #-}
68−sourceFromFoldable :: Int -> Int -> Stream m Int
141+repeat :: Int -> Int -> Stream m Int
69−sourceFromFoldable streamLen n = S.fromFoldable [n..n+streamLen]
142+repeat streamLen = S.take streamLen . S.repeat
71−{-# INLINE sourceFromFoldableM #-}
144+{-# INLINE repeatM #-}
72−sourceFromFoldableM :: S.MonadAsync m => Int -> Int -> Stream m Int
145+repeatM :: Monad m => Int -> Int -> Stream m Int
73−sourceFromFoldableM streamLen n =
146+repeatM streamLen = S.take streamLen . S.repeatM . return
74− Prelude.foldr S.consM S.nil (Prelude.fmap return [n..n+streamLen])
76−{-# INLINABLE concatMapFoldableWith #-}
148+{-# INLINE replicate #-}
77−concatMapFoldableWith :: (S.IsStream t, Foldable f)
149+replicate :: Int -> Int -> Stream m Int
78− => (t m b -> t m b -> t m b) -> (a -> t m b) -> f a -> t m b
150+replicate = S.replicate
79−concatMapFoldableWith f g = Prelude.foldr (f . g) S.nil
151+
152+{-# INLINE replicateM #-}
153+replicateM :: Monad m => Int -> Int -> Stream m Int
154+replicateM streamLen = S.replicateMWith S.consM streamLen . return
81−{-# INLINE sourceFoldMapWith #-}
156+{-# INLINE iterate #-}
82−sourceFoldMapWith :: Int -> Int -> Stream m Int
157+iterate :: Int -> Int -> Stream m Int
83−sourceFoldMapWith streamLen n = concatMapFoldableWith S.serial S.yield [n..n+streamLen]
158+iterate streamLen = S.take streamLen . S.iterate (+1)
85−{-# INLINE sourceFoldMapWithM #-}
160+{-# INLINE iterateM #-}
161+iterateM :: Monad m => Int -> Int -> Stream m Int
162+iterateM streamLen = S.take streamLen . S.iterateM (return . (+1)) . return
164+{-# INLINE fromFoldable #-}
165+fromFoldable :: Int -> Int -> Stream m Int
166+fromFoldable streamLen n = S.fromFoldable [n..n+streamLen]
168+{-# INLINE fromFoldableM #-}
86−sourceFoldMapWithM :: Monad m => Int -> Int -> Stream m Int
169+fromFoldableM :: Monad m => Int -> Int -> Stream m Int
87−sourceFoldMapWithM streamLen n =
170+fromFoldableM streamLen n =
171+ List.foldr S.consM S.nil (Prelude.fmap return [n..n+streamLen])
173+{-# INLINABLE concatMapFoldableWith #-}
88− concatMapFoldableWith S.serial (S.yieldM . return) [n..n+streamLen]
174+concatMapFoldableWith :: P.Foldable f
175+ => (Stream m b -> Stream m b -> Stream m b)
176+ -> (a -> Stream m b)
179+concatMapFoldableWith f g = P.foldr (f . g) S.nil
181+{-# INLINE concatMapFoldableSerial #-}
182+concatMapFoldableSerial :: Int -> Int -> Stream m Int
183+concatMapFoldableSerial streamLen n =
184+ concatMapFoldableWith S.append S.fromPure [n..n+streamLen]
186+{-# INLINE concatMapFoldableSerialM #-}
187+concatMapFoldableSerialM :: Monad m => Int -> Int -> Stream m Int
188+concatMapFoldableSerialM streamLen n =
189+ concatMapFoldableWith S.append (S.fromEffect . return) [n..n+streamLen]
90-------------------------------------------------------------------------------
191-------------------------------------------------------------------------------
91-- Elimination
192-- Elimination
92-------------------------------------------------------------------------------
193-------------------------------------------------------------------------------
94−{-# INLINE runStream #-}
195+{-# INLINE drain #-}
95−runStream :: Monad m => Stream m a -> m ()
196+drain :: Monad m => Stream m a -> m ()
96−runStream = S.drain
197+drain = S.drain
97−-- runStream = S.mapM_ (\_ -> return ())
99{-# INLINE mapM_ #-}
199{-# INLINE mapM_ #-}
100mapM_ :: Monad m => Stream m a -> m ()
200mapM_ :: Monad m => Stream m a -> m ()
101mapM_ = S.mapM_ (\_ -> return ())
201mapM_ = S.mapM_ (\_ -> return ())
103−{-# INLINE toNull #-}
104−toNull :: Monad m => Stream m Int -> m ()
107{-# INLINE uncons #-}
203{-# INLINE uncons #-}
108uncons :: Monad m => Stream m Int -> m ()
204uncons :: Monad m => Stream m Int -> m ()
109uncons s = do
205uncons s = do
@@ -113,13 +209,13 @@ uncons s = do
113 Just (_, t) -> uncons t
209 Just (_, t) -> uncons t
115{-# INLINE init #-}
211{-# INLINE init #-}
116−init :: (Monad m, S.IsStream t) => t m a -> m ()
212+init :: Monad m => Stream m a -> m ()
117init s = do
213init s = do
118 t <- S.init s
214 t <- S.init s
119 P.mapM_ S.drain t
215 P.mapM_ S.drain t
121{-# INLINE tail #-}
217{-# INLINE tail #-}
122−tail :: (Monad m, S.IsStream t) => t m a -> m ()
218+tail :: Monad m => Stream m a -> m ()
123tail s = S.tail s >>= P.mapM_ tail
219tail s = S.tail s >>= P.mapM_ tail
125{-# INLINE nullTail #-}
221{-# INLINE nullTail #-}
@@ -138,9 +234,9 @@ headTail s = do
138toList :: Monad m => Stream m Int -> m [Int]
234toList :: Monad m => Stream m Int -> m [Int]
139toList = S.toList
235toList = S.toList
141−{-# INLINE foldl #-}
237+{-# INLINE foldl' #-}
142−foldl :: Monad m => Stream m Int -> m Int
238+foldl' :: Monad m => Stream m Int -> m Int
143−foldl = S.foldl' (+) 0
239+foldl' = S.foldl' (+) 0
145{-# INLINE last #-}
241{-# INLINE last #-}
146last :: Monad m => Stream m Int -> m (Maybe Int)
242last :: Monad m => Stream m Int -> m (Maybe Int)
@@ -150,40 +246,36 @@ last = S.last
150-- Transformation
246-- Transformation
151-------------------------------------------------------------------------------
247-------------------------------------------------------------------------------
153−{-# INLINE transform #-}
154−transform :: Monad m => Stream m a -> m ()
155−transform = runStream
157{-# INLINE composeN #-}
249{-# INLINE composeN #-}
159 :: Monad m
251 :: Monad m
160 => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()
252 => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()
161composeN n f =
253composeN n f =
162 case n of
254 case n of
163− 1 -> transform . f
255+ 1 -> drain . f
164− 2 -> transform . f . f
256+ 2 -> drain . f . f
165− 3 -> transform . f . f . f
257+ 3 -> drain . f . f . f
166− 4 -> transform . f . f . f . f
258+ 4 -> drain . f . f . f . f
167 _ -> undefined
259 _ -> undefined
169−{-# INLINE scan #-}
261+{-# INLINE scanl' #-}
170−scan :: Monad m => Int -> Stream m Int -> m ()
262+scanl' :: Monad m => Int -> Stream m Int -> m ()
171−scan n = composeN n $ S.scanl' (+) 0
263+scanl' n = composeN n $ S.scanl' (+) 0
173{-# INLINE map #-}
265{-# INLINE map #-}
174map :: Monad m => Int -> Stream m Int -> m ()
266map :: Monad m => Int -> Stream m Int -> m ()
175−map n = composeN n $ P.fmap (+ 1)
267+map n = composeN n $ S.map (+ 1)
177{-# INLINE fmapK #-}
269{-# INLINE fmapK #-}
178fmapK :: Monad m => Int -> Stream m Int -> m ()
270fmapK :: Monad m => Int -> Stream m Int -> m ()
179fmapK n = composeN n $ P.fmap (+ 1)
271fmapK n = composeN n $ P.fmap (+ 1)
181{-# INLINE mapM #-}
273{-# INLINE mapM #-}
182−mapM :: S.MonadAsync m => Int -> Stream m Int -> m ()
274+mapM :: Monad m => Int -> Stream m Int -> m ()
183−mapM n = composeN n $ S.mapM return
275+mapM n = composeN n $ S.mapMWith S.consM return
185{-# INLINE mapMSerial #-}
277{-# INLINE mapMSerial #-}
186−mapMSerial :: S.MonadAsync m => Int -> Stream m Int -> m ()
278+mapMSerial :: Monad m => Int -> Stream m Int -> m ()
187mapMSerial n = composeN n $ S.mapMSerial return
279mapMSerial n = composeN n $ S.mapMSerial return
189{-# INLINE filterEven #-}
281{-# INLINE filterEven #-}
@@ -235,7 +327,7 @@ foldlS :: Monad m => Int -> Stream m Int -> m ()
235foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil
327foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil
237{-# INLINE intersperse #-}
329{-# INLINE intersperse #-}
238−intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()
330+intersperse :: Monad m => Int -> Int -> Stream m Int -> m ()
239intersperse streamLen n = composeN n $ S.intersperse streamLen
331intersperse streamLen n = composeN n $ S.intersperse streamLen
241-------------------------------------------------------------------------------
333-------------------------------------------------------------------------------
@@ -244,51 +336,67 @@ intersperse streamLen n = composeN n $ S.intersperse streamLen
245{-# INLINE iterateSource #-}
337{-# INLINE iterateSource #-}
246iterateSource
338iterateSource
248− => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
339+ :: Monad m => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
249−iterateSource iterStreamLen g i n = f i (sourceUnfoldrM iterStreamLen n)
340+iterateSource iterStreamLen g i n = f i (unfoldrM iterStreamLen n)
251 f (0 :: Int) m = g m
342 f (0 :: Int) m = g m
252 f x m = g (f (x P.- 1) m)
343 f x m = g (f (x P.- 1) m)
254-- this is quadratic
345-- this is quadratic
255{-# INLINE iterateScan #-}
346{-# INLINE iterateScan #-}
256−iterateScan :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
347+iterateScan :: Monad m => Int -> Int -> Int -> Stream m Int
348+iterateScan iterStreamLen maxIters =
257−iterateScan iterStreamLen maxIters = iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)
349+ iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)
259-- this is quadratic
351-- this is quadratic
260{-# INLINE iterateDropWhileFalse #-}
352{-# INLINE iterateDropWhileFalse #-}
261−iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
353+iterateDropWhileFalse :: Monad m => Int -> Int -> Int -> Int -> Stream m Int
262iterateDropWhileFalse streamLen iterStreamLen maxIters =
354iterateDropWhileFalse streamLen iterStreamLen maxIters =
263 iterateSource iterStreamLen (S.dropWhile (> streamLen)) (maxIters `div` 10)
355 iterateSource iterStreamLen (S.dropWhile (> streamLen)) (maxIters `div` 10)
265{-# INLINE iterateMapM #-}
357{-# INLINE iterateMapM #-}
266−iterateMapM :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
358+iterateMapM :: Monad m => Int -> Int -> Int -> Stream m Int
359+iterateMapM iterStreamLen =
267−iterateMapM iterStreamLen maxIters = iterateSource iterStreamLen (S.mapM return) maxIters
360+ iterateSource iterStreamLen (S.mapMWith S.consM return)
269{-# INLINE iterateFilterEven #-}
362{-# INLINE iterateFilterEven #-}
270−iterateFilterEven :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
363+iterateFilterEven :: Monad m => Int -> Int -> Int -> Stream m Int
271−iterateFilterEven iterStreamLen maxIters = iterateSource iterStreamLen (S.filter even) maxIters
364+iterateFilterEven iterStreamLen = iterateSource iterStreamLen (S.filter even)
273{-# INLINE iterateTakeAll #-}
366{-# INLINE iterateTakeAll #-}
274−iterateTakeAll :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
367+iterateTakeAll :: Monad m => Int -> Int -> Int -> Int -> Stream m Int
368+iterateTakeAll streamLen iterStreamLen =
275−iterateTakeAll streamLen iterStreamLen maxIters = iterateSource iterStreamLen (S.take streamLen) maxIters
369+ iterateSource iterStreamLen (S.take streamLen)
277{-# INLINE iterateDropOne #-}
371{-# INLINE iterateDropOne #-}
278−iterateDropOne :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
372+iterateDropOne :: Monad m => Int -> Int -> Int -> Stream m Int
279−iterateDropOne iterStreamLen maxIters = iterateSource iterStreamLen (S.drop 1) maxIters
373+iterateDropOne iterStreamLen = iterateSource iterStreamLen (S.drop 1)
281{-# INLINE iterateDropWhileTrue #-}
375{-# INLINE iterateDropWhileTrue #-}
376+iterateDropWhileTrue ::
282−iterateDropWhileTrue :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
377+ Monad m => Int -> Int -> Int -> Int -> Stream m Int
378+iterateDropWhileTrue streamLen iterStreamLen =
283−iterateDropWhileTrue streamLen iterStreamLen maxIters = iterateSource iterStreamLen (S.dropWhile (<= streamLen)) maxIters
379+ iterateSource iterStreamLen (S.dropWhile (<= streamLen))
285-------------------------------------------------------------------------------
381-------------------------------------------------------------------------------
286-- Zipping
382-- Zipping
287-------------------------------------------------------------------------------
383-------------------------------------------------------------------------------
289−{-# INLINE zip #-}
385+{-# INLINE zipWith #-}
290−zip :: Monad m => Stream m Int -> m ()
386+zipWith :: Monad m => Stream m Int -> m ()
291−zip src = transform $ S.zipWith (,) src src
387+zipWith src = drain $ S.zipWith (,) src src
389+{-# INLINE zipWithM #-}
390+zipWithM :: Monad m => Stream m Int -> m ()
391+zipWithM src = drain $ S.zipWithM (curry return) src src
393+{-# INLINE sortByK #-}
394+sortByK :: (a -> a -> Ordering) -> Stream m a -> Stream m a
395+sortByK f = S.mergeMapWith (S.mergeBy f) S.fromPure
397+{-# INLINE sortBy #-}
398+sortBy :: Monad m => Stream m Int -> m ()
399+sortBy = drain . sortByK compare
293-------------------------------------------------------------------------------
401-------------------------------------------------------------------------------
294-- Mixed Composition
402-- Mixed Composition
@@ -326,10 +434,9 @@ filterDrop streamLen n = composeN n $ S.drop 1 . S.filter (<= streamLen)
326filterTake :: Monad m => Int -> Int -> Stream m Int -> m ()
434filterTake :: Monad m => Int -> Int -> Stream m Int -> m ()
327filterTake streamLen n = composeN n $ S.take streamLen . S.filter (<= streamLen)
435filterTake streamLen n = composeN n $ S.take streamLen . S.filter (<= streamLen)
329−-- Initially, this used maxBound not streamLen
330{-# INLINE filterScan #-}
437{-# INLINE filterScan #-}
331−filterScan :: Monad m => Int -> Int -> Stream m Int -> m ()
438+filterScan :: Monad m => Int -> Stream m Int -> m ()
332−filterScan streamLen n = composeN n $ S.scanl' (+) 0 . S.filter (<= streamLen)
439+filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
334{-# INLINE filterMap #-}
441{-# INLINE filterMap #-}
335filterMap :: Monad m => Int -> Int -> Stream m Int -> m ()
442filterMap :: Monad m => Int -> Int -> Stream m Int -> m ()
@@ -345,8 +452,8 @@ filterMap streamLen n = composeN n $ S.map (subtract 1) . S.filter (<= streamLen
345concatMap :: Int -> Int -> Int -> IO ()
452concatMap :: Int -> Int -> Int -> IO ()
346concatMap outer inner n =
453concatMap outer inner n =
347 S.drain $ S.concatMap
454 S.drain $ S.concatMap
348− (\_ -> sourceUnfoldrM inner n)
455+ (\_ -> unfoldrM inner n)
349− (sourceUnfoldrM outer n)
456+ (unfoldrM outer n)
351#ifdef INSPECTION
458#ifdef INSPECTION
352inspect $ hasNoTypeClasses 'concatMap
459inspect $ hasNoTypeClasses 'concatMap
@@ -358,8 +465,8 @@ inspect $ hasNoTypeClasses 'concatMap
358concatMapPure :: Int -> Int -> Int -> IO ()
465concatMapPure :: Int -> Int -> Int -> IO ()
359concatMapPure outer inner n =
466concatMapPure outer inner n =
360 S.drain $ S.concatMap
467 S.drain $ S.concatMap
361− (\_ -> sourceUnfoldr inner n)
468+ (\_ -> unfoldr inner n)
362− (sourceUnfoldr outer n)
469+ (unfoldr outer n)
364#ifdef INSPECTION
471#ifdef INSPECTION
365inspect $ hasNoTypeClasses 'concatMapPure
472inspect $ hasNoTypeClasses 'concatMapPure
@@ -370,7 +477,7 @@ inspect $ hasNoTypeClasses 'concatMapPure
370{-# INLINE concatMapRepl #-}
477{-# INLINE concatMapRepl #-}
371concatMapRepl :: Int -> Int -> Int -> IO ()
478concatMapRepl :: Int -> Int -> Int -> IO ()
372concatMapRepl outer inner n =
479concatMapRepl outer inner n =
373− S.drain $ S.concatMap (S.replicate inner) (sourceUnfoldrM outer n)
480+ S.drain $ S.concatMap (S.replicate inner) (unfoldrM outer n)
375#ifdef INSPECTION
482#ifdef INSPECTION
376inspect $ hasNoTypeClasses 'concatMapRepl
483inspect $ hasNoTypeClasses 'concatMapRepl
@@ -382,44 +489,70 @@ inspect $ hasNoTypeClasses 'concatMapRepl
382sourceConcatMapId :: Monad m
489sourceConcatMapId :: Monad m
383 => Int -> Int -> Stream m (Stream m Int)
490 => Int -> Int -> Stream m (Stream m Int)
384sourceConcatMapId val n =
491sourceConcatMapId val n =
385− S.fromFoldable $ fmap (S.yieldM . return) [n..n+val]
492+ S.fromFoldable $ fmap (S.fromEffect . return) [n..n+val]
387−{-# INLINE concatStreamsWith #-}
494+{-# INLINE concatMapBySerial #-}
388−concatStreamsWith :: Int -> Int -> Int -> IO ()
495+concatMapBySerial :: Int -> Int -> Int -> IO ()
389−concatStreamsWith outer inner n =
496+concatMapBySerial outer inner n =
390− S.drain $ S.concatMapBy S.serial
497+ S.drain $ S.concatMapWith S.append
391− (sourceUnfoldrM inner)
498+ (unfoldrM inner)
392− (sourceUnfoldrM outer n)
499+ (unfoldrM outer n)
394-------------------------------------------------------------------------------
501-------------------------------------------------------------------------------
395-- Nested Composition
502-- Nested Composition
396-------------------------------------------------------------------------------
503-------------------------------------------------------------------------------
398−{-# INLINE toNullApNested #-}
505+instance Monad m => Applicative (S.StreamK m) where
509+ {-# INLINE (<*>) #-}
510+ (<*>) = S.crossApply
512+ {-# INLINE liftA2 #-}
513+ liftA2 f x = (<*>) (fmap f x)
516+ (*>) = S.crossApplySnd
519+ (<*) = S.crossApplyFst
521+-- NOTE: even though concatMap for StreamD is 3x faster compared to StreamK,
522+-- the monad instance of StreamD is slower than StreamK after foldr/build
524+instance Monad m => Monad (S.StreamK m) where
525+ {-# INLINE return #-}
528+ {-# INLINE (>>=) #-}
529+ (>>=) = flip S.concatMap
531+{-# INLINE drainApplicative #-}
399−toNullApNested :: Monad m => Stream m Int -> m ()
532+drainApplicative :: Monad m => Stream m Int -> m ()
400−toNullApNested s = runStream $ do
533+drainApplicative s = drain $ do
401 (+) <$> s <*> s
534 (+) <$> s <*> s
403−{-# INLINE toNullNested #-}
536+{-# INLINE drainMonad #-}
404−toNullNested :: Monad m => Stream m Int -> m ()
537+drainMonad :: Monad m => Stream m Int -> m ()
405−toNullNested s = runStream $ do
538+drainMonad s = drain $ do
408 return $ x + y
541 return $ x + y
410−{-# INLINE toNullNested3 #-}
543+{-# INLINE drainMonad3 #-}
411−toNullNested3 :: Monad m => Stream m Int -> m ()
544+drainMonad3 :: Monad m => Stream m Int -> m ()
412−toNullNested3 s = runStream $ do
545+drainMonad3 s = drain $ do
416 return $ x + y + z
549 return $ x + y + z
418−{-# INLINE filterAllOutNested #-}
551+{-# INLINE filterAllOutMonad #-}
419−filterAllOutNested
552+filterAllOutMonad
420 :: Monad m
553 :: Monad m
421 => Stream m Int -> m ()
554 => Stream m Int -> m ()
422−filterAllOutNested str = runStream $ do
555+filterAllOutMonad str = drain $ do
425 let s = x + y
558 let s = x + y
@@ -427,11 +560,11 @@ filterAllOutNested str = runStream $ do
427 then return s
560 then return s
428 else S.nil
561 else S.nil
430−{-# INLINE filterAllInNested #-}
563+{-# INLINE filterAllInMonad #-}
431−filterAllInNested
564+filterAllInMonad
432 :: Monad m
565 :: Monad m
433 => Stream m Int -> m ()
566 => Stream m Int -> m ()
434−filterAllInNested str = runStream $ do
567+filterAllInMonad str = drain $ do
437 let s = x + y
570 let s = x + y
@@ -443,9 +576,14 @@ filterAllInNested str = runStream $ do
443-- Nested Composition Pure lists
576-- Nested Composition Pure lists
444-------------------------------------------------------------------------------
577-------------------------------------------------------------------------------
446−{-# INLINE sourceUnfoldrList #-}
579+-- There are several list benchmarks here for comparison with lists. It is easy
447−sourceUnfoldrList :: Int -> Int -> [Int]
580+-- and convenient to see the comparisons when they are here, otherwise we'll
581+-- have to add a separate module for list benchmarks with the same names and
582+-- then add a comparison in bench.sh.
584+{-# INLINE unfoldrList #-}
585+unfoldrList :: Int -> Int -> [Int]
448−sourceUnfoldrList maxval n = List.unfoldr step n
586+unfoldrList maxval n = List.unfoldr step n
450 step cnt =
588 step cnt =
451 if cnt > n + maxval
589 if cnt > n + maxval
@@ -496,46 +634,52 @@ filterAllInNestedList str = do
496-------------------------------------------------------------------------------
634-------------------------------------------------------------------------------
498moduleName :: String
636moduleName :: String
499−moduleName = "Data.Stream.StreamK"
637+moduleName = "Data.StreamK"
501o_1_space_generation :: Int -> Benchmark
639o_1_space_generation :: Int -> Benchmark
502o_1_space_generation streamLen =
640o_1_space_generation streamLen =
503 bgroup "generation"
641 bgroup "generation"
504− [ benchFold "unfoldr" toNull (sourceUnfoldr streamLen)
642+ [ benchFold "unfoldr" drain (unfoldr streamLen)
505− , benchFold "unfoldrM" toNull (sourceUnfoldrM streamLen)
643+ , benchFold "unfoldrM" drain (unfoldrM streamLen)
506−
644+ , benchFold "repeat" drain (repeat streamLen)
645+ , benchFold "repeatM" drain (repeatM streamLen)
646+ , benchFold "replicate" drain (replicate streamLen)
647+ , benchFold "replicateM" drain (replicateM streamLen)
648+ , benchFold "iterate" drain (iterate streamLen)
649+ , benchFold "iterateM" drain (iterateM streamLen)
507− , benchFold "fromFoldable" toNull (sourceFromFoldable streamLen)
651+ , benchFold "fromFoldable" drain (fromFoldable streamLen)
508− , benchFold "fromFoldableM" toNull (sourceFromFoldableM streamLen)
652+ , benchFold "fromFoldableM" drain (fromFoldableM streamLen)
510 -- appends
654 -- appends
511− , benchFold "concatMapFoldableWith" toNull (sourceFoldMapWith streamLen)
655+ , benchFold "concatMapFoldableWith" drain (concatMapFoldableSerial streamLen)
512− , benchFold "concatMapFoldableWithM" toNull (sourceFoldMapWithM streamLen)
656+ , benchFold "concatMapFoldableWithM" drain (concatMapFoldableSerialM streamLen)
515o_1_space_elimination :: Int -> Benchmark
659o_1_space_elimination :: Int -> Benchmark
516o_1_space_elimination streamLen =
660o_1_space_elimination streamLen =
517 bgroup "elimination"
661 bgroup "elimination"
518− [ benchFold "toNull" toNull (sourceUnfoldrM streamLen)
662+ [ benchFold "toNull" drain (unfoldrM streamLen)
519− , benchFold "mapM_" mapM_ (sourceUnfoldrM streamLen)
663+ , benchFold "mapM_" mapM_ (unfoldrM streamLen)
520− , benchFold "uncons" uncons (sourceUnfoldrM streamLen)
664+ , benchFold "uncons" uncons (unfoldrM streamLen)
521− , benchFold "init" init (sourceUnfoldrM streamLen)
665+ , benchFold "init" init (unfoldrM streamLen)
522− , benchFold "foldl'" foldl (sourceUnfoldrM streamLen)
666+ , benchFold "foldl'" foldl' (unfoldrM streamLen)
523− , benchFold "last" last (sourceUnfoldrM streamLen)
667+ , benchFold "last" last (unfoldrM streamLen)
526o_1_space_nested :: Int -> Benchmark
670o_1_space_nested :: Int -> Benchmark
527o_1_space_nested streamLen =
671o_1_space_nested streamLen =
528 bgroup "nested"
672 bgroup "nested"
529− [ benchFold "toNullAp" toNullApNested (sourceUnfoldrM streamLen2)
673+ [ benchFold "drainApplicative" drainApplicative (unfoldrM streamLen2)
530− , benchFold "toNull" toNullNested (sourceUnfoldrM streamLen2)
674+ , benchFold "drainMonad" drainMonad (unfoldrM streamLen2)
531− , benchFold "toNull3" toNullNested3 (sourceUnfoldrM streamLen3)
675+ , benchFold "drainMonad3" drainMonad3 (unfoldrM streamLen3)
532− , benchFold "filterAllIn" filterAllInNested (sourceUnfoldrM streamLen2)
676+ , benchFold "filterAllInMonad" filterAllInMonad (unfoldrM streamLen2)
533− , benchFold "filterAllOut" filterAllOutNested (sourceUnfoldrM streamLen2)
677+ , benchFold "filterAllOutMonad" filterAllOutMonad (unfoldrM streamLen2)
534− , benchFold "toNullApPure" toNullApNested (sourceUnfoldr streamLen2)
678+ , benchFold "drainApplicative (pure)" drainApplicative (unfoldr streamLen2)
535− , benchFold "toNullPure" toNullNested (sourceUnfoldr streamLen2)
679+ , benchFold "drainMonad (pure)" drainMonad (unfoldr streamLen2)
536− , benchFold "toNull3Pure" toNullNested3 (sourceUnfoldr streamLen3)
680+ , benchFold "drainMonad3 (pure)" drainMonad3 (unfoldr streamLen3)
537− , benchFold "filterAllInPure" filterAllInNested (sourceUnfoldr streamLen2)
681+ , benchFold "filterAllInMonad (pure)" filterAllInMonad (unfoldr streamLen2)
538− , benchFold "filterAllOutPure" filterAllOutNested (sourceUnfoldr streamLen2)
682+ , benchFold "filterAllOutMonad (pure)" filterAllOutMonad (unfoldr streamLen2)
541 streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
685 streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
@@ -544,24 +688,25 @@ o_1_space_nested streamLen =
544o_1_space_transformation :: Int -> Benchmark
688o_1_space_transformation :: Int -> Benchmark
545o_1_space_transformation streamLen =
689o_1_space_transformation streamLen =
546 bgroup "transformation"
690 bgroup "transformation"
548− [ benchFold "foldrS" (foldrS 1) (sourceUnfoldrM streamLen)
691+ [ benchFold "foldrS" (foldrS 1) (unfoldrM streamLen)
549− , benchFold "scan" (scan 1) (sourceUnfoldrM streamLen)
692+ , benchFold "scanl'" (scanl' 1) (unfoldrM streamLen)
550− , benchFold "map" (map 1) (sourceUnfoldrM streamLen)
693+ , benchFold "map" (map 1) (unfoldrM streamLen)
551− , benchFold "fmap" (fmapK 1) (sourceUnfoldrM streamLen)
694+ , benchFold "fmap" (fmapK 1) (unfoldrM streamLen)
552− , benchFold "mapM" (mapM 1) (sourceUnfoldrM streamLen)
695+ , benchFold "mapM" (mapM 1) (unfoldrM streamLen)
553− , benchFold "mapMSerial" (mapMSerial 1) (sourceUnfoldrM streamLen)
696+ , benchFold "mapMSerial" (mapMSerial 1) (unfoldrM streamLen)
699+o_1_space_transformationX4 :: Int -> Benchmark
700+o_1_space_transformationX4 streamLen =
555− , bgroup "X4"
701+ bgroup "transformationX4"
556− [ benchFold "scan" (scan 4) (sourceUnfoldrM streamLen)
702+ [ benchFold "scanl'" (scanl' 4) (unfoldrM streamLen)
557− , benchFold "map" (map 4) (sourceUnfoldrM streamLen)
703+ , benchFold "map" (map 4) (unfoldrM streamLen)
558− , benchFold "fmap" (fmapK 4) (sourceUnfoldrM streamLen)
704+ , benchFold "fmap" (fmapK 4) (unfoldrM streamLen)
559− , benchFold "mapM" (mapM 4) (sourceUnfoldrM streamLen)
705+ , benchFold "mapM" (mapM 4) (unfoldrM streamLen)
560− , benchFold "mapMSerial" (mapMSerial 4) (sourceUnfoldrM streamLen)
706+ , benchFold "mapMSerial" (mapMSerial 4) (unfoldrM streamLen)
561 -- XXX this is horribly slow
707 -- XXX this is horribly slow
562− -- , benchFold "concatMap" (concatMap 4) (sourceUnfoldrM streamLen16)
708+ -- , benchFold "concatMap" (concatMap 4) (unfoldrM streamLen16)
566o_1_space_concat :: Int -> Benchmark
711o_1_space_concat :: Int -> Benchmark
567o_1_space_concat streamLen =
712o_1_space_concat streamLen =
@@ -585,14 +730,17 @@ o_1_space_concat streamLen =
586 -- This is for comparison with concatMapFoldableWith
731 -- This is for comparison with concatMapFoldableWith
587 , benchIOSrc1 "concatMapWithId (n of 1) (fromFoldable)"
732 , benchIOSrc1 "concatMapWithId (n of 1) (fromFoldable)"
734+ . S.concatMapWith S.append id
588− (S.drain . S.concatMapBy S.serial id . sourceConcatMapId streamLen)
735+ . sourceConcatMapId streamLen)
590− , benchIOSrc1 "concatMapWith (n of 1)"
737+ , benchIOSrc1 "concatMapBy serial (n of 1)"
591− (concatStreamsWith streamLen 1)
738+ (concatMapBySerial streamLen 1)
592− , benchIOSrc1 "concatMapWith (sqrt n of sqrt n)"
739+ , benchIOSrc1 "concatMapBy serial (sqrt n of sqrt n)"
593− (concatStreamsWith streamLen2 streamLen2)
740+ (concatMapBySerial streamLen2 streamLen2)
594− , benchIOSrc1 "concatMapWith (1 of n)"
741+ , benchIOSrc1 "concatMapBy serial (1 of n)"
595− (concatStreamsWith 1 streamLen)
742+ (concatMapBySerial 1 streamLen)
743+ , benchFold "sortBy" sortBy (unfoldrM streamLen)
598 streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
746 streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
@@ -600,89 +748,95 @@ o_1_space_concat streamLen =
600o_1_space_filtering :: Int -> Benchmark
748o_1_space_filtering :: Int -> Benchmark
601o_1_space_filtering streamLen =
749o_1_space_filtering streamLen =
602 bgroup "filtering"
750 bgroup "filtering"
604− [ benchFold "filter-even" (filterEven 1) (sourceUnfoldrM streamLen)
751+ [ benchFold "filter-even" (filterEven 1) (unfoldrM streamLen)
605− , benchFold "filter-all-out" (filterAllOut streamLen 1) (sourceUnfoldrM streamLen)
752+ , benchFold "filter-all-out" (filterAllOut streamLen 1) (unfoldrM streamLen)
606− , benchFold "filter-all-in" (filterAllIn streamLen 1) (sourceUnfoldrM streamLen)
753+ , benchFold "filter-all-in" (filterAllIn streamLen 1) (unfoldrM streamLen)
607− , benchFold "take-all" (takeAll streamLen 1) (sourceUnfoldrM streamLen)
754+ , benchFold "take-all" (takeAll streamLen 1) (unfoldrM streamLen)
608− , benchFold "takeWhile-true" (takeWhileTrue streamLen 1) (sourceUnfoldrM streamLen)
755+ , benchFold "takeWhile-true" (takeWhileTrue streamLen 1) (unfoldrM streamLen)
609− , benchFold "drop-one" (dropOne 1) (sourceUnfoldrM streamLen)
756+ , benchFold "drop-one" (dropOne 1) (unfoldrM streamLen)
610− , benchFold "drop-all" (dropAll streamLen 1) (sourceUnfoldrM streamLen)
757+ , benchFold "drop-all" (dropAll streamLen 1) (unfoldrM streamLen)
611− , benchFold "dropWhile-true" (dropWhileTrue streamLen 1) (sourceUnfoldrM streamLen)
758+ , benchFold "dropWhile-true" (dropWhileTrue streamLen 1) (unfoldrM streamLen)
612− , benchFold "dropWhile-false" (dropWhileFalse 1) (sourceUnfoldrM streamLen)
759+ , benchFold "dropWhile-false" (dropWhileFalse 1) (unfoldrM streamLen)
762+o_1_space_filteringX4 :: Int -> Benchmark
763+o_1_space_filteringX4 streamLen =
614− , bgroup "X4"
764+ bgroup "filteringX4"
615− [ benchFold "filter-even" (filterEven 4) (sourceUnfoldrM streamLen)
765+ [ benchFold "filter-even" (filterEven 4) (unfoldrM streamLen)
616− , benchFold "filter-all-out" (filterAllOut streamLen 4) (sourceUnfoldrM streamLen)
766+ , benchFold "filter-all-out" (filterAllOut streamLen 4) (unfoldrM streamLen)
617− , benchFold "filter-all-in" (filterAllIn streamLen 4) (sourceUnfoldrM streamLen)
767+ , benchFold "filter-all-in" (filterAllIn streamLen 4) (unfoldrM streamLen)
618− , benchFold "take-all" (takeAll streamLen 4) (sourceUnfoldrM streamLen)
768+ , benchFold "take-all" (takeAll streamLen 4) (unfoldrM streamLen)
619− , benchFold "takeWhile-true" (takeWhileTrue streamLen 4) (sourceUnfoldrM streamLen)
769+ , benchFold "takeWhile-true" (takeWhileTrue streamLen 4) (unfoldrM streamLen)
620− , benchFold "drop-one" (dropOne 4) (sourceUnfoldrM streamLen)
770+ , benchFold "drop-one" (dropOne 4) (unfoldrM streamLen)
621− , benchFold "drop-all" (dropAll streamLen 4) (sourceUnfoldrM streamLen)
771+ , benchFold "drop-all" (dropAll streamLen 4) (unfoldrM streamLen)
622− , benchFold "dropWhile-true" (dropWhileTrue streamLen 4) (sourceUnfoldrM streamLen)
772+ , benchFold "dropWhile-true" (dropWhileTrue streamLen 4) (unfoldrM streamLen)
623− , benchFold "dropWhile-false" (dropWhileFalse 4) (sourceUnfoldrM streamLen)
773+ , benchFold "dropWhile-false" (dropWhileFalse 4) (unfoldrM streamLen)
627o_1_space_zipping :: Int -> Benchmark
776o_1_space_zipping :: Int -> Benchmark
628o_1_space_zipping streamLen =
777o_1_space_zipping streamLen =
629 bgroup "zipping"
778 bgroup "zipping"
630− [ benchFold "zip" zip (sourceUnfoldrM streamLen)
779+ [ benchFold "zipWith" zipWith (unfoldrM streamLen)
780+ , benchFold "zipWithM" zipWithM (unfoldrM streamLen)
633o_1_space_mixed :: Int -> Benchmark
783o_1_space_mixed :: Int -> Benchmark
634o_1_space_mixed streamLen =
784o_1_space_mixed streamLen =
635 bgroup "mixed"
785 bgroup "mixed"
637− [ benchFold "scan-map" (scanMap 1) (sourceUnfoldrM streamLen)
786+ [ benchFold "scan-map" (scanMap 1) (unfoldrM streamLen)
638− , benchFold "drop-map" (dropMap 1) (sourceUnfoldrM streamLen)
787+ , benchFold "drop-map" (dropMap 1) (unfoldrM streamLen)
639− , benchFold "drop-scan" (dropScan 1) (sourceUnfoldrM streamLen)
788+ , benchFold "drop-scan" (dropScan 1) (unfoldrM streamLen)
640− , benchFold "take-drop" (takeDrop streamLen 1) (sourceUnfoldrM streamLen)
789+ , benchFold "take-drop" (takeDrop streamLen 1) (unfoldrM streamLen)
641− , benchFold "take-scan" (takeScan streamLen 1) (sourceUnfoldrM streamLen)
790+ , benchFold "take-scan" (takeScan streamLen 1) (unfoldrM streamLen)
642− , benchFold "take-map" (takeMap streamLen 1) (sourceUnfoldrM streamLen)
791+ , benchFold "take-map" (takeMap streamLen 1) (unfoldrM streamLen)
643− , benchFold "filter-drop" (filterDrop streamLen 1) (sourceUnfoldrM streamLen)
792+ , benchFold "filter-drop" (filterDrop streamLen 1) (unfoldrM streamLen)
644− , benchFold "filter-take" (filterTake streamLen 1) (sourceUnfoldrM streamLen)
793+ , benchFold "filter-take" (filterTake streamLen 1) (unfoldrM streamLen)
645− , benchFold "filter-scan" (filterScan streamLen 1) (sourceUnfoldrM streamLen)
794+ , benchFold "filter-scan" (filterScan 1) (unfoldrM streamLen)
646− , benchFold "filter-map" (filterMap streamLen 1) (sourceUnfoldrM streamLen)
795+ , benchFold "filter-map" (filterMap streamLen 1) (unfoldrM streamLen)
798+o_1_space_mixedX2 :: Int -> Benchmark
799+o_1_space_mixedX2 streamLen =
648− , bgroup "X2"
800+ bgroup "mixedX2"
649− [ benchFold "scan-map" (scanMap 2) (sourceUnfoldrM streamLen)
801+ [ benchFold "scan-map" (scanMap 2) (unfoldrM streamLen)
650− , benchFold "drop-map" (dropMap 2) (sourceUnfoldrM streamLen)
802+ , benchFold "drop-map" (dropMap 2) (unfoldrM streamLen)
651− , benchFold "drop-scan" (dropScan 2) (sourceUnfoldrM streamLen)
803+ , benchFold "drop-scan" (dropScan 2) (unfoldrM streamLen)
652− , benchFold "take-drop" (takeDrop streamLen 2) (sourceUnfoldrM streamLen)
804+ , benchFold "take-drop" (takeDrop streamLen 2) (unfoldrM streamLen)
653− , benchFold "take-scan" (takeScan streamLen 2) (sourceUnfoldrM streamLen)
805+ , benchFold "take-scan" (takeScan streamLen 2) (unfoldrM streamLen)
654− , benchFold "take-map" (takeMap streamLen 2) (sourceUnfoldrM streamLen)
806+ , benchFold "take-map" (takeMap streamLen 2) (unfoldrM streamLen)
655− , benchFold "filter-drop" (filterDrop streamLen 2) (sourceUnfoldrM streamLen)
807+ , benchFold "filter-drop" (filterDrop streamLen 2) (unfoldrM streamLen)
656− , benchFold "filter-take" (filterTake streamLen 2) (sourceUnfoldrM streamLen)
808+ , benchFold "filter-take" (filterTake streamLen 2) (unfoldrM streamLen)
657− , benchFold "filter-scan" (filterScan streamLen 2) (sourceUnfoldrM streamLen)
809+ , benchFold "filter-scan" (filterScan 2) (unfoldrM streamLen)
658− , benchFold "filter-map" (filterMap streamLen 2) (sourceUnfoldrM streamLen)
810+ , benchFold "filter-map" (filterMap streamLen 2) (unfoldrM streamLen)
813+o_1_space_mixedX4 :: Int -> Benchmark
814+o_1_space_mixedX4 streamLen =
660− , bgroup "X4"
815+ bgroup "mixedX4"
661− [ benchFold "scan-map" (scanMap 4) (sourceUnfoldrM streamLen)
816+ [ benchFold "scan-map" (scanMap 4) (unfoldrM streamLen)
662− , benchFold "drop-map" (dropMap 4) (sourceUnfoldrM streamLen)
817+ , benchFold "drop-map" (dropMap 4) (unfoldrM streamLen)
663− , benchFold "drop-scan" (dropScan 4) (sourceUnfoldrM streamLen)
818+ , benchFold "drop-scan" (dropScan 4) (unfoldrM streamLen)
664− , benchFold "take-drop" (takeDrop streamLen 4) (sourceUnfoldrM streamLen)
819+ , benchFold "take-drop" (takeDrop streamLen 4) (unfoldrM streamLen)
665− , benchFold "take-scan" (takeScan streamLen 4) (sourceUnfoldrM streamLen)
820+ , benchFold "take-scan" (takeScan streamLen 4) (unfoldrM streamLen)
666− , benchFold "take-map" (takeMap streamLen 4) (sourceUnfoldrM streamLen)
821+ , benchFold "take-map" (takeMap streamLen 4) (unfoldrM streamLen)
667− , benchFold "filter-drop" (filterDrop streamLen 4) (sourceUnfoldrM streamLen)
822+ , benchFold "filter-drop" (filterDrop streamLen 4) (unfoldrM streamLen)
668− , benchFold "filter-take" (filterTake streamLen 4) (sourceUnfoldrM streamLen)
823+ , benchFold "filter-take" (filterTake streamLen 4) (unfoldrM streamLen)
669− , benchFold "filter-scan" (filterScan streamLen 4) (sourceUnfoldrM streamLen)
824+ , benchFold "filter-scan" (filterScan 4) (unfoldrM streamLen)
670− , benchFold "filter-map" (filterMap streamLen 4) (sourceUnfoldrM streamLen)
825+ , benchFold "filter-map" (filterMap streamLen 4) (unfoldrM streamLen)
674o_1_space_list :: Int -> Benchmark
828o_1_space_list :: Int -> Benchmark
675o_1_space_list streamLen =
829o_1_space_list streamLen =
676 bgroup "list"
830 bgroup "list"
677 [ bgroup "elimination"
831 [ bgroup "elimination"
678− [ benchList "last" (\xs -> [List.last xs]) (sourceUnfoldrList streamLen)
832+ [ benchList "last" (\xs -> [List.last xs]) (unfoldrList streamLen)
680 , bgroup "nested"
834 , bgroup "nested"
681− [ benchList "toNullAp" toNullApNestedList (sourceUnfoldrList streamLen2)
835+ [ benchList "toNullAp" toNullApNestedList (unfoldrList streamLen2)
682− , benchList "toNull" toNullNestedList (sourceUnfoldrList streamLen2)
836+ , benchList "toNull" toNullNestedList (unfoldrList streamLen2)
683− , benchList "toNull3" toNullNestedList3 (sourceUnfoldrList streamLen3)
837+ , benchList "toNull3" toNullNestedList3 (unfoldrList streamLen3)
684− , benchList "filterAllIn" filterAllInNestedList (sourceUnfoldrList streamLen2)
838+ , benchList "filterAllIn" filterAllInNestedList (unfoldrList streamLen2)
685− , benchList "filterAllOut" filterAllOutNestedList (sourceUnfoldrList streamLen2)
839+ , benchList "filterAllOut" filterAllOutNestedList (unfoldrList streamLen2)
@@ -697,10 +851,14 @@ o_1_space streamLen =
697 , o_1_space_elimination streamLen
851 , o_1_space_elimination streamLen
698 , o_1_space_nested streamLen
852 , o_1_space_nested streamLen
699 , o_1_space_transformation streamLen
853 , o_1_space_transformation streamLen
854+ , o_1_space_transformationX4 streamLen
700 , o_1_space_concat streamLen
855 , o_1_space_concat streamLen
701 , o_1_space_filtering streamLen
856 , o_1_space_filtering streamLen
857+ , o_1_space_filteringX4 streamLen
702 , o_1_space_zipping streamLen
858 , o_1_space_zipping streamLen
703 , o_1_space_mixed streamLen
859 , o_1_space_mixed streamLen
860+ , o_1_space_mixedX2 streamLen
861+ , o_1_space_mixedX4 streamLen
704 , o_1_space_list streamLen
862 , o_1_space_list streamLen
@@ -708,31 +866,31 @@ o_n_heap :: Int -> Benchmark
708o_n_heap streamLen =
866o_n_heap streamLen =
709 bgroup (o_n_heap_prefix moduleName)
867 bgroup (o_n_heap_prefix moduleName)
710 [ bgroup "transformation"
868 [ bgroup "transformation"
711− [ benchFold "foldlS" (foldlS 1) (sourceUnfoldrM streamLen)
869+ [ benchFold "foldlS" (foldlS 1) (unfoldrM streamLen)
715{-# INLINE benchK #-}
873{-# INLINE benchK #-}
716benchK :: P.String -> (Int -> Stream P.IO Int) -> Benchmark
874benchK :: P.String -> (Int -> Stream P.IO Int) -> Benchmark
717−benchK name f = bench name $ nfIO $ randomRIO (1,1) >>= toNull . f
875+benchK name f = bench name $ nfIO $ randomRIO (1,1) >>= drain . f
719o_n_stack :: Int -> Int -> Int -> Benchmark
877o_n_stack :: Int -> Int -> Int -> Benchmark
720o_n_stack streamLen iterStreamLen maxIters =
878o_n_stack streamLen iterStreamLen maxIters =
721 bgroup (o_n_stack_prefix moduleName)
879 bgroup (o_n_stack_prefix moduleName)
722 [ bgroup "elimination"
880 [ bgroup "elimination"
723− [ benchFold "tail" tail (sourceUnfoldrM streamLen)
881+ [ benchFold "tail" tail (unfoldrM streamLen)
724− , benchFold "nullTail" nullTail (sourceUnfoldrM streamLen)
882+ , benchFold "nullTail" nullTail (unfoldrM streamLen)
725− , benchFold "headTail" headTail (sourceUnfoldrM streamLen)
883+ , benchFold "headTail" headTail (unfoldrM streamLen)
727 , bgroup "transformation"
885 , bgroup "transformation"
729 -- XXX why do these need so much stack
887 -- XXX why do these need so much stack
730− benchFold "intersperse" (intersperse streamLen 1) (sourceUnfoldrM streamLen2)
888+ benchFold "intersperse" (intersperse streamLen 1) (unfoldrM streamLen2)
731− , benchFold "interspersePure" (intersperse streamLen 1) (sourceUnfoldr streamLen2)
889+ , benchFold "interspersePure" (intersperse streamLen 1) (unfoldr streamLen2)
733 , bgroup "transformationX4"
891 , bgroup "transformationX4"
735− benchFold "intersperse" (intersperse streamLen 4) (sourceUnfoldrM streamLen16)
893+ benchFold "intersperse" (intersperse streamLen 4) (unfoldrM streamLen16)
737 , bgroup "iterated"
895 , bgroup "iterated"
738 [ benchK "mapM" (iterateMapM iterStreamLen maxIters)
896 [ benchK "mapM" (iterateMapM iterStreamLen maxIters)
@@ -752,7 +910,7 @@ o_n_space :: Int -> Benchmark
752o_n_space streamLen =
910o_n_space streamLen =
753 bgroup (o_n_space_prefix moduleName)
911 bgroup (o_n_space_prefix moduleName)
754 [ bgroup "elimination"
912 [ bgroup "elimination"
755− [ benchFold "toList" toList (sourceUnfoldrM streamLen)
913+ [ benchFold "toList" toList (unfoldrM streamLen)