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