@@ -8,7 +8,6 @@
88{-# LANGUAGE CPP #-}
99{-# LANGUAGE FlexibleContexts #-}
1010{-# LANGUAGE ScopedTypeVariables #-}
11−{-# OPTIONS_GHC -Wno-orphans #-}
1211
1312#ifdef __HADDOCK_VERSION__
1413#undef INSPECTION
@@ -21,23 +20,19 @@
2120
2221module Main (main) where
2322
24−#if !MIN_VERSION_base(4,18,0)
25−import Control.Applicative (liftA2)
26−#endif
2723import Control.Monad (when)
2824import Data.Maybe (isJust)
2925import System.Random (randomRIO)
3026import Prelude hiding
31− ( Foldable(..), tail, mapM_, last, map, mapM, concatMap, zipWith, init, iterate
32− , repeat, replicate
33− )
27+ (tail, mapM_, foldl, last, map, mapM, concatMap, zip, init)
3428
3529import qualified Prelude as P
3630import qualified Data.List as List
3731
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
3934
40−import Test.Tasty.Bench (bench, nfIO, bgroup, Benchmark, defaultMain)
35+import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)
4136
4237import Streamly.Benchmark.Common
4338
@@ -45,161 +40,70 @@ import Streamly.Benchmark.Common
4540import Test.Inspection
4641#endif
4742
48−{-
49−
50−Benchmarks that need to be added
51−
52−-- fromList
53−
54−-- bindWith
55−-- concatPairsWith
56−-- apWith
57−-- apSerial
58−-- apSerialDiscardFst
59−-- apSerialDiscardSnd
60−
61−-- the
62−-- serial
63−-- consMStream
64−-- withLocal
65−-- mfix
66−
67−-- elem
68−-- notElem
69−-- all
70−-- any
71−-- minimum
72−-- minimumBy
73−-- maximum
74−-- maximumBy
75−-- findIndices
76−-- lookup
77−-- findM
78−-- find
79−-- (!!)
80−
81−-- foldlM'
82−-- foldlT
83−-- foldlx'
84−-- foldlMx'
85−-- fold
86−
87−-- sequence
88−
89−-- foldrSM
90−-- buildS
91−-- buildM
92−-- augmentS
93−-- augmentSM
94−-- foldr
95−-- foldr1
96−-- foldrM
97−-- foldrT
98−
99−-- intersperseM
100−-- insertBy
101−-- deleteBy
102−-- reverse
103−-- mapMaybe
104−
105−-- zipWithM
106−-- mergeBy
107−-- mergeByM
108−
109−-- toStreamK (Probably can be skipped)
110−-- hoist
111−
112−-- scanlx'
113−
114−-}
115−
11643-------------------------------------------------------------------------------
11744-- Stream generation and elimination
11845-------------------------------------------------------------------------------
11946
120−type Stream m a = S.StreamK m a
47+type Stream m a = S.Stream m a
12148
122−{-# INLINE unfoldr #-}
123−unfoldr :: Int -> Int -> Stream m Int
124−unfoldr streamLen n = S.unfoldr step n
49+{-# INLINE sourceUnfoldr #-}
50+sourceUnfoldr :: Int -> Int -> Stream m Int
51+sourceUnfoldr value n = S.unfoldr step n
12552 where
12653 step cnt =
127− if cnt > n + streamLen
54+ if cnt > n + value
12855 then Nothing
12956 else Just (cnt, cnt + 1)
13057
131−{-# INLINE unfoldrM #-}
132−unfoldrM :: Monad m => Int -> Int -> Stream m Int
133−unfoldrM streamLen n = S.unfoldrMWith S.consM step n
58+{-# INLINE sourceUnfoldrM #-}
59+sourceUnfoldrM :: S.MonadAsync m => Int -> Int -> Stream m Int
60+sourceUnfoldrM value n = S.unfoldrM step n
13461 where
13562 step cnt =
136− if cnt > n + streamLen
63+ if cnt > n + value
13764 then return Nothing
13865 else return (Just (cnt, cnt + 1))
13966
140−{-# INLINE repeat #-}
141−repeat :: Int -> Int -> Stream m Int
142−repeat streamLen = S.take streamLen . S.repeat
143−
144−{-# INLINE repeatM #-}
145−repeatM :: Monad m => Int -> Int -> Stream m Int
146−repeatM streamLen = S.take streamLen . S.repeatM . return
147−
148−{-# INLINE replicate #-}
149−replicate :: Int -> Int -> Stream m Int
150−replicate = S.replicate
151−
152−{-# INLINE replicateM #-}
153−replicateM :: Monad m => Int -> Int -> Stream m Int
154−replicateM streamLen = S.replicateMWith S.consM streamLen . return
67+{-# INLINE sourceFromFoldable #-}
68+sourceFromFoldable :: Int -> Int -> Stream m Int
69+sourceFromFoldable value n = S.fromFoldable [n..n+value]
15570
156−{-# INLINE iterate #-}
157−iterate :: Int -> Int -> Stream m Int
158−iterate streamLen = S.take streamLen . S.iterate (+1)
71+{-# INLINE sourceFromFoldableM #-}
72+sourceFromFoldableM :: S.MonadAsync m => Int -> Int -> Stream m Int
73+sourceFromFoldableM value n =
74+ Prelude.foldr S.consM S.nil (Prelude.fmap return [n..n+value])
15975
160−{-# INLINE iterateM #-}
161−iterateM :: Monad m => Int -> Int -> Stream m Int
162−iterateM streamLen = S.take streamLen . S.iterateM (return . (+1)) . return
163−
164−{-# INLINE fromFoldable #-}
165−fromFoldable :: Int -> Int -> Stream m Int
166−fromFoldable streamLen n = S.fromFoldable [n..n+streamLen]
76+{-# INLINABLE concatMapFoldableWith #-}
77+concatMapFoldableWith :: (S.IsStream t, Foldable f)
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
16780
168−{-# INLINE fromFoldableM #-}
169−fromFoldableM :: Monad m => Int -> Int -> Stream m Int
170−fromFoldableM streamLen n =
171− List.foldr S.consM S.nil (Prelude.fmap return [n..n+streamLen])
81+{-# INLINE sourceFoldMapWith #-}
82+sourceFoldMapWith :: Int -> Int -> Stream m Int
83+sourceFoldMapWith value n = concatMapFoldableWith S.serial S.yield [n..n+value]
17284
173−{-# INLINABLE concatMapFoldableWith #-}
174−concatMapFoldableWith :: P.Foldable f
175− => (Stream m b -> Stream m b -> Stream m b)
176− -> (a -> Stream m b)
177− -> f a
178− -> Stream m b
179−concatMapFoldableWith f g = P.foldr (f . g) S.nil
180−
181−{-# INLINE concatMapFoldableSerial #-}
182−concatMapFoldableSerial :: Int -> Int -> Stream m Int
183−concatMapFoldableSerial streamLen n =
184− concatMapFoldableWith S.append S.fromPure [n..n+streamLen]
185−
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]
85+{-# INLINE sourceFoldMapWithM #-}
86+sourceFoldMapWithM :: Monad m => Int -> Int -> Stream m Int
87+sourceFoldMapWithM value n =
88+ concatMapFoldableWith S.serial (S.yieldM . return) [n..n+value]
19089
19190-------------------------------------------------------------------------------
19291-- Elimination
19392-------------------------------------------------------------------------------
19493
195−{-# INLINE drain #-}
196−drain :: Monad m => Stream m a -> m ()
197−drain = S.drain
94+{-# INLINE runStream #-}
95+runStream :: Monad m => Stream m a -> m ()
96+runStream = S.drain
97+-- runStream = S.mapM_ (\_ -> return ())
19898
19999{-# INLINE mapM_ #-}
200100mapM_ :: Monad m => Stream m a -> m ()
201101mapM_ = S.mapM_ (\_ -> return ())
202102
103+{-# INLINE toNull #-}
104+toNull :: Monad m => Stream m Int -> m ()
105+toNull = runStream
106+
203107{-# INLINE uncons #-}
204108uncons :: Monad m => Stream m Int -> m ()
205109uncons s = do
@@ -209,13 +113,13 @@ uncons s = do
209113 Just (_, t) -> uncons t
210114
211115{-# INLINE init #-}
212−init :: Monad m => Stream m a -> m ()
116+init :: (Monad m, S.IsStream t) => t m a -> m ()
213117init s = do
214118 t <- S.init s
215119 P.mapM_ S.drain t
216120
217121{-# INLINE tail #-}
218−tail :: Monad m => Stream m a -> m ()
122+tail :: (Monad m, S.IsStream t) => t m a -> m ()
219123tail s = S.tail s >>= P.mapM_ tail
220124
221125{-# INLINE nullTail #-}
@@ -234,9 +138,9 @@ headTail s = do
234138toList :: Monad m => Stream m Int -> m [Int]
235139toList = S.toList
236140
237−{-# INLINE foldl' #-}
238−foldl' :: Monad m => Stream m Int -> m Int
239−foldl' = S.foldl' (+) 0
141+{-# INLINE foldl #-}
142+foldl :: Monad m => Stream m Int -> m Int
143+foldl = S.foldl' (+) 0
240144
241145{-# INLINE last #-}
242146last :: Monad m => Stream m Int -> m (Maybe Int)
@@ -246,36 +150,40 @@ last = S.last
246150-- Transformation
247151-------------------------------------------------------------------------------
248152
153+{-# INLINE transform #-}
154+transform :: Monad m => Stream m a -> m ()
155+transform = runStream
156+
249157{-# INLINE composeN #-}
250158composeN
251159 :: Monad m
252160 => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()
253161composeN n f =
254162 case n of
255− 1 -> drain . f
256− 2 -> drain . f . f
257− 3 -> drain . f . f . f
258− 4 -> drain . f . f . f . f
163+ 1 -> transform . f
164+ 2 -> transform . f . f
165+ 3 -> transform . f . f . f
166+ 4 -> transform . f . f . f . f
259167 _ -> undefined
260168
261−{-# INLINE scanl' #-}
262−scanl' :: Monad m => Int -> Stream m Int -> m ()
263−scanl' n = composeN n $ S.scanl' (+) 0
169+{-# INLINE scan #-}
170+scan :: Monad m => Int -> Stream m Int -> m ()
171+scan n = composeN n $ S.scanl' (+) 0
264172
265173{-# INLINE map #-}
266174map :: Monad m => Int -> Stream m Int -> m ()
267−map n = composeN n $ S.map (+ 1)
175+map n = composeN n $ P.fmap (+ 1)
268176
269177{-# INLINE fmapK #-}
270178fmapK :: Monad m => Int -> Stream m Int -> m ()
271179fmapK n = composeN n $ P.fmap (+ 1)
272180
273181{-# INLINE mapM #-}
274−mapM :: Monad m => Int -> Stream m Int -> m ()
275−mapM n = composeN n $ S.mapMWith S.consM return
182+mapM :: S.MonadAsync m => Int -> Stream m Int -> m ()
183+mapM n = composeN n $ S.mapM return
276184
277185{-# INLINE mapMSerial #-}
278−mapMSerial :: Monad m => Int -> Stream m Int -> m ()
186+mapMSerial :: S.MonadAsync m => Int -> Stream m Int -> m ()
279187mapMSerial n = composeN n $ S.mapMSerial return
280188
281189{-# INLINE filterEven #-}
@@ -284,11 +192,11 @@ filterEven n = composeN n $ S.filter even
284192
285193{-# INLINE filterAllOut #-}
286194filterAllOut :: Monad m => Int -> Int -> Stream m Int -> m ()
287−filterAllOut streamLen n = composeN n $ S.filter (> streamLen)
195+filterAllOut maxValue n = composeN n $ S.filter (> maxValue)
288196
289197{-# INLINE filterAllIn #-}
290198filterAllIn :: Monad m => Int -> Int -> Stream m Int -> m ()
291−filterAllIn streamLen n = composeN n $ S.filter (<= streamLen)
199+filterAllIn maxValue n = composeN n $ S.filter (<= maxValue)
292200
293201{-# INLINE _takeOne #-}
294202_takeOne :: Monad m => Int -> Stream m Int -> m ()
@@ -296,11 +204,11 @@ _takeOne n = composeN n $ S.take 1
296204
297205{-# INLINE takeAll #-}
298206takeAll :: Monad m => Int -> Int -> Stream m Int -> m ()
299−takeAll streamLen n = composeN n $ S.take streamLen
207+takeAll maxValue n = composeN n $ S.take maxValue
300208
301209{-# INLINE takeWhileTrue #-}
302210takeWhileTrue :: Monad m => Int -> Int -> Stream m Int -> m ()
303−takeWhileTrue streamLen n = composeN n $ S.takeWhile (<= streamLen)
211+takeWhileTrue maxValue n = composeN n $ S.takeWhile (<= maxValue)
304212
305213{-# INLINE dropOne #-}
306214dropOne :: Monad m => Int -> Stream m Int -> m ()
@@ -308,11 +216,11 @@ dropOne n = composeN n $ S.drop 1
308216
309217{-# INLINE dropAll #-}
310218dropAll :: Monad m => Int -> Int -> Stream m Int -> m ()
311−dropAll streamLen n = composeN n $ S.drop streamLen
219+dropAll maxValue n = composeN n $ S.drop maxValue
312220
313221{-# INLINE dropWhileTrue #-}
314222dropWhileTrue :: Monad m => Int -> Int -> Stream m Int -> m ()
315−dropWhileTrue streamLen n = composeN n $ S.dropWhile (<= streamLen)
223+dropWhileTrue maxValue n = composeN n $ S.dropWhile (<= maxValue)
316224
317225{-# INLINE dropWhileFalse #-}
318226dropWhileFalse :: Monad m => Int -> Stream m Int -> m ()
@@ -327,8 +235,8 @@ foldlS :: Monad m => Int -> Stream m Int -> m ()
327235foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil
328236
329237{-# INLINE intersperse #-}
330−intersperse :: Monad m => Int -> Int -> Stream m Int -> m ()
331−intersperse streamLen n = composeN n $ S.intersperse streamLen
238+intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()
239+intersperse maxValue n = composeN n $ S.intersperse maxValue
332240
333241-------------------------------------------------------------------------------
334242-- Iteration
@@ -336,67 +244,51 @@ intersperse streamLen n = composeN n $ S.intersperse streamLen
336244
337245{-# INLINE iterateSource #-}
338246iterateSource
339− :: Monad m => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
340−iterateSource iterStreamLen g i n = f i (unfoldrM iterStreamLen n)
247+ :: S.MonadAsync m
248+ => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
249+iterateSource iterStreamLen g i n = f i (sourceUnfoldrM iterStreamLen n)
341250 where
342251 f (0 :: Int) m = g m
343252 f x m = g (f (x P.- 1) m)
344253
345254-- this is quadratic
346255{-# INLINE iterateScan #-}
347−iterateScan :: Monad m => Int -> Int -> Int -> Stream m Int
348−iterateScan iterStreamLen maxIters =
349− iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)
256+iterateScan :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
257+iterateScan iterStreamLen maxIters = iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)
350258
351259-- this is quadratic
352260{-# INLINE iterateDropWhileFalse #-}
353−iterateDropWhileFalse :: Monad m => Int -> Int -> Int -> Int -> Stream m Int
354−iterateDropWhileFalse streamLen iterStreamLen maxIters =
355− iterateSource iterStreamLen (S.dropWhile (> streamLen)) (maxIters `div` 10)
261+iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
262+iterateDropWhileFalse maxValue iterStreamLen maxIters =
263+ iterateSource iterStreamLen (S.dropWhile (> maxValue)) (maxIters `div` 10)
356264
357265{-# INLINE iterateMapM #-}
358−iterateMapM :: Monad m => Int -> Int -> Int -> Stream m Int
359−iterateMapM iterStreamLen =
360− iterateSource iterStreamLen (S.mapMWith S.consM return)
266+iterateMapM :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
267+iterateMapM iterStreamLen maxIters = iterateSource iterStreamLen (S.mapM return) maxIters
361268
362269{-# INLINE iterateFilterEven #-}
363−iterateFilterEven :: Monad m => Int -> Int -> Int -> Stream m Int
364−iterateFilterEven iterStreamLen = iterateSource iterStreamLen (S.filter even)
270+iterateFilterEven :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
271+iterateFilterEven iterStreamLen maxIters = iterateSource iterStreamLen (S.filter even) maxIters
365272
366273{-# INLINE iterateTakeAll #-}
367−iterateTakeAll :: Monad m => Int -> Int -> Int -> Int -> Stream m Int
368−iterateTakeAll streamLen iterStreamLen =
369− iterateSource iterStreamLen (S.take streamLen)
274+iterateTakeAll :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
275+iterateTakeAll maxValue iterStreamLen maxIters = iterateSource iterStreamLen (S.take maxValue) maxIters
370276
371277{-# INLINE iterateDropOne #-}
372−iterateDropOne :: Monad m => Int -> Int -> Int -> Stream m Int
373−iterateDropOne iterStreamLen = iterateSource iterStreamLen (S.drop 1)
278+iterateDropOne :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
279+iterateDropOne iterStreamLen maxIters = iterateSource iterStreamLen (S.drop 1) maxIters
374280
375281{-# INLINE iterateDropWhileTrue #-}
376−iterateDropWhileTrue ::
377− Monad m => Int -> Int -> Int -> Int -> Stream m Int
378−iterateDropWhileTrue streamLen iterStreamLen =
379− iterateSource iterStreamLen (S.dropWhile (<= streamLen))
282+iterateDropWhileTrue :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
283+iterateDropWhileTrue maxValue iterStreamLen maxIters = iterateSource iterStreamLen (S.dropWhile (<= maxValue)) maxIters
380284
381285-------------------------------------------------------------------------------
382286-- Zipping
383287-------------------------------------------------------------------------------
384288
385−{-# INLINE zipWith #-}
386−zipWith :: Monad m => Stream m Int -> m ()
387−zipWith src = drain $ S.zipWith (,) src src
388−
389−{-# INLINE zipWithM #-}
390−zipWithM :: Monad m => Stream m Int -> m ()
391−zipWithM src = drain $ S.zipWithM (curry return) src src
392−
393−{-# INLINE sortByK #-}
394−sortByK :: (a -> a -> Ordering) -> Stream m a -> Stream m a
395−sortByK f = S.mergeMapWith (S.mergeBy f) S.fromPure
396−
397−{-# INLINE sortBy #-}
398−sortBy :: Monad m => Stream m Int -> m ()
399−sortBy = drain . sortByK compare
289+{-# INLINE zip #-}
290+zip :: Monad m => Stream m Int -> m ()
291+zip src = transform $ S.zipWith (,) src src
400292
401293-------------------------------------------------------------------------------
402294-- Mixed Composition
@@ -416,31 +308,32 @@ dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
416308
417309{-# INLINE takeDrop #-}
418310takeDrop :: Monad m => Int -> Int -> Stream m Int -> m ()
419−takeDrop streamLen n = composeN n $ S.drop 1 . S.take streamLen
311+takeDrop maxValue n = composeN n $ S.drop 1 . S.take maxValue
420312
421313{-# INLINE takeScan #-}
422314takeScan :: Monad m => Int -> Int -> Stream m Int -> m ()
423−takeScan streamLen n = composeN n $ S.scanl' (+) 0 . S.take streamLen
315+takeScan maxValue n = composeN n $ S.scanl' (+) 0 . S.take maxValue
424316
425317{-# INLINE takeMap #-}
426318takeMap :: Monad m => Int -> Int -> Stream m Int -> m ()
427−takeMap streamLen n = composeN n $ S.map (subtract 1) . S.take streamLen
319+takeMap maxValue n = composeN n $ S.map (subtract 1) . S.take maxValue
428320
429321{-# INLINE filterDrop #-}
430322filterDrop :: Monad m => Int -> Int -> Stream m Int -> m ()
431−filterDrop streamLen n = composeN n $ S.drop 1 . S.filter (<= streamLen)
323+filterDrop maxValue n = composeN n $ S.drop 1 . S.filter (<= maxValue)
432324
433325{-# INLINE filterTake #-}
434326filterTake :: Monad m => Int -> Int -> Stream m Int -> m ()
435−filterTake streamLen n = composeN n $ S.take streamLen . S.filter (<= streamLen)
327+filterTake maxValue n = composeN n $ S.take maxValue . S.filter (<= maxValue)
436328
329+-- Initially, this used maxBound not maxValue
437330{-# INLINE filterScan #-}
438−filterScan :: Monad m => Int -> Stream m Int -> m ()
439−filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
331+filterScan :: Monad m => Int -> Int -> Stream m Int -> m ()
332+filterScan maxValue n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxValue)
440333
441334{-# INLINE filterMap #-}
442335filterMap :: Monad m => Int -> Int -> Stream m Int -> m ()
443−filterMap streamLen n = composeN n $ S.map (subtract 1) . S.filter (<= streamLen)
336+filterMap maxValue n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)
444337
445338-------------------------------------------------------------------------------
446339-- ConcatMap
@@ -452,8 +345,8 @@ filterMap streamLen n = composeN n $ S.map (subtract 1) . S.filter (<= streamLen
452345concatMap :: Int -> Int -> Int -> IO ()
453346concatMap outer inner n =
454347 S.drain $ S.concatMap
455− (\_ -> unfoldrM inner n)
456− (unfoldrM outer n)
348+ (\_ -> sourceUnfoldrM inner n)
349+ (sourceUnfoldrM outer n)
457350
458351#ifdef INSPECTION
459352inspect $ hasNoTypeClasses 'concatMap
@@ -465,8 +358,8 @@ inspect $ hasNoTypeClasses 'concatMap
465358concatMapPure :: Int -> Int -> Int -> IO ()
466359concatMapPure outer inner n =
467360 S.drain $ S.concatMap
468− (\_ -> unfoldr inner n)
469− (unfoldr outer n)
361+ (\_ -> sourceUnfoldr inner n)
362+ (sourceUnfoldr outer n)
470363
471364#ifdef INSPECTION
472365inspect $ hasNoTypeClasses 'concatMapPure
@@ -477,7 +370,7 @@ inspect $ hasNoTypeClasses 'concatMapPure
477370{-# INLINE concatMapRepl #-}
478371concatMapRepl :: Int -> Int -> Int -> IO ()
479372concatMapRepl outer inner n =
480− S.drain $ S.concatMap (S.replicate inner) (unfoldrM outer n)
373+ S.drain $ S.concatMap (S.replicate inner) (sourceUnfoldrM outer n)
481374
482375#ifdef INSPECTION
483376inspect $ hasNoTypeClasses 'concatMapRepl
@@ -489,70 +382,44 @@ inspect $ hasNoTypeClasses 'concatMapRepl
489382sourceConcatMapId :: Monad m
490383 => Int -> Int -> Stream m (Stream m Int)
491384sourceConcatMapId val n =
492− S.fromFoldable $ fmap (S.fromEffect . return) [n..n+val]
385+ S.fromFoldable $ fmap (S.yieldM . return) [n..n+val]
493386
494−{-# INLINE concatMapBySerial #-}
495−concatMapBySerial :: Int -> Int -> Int -> IO ()
496−concatMapBySerial outer inner n =
497− S.drain $ S.concatMapWith S.append
498− (unfoldrM inner)
499− (unfoldrM outer n)
387+{-# INLINE concatStreamsWith #-}
388+concatStreamsWith :: Int -> Int -> Int -> IO ()
389+concatStreamsWith outer inner n =
390+ S.drain $ S.concatMapBy S.serial
391+ (sourceUnfoldrM inner)
392+ (sourceUnfoldrM outer n)
500393
501394-------------------------------------------------------------------------------
502395-- Nested Composition
503396-------------------------------------------------------------------------------
504397
505−instance Monad m => Applicative (S.StreamK m) where
506− {-# INLINE pure #-}
507− pure = S.fromPure
508−
509− {-# INLINE (<*>) #-}
510− (<*>) = S.crossApply
511−
512− {-# INLINE liftA2 #-}
513− liftA2 f x = (<*>) (fmap f x)
514−
515− {-# INLINE (*>) #-}
516− (*>) = S.crossApplySnd
517−
518− {-# INLINE (<*) #-}
519− (<*) = S.crossApplyFst
520−
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
523−-- fusion.
524−instance Monad m => Monad (S.StreamK m) where
525− {-# INLINE return #-}
526− return = pure
527−
528− {-# INLINE (>>=) #-}
529− (>>=) = flip S.concatMap
530−
531−{-# INLINE drainApplicative #-}
532−drainApplicative :: Monad m => Stream m Int -> m ()
533−drainApplicative s = drain $ do
398+{-# INLINE toNullApNested #-}
399+toNullApNested :: Monad m => Stream m Int -> m ()
400+toNullApNested s = runStream $ do
534401 (+) <$> s <*> s
535402
536−{-# INLINE drainMonad #-}
537−drainMonad :: Monad m => Stream m Int -> m ()
538−drainMonad s = drain $ do
403+{-# INLINE toNullNested #-}
404+toNullNested :: Monad m => Stream m Int -> m ()
405+toNullNested s = runStream $ do
539406 x <- s
540407 y <- s
541408 return $ x + y
542409
543−{-# INLINE drainMonad3 #-}
544−drainMonad3 :: Monad m => Stream m Int -> m ()
545−drainMonad3 s = drain $ do
410+{-# INLINE toNullNested3 #-}
411+toNullNested3 :: Monad m => Stream m Int -> m ()
412+toNullNested3 s = runStream $ do
546413 x <- s
547414 y <- s
548415 z <- s
549416 return $ x + y + z
550417
551−{-# INLINE filterAllOutMonad #-}
552−filterAllOutMonad
418+{-# INLINE filterAllOutNested #-}
419+filterAllOutNested
553420 :: Monad m
554421 => Stream m Int -> m ()
555−filterAllOutMonad str = drain $ do
422+filterAllOutNested str = runStream $ do
556423 x <- str
557424 y <- str
558425 let s = x + y
@@ -560,11 +427,11 @@ filterAllOutMonad str = drain $ do
560427 then return s
561428 else S.nil
562429
563−{-# INLINE filterAllInMonad #-}
564−filterAllInMonad
430+{-# INLINE filterAllInNested #-}
431+filterAllInNested
565432 :: Monad m
566433 => Stream m Int -> m ()
567−filterAllInMonad str = drain $ do
434+filterAllInNested str = runStream $ do
568435 x <- str
569436 y <- str
570437 let s = x + y
@@ -576,14 +443,9 @@ filterAllInMonad str = drain $ do
576443-- Nested Composition Pure lists
577444-------------------------------------------------------------------------------
578445
579−-- There are several list benchmarks here for comparison with lists. It is easy
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.
583−
584−{-# INLINE unfoldrList #-}
585−unfoldrList :: Int -> Int -> [Int]
586−unfoldrList maxval n = List.unfoldr step n
446+{-# INLINE sourceUnfoldrList #-}
447+sourceUnfoldrList :: Int -> Int -> [Int]
448+sourceUnfoldrList maxval n = List.unfoldr step n
587449 where
588450 step cnt =
589451 if cnt > n + maxval
@@ -634,283 +496,271 @@ filterAllInNestedList str = do
634496-------------------------------------------------------------------------------
635497
636498moduleName :: String
637−moduleName = "Data.StreamK"
499+moduleName = "Data.Stream.StreamK"
638500
639501o_1_space_generation :: Int -> Benchmark
640−o_1_space_generation streamLen =
502+o_1_space_generation value =
641503 bgroup "generation"
642− [ benchFold "unfoldr" drain (unfoldr streamLen)
643− , benchFold "unfoldrM" drain (unfoldrM streamLen)
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)
650−
651− , benchFold "fromFoldable" drain (fromFoldable streamLen)
652− , benchFold "fromFoldableM" drain (fromFoldableM streamLen)
504+ [ benchFold "unfoldr" toNull (sourceUnfoldr value)
505+ , benchFold "unfoldrM" toNull (sourceUnfoldrM value)
506+
507+ , benchFold "fromFoldable" toNull (sourceFromFoldable value)
508+ , benchFold "fromFoldableM" toNull (sourceFromFoldableM value)
653509
654510 -- appends
655− , benchFold "concatMapFoldableWith" drain (concatMapFoldableSerial streamLen)
656− , benchFold "concatMapFoldableWithM" drain (concatMapFoldableSerialM streamLen)
511+ , benchFold "concatMapFoldableWith" toNull (sourceFoldMapWith value)
512+ , benchFold "concatMapFoldableWithM" toNull (sourceFoldMapWithM value)
657513 ]
658514
659515o_1_space_elimination :: Int -> Benchmark
660−o_1_space_elimination streamLen =
516+o_1_space_elimination value =
661517 bgroup "elimination"
662− [ benchFold "toNull" drain (unfoldrM streamLen)
663− , benchFold "mapM_" mapM_ (unfoldrM streamLen)
664− , benchFold "uncons" uncons (unfoldrM streamLen)
665− , benchFold "init" init (unfoldrM streamLen)
666− , benchFold "foldl'" foldl' (unfoldrM streamLen)
667− , benchFold "last" last (unfoldrM streamLen)
518+ [ benchFold "toNull" toNull (sourceUnfoldrM value)
519+ , benchFold "mapM_" mapM_ (sourceUnfoldrM value)
520+ , benchFold "uncons" uncons (sourceUnfoldrM value)
521+ , benchFold "init" init (sourceUnfoldrM value)
522+ , benchFold "foldl'" foldl (sourceUnfoldrM value)
523+ , benchFold "last" last (sourceUnfoldrM value)
668524 ]
669525
670526o_1_space_nested :: Int -> Benchmark
671−o_1_space_nested streamLen =
527+o_1_space_nested value =
672528 bgroup "nested"
673− [ benchFold "drainApplicative" drainApplicative (unfoldrM streamLen2)
674− , benchFold "drainMonad" drainMonad (unfoldrM streamLen2)
675− , benchFold "drainMonad3" drainMonad3 (unfoldrM streamLen3)
676− , benchFold "filterAllInMonad" filterAllInMonad (unfoldrM streamLen2)
677− , benchFold "filterAllOutMonad" filterAllOutMonad (unfoldrM streamLen2)
678− , benchFold "drainApplicative (pure)" drainApplicative (unfoldr streamLen2)
679− , benchFold "drainMonad (pure)" drainMonad (unfoldr streamLen2)
680− , benchFold "drainMonad3 (pure)" drainMonad3 (unfoldr streamLen3)
681− , benchFold "filterAllInMonad (pure)" filterAllInMonad (unfoldr streamLen2)
682− , benchFold "filterAllOutMonad (pure)" filterAllOutMonad (unfoldr streamLen2)
529+ [ benchFold "toNullAp" toNullApNested (sourceUnfoldrM value2)
530+ , benchFold "toNull" toNullNested (sourceUnfoldrM value2)
531+ , benchFold "toNull3" toNullNested3 (sourceUnfoldrM value3)
532+ , benchFold "filterAllIn" filterAllInNested (sourceUnfoldrM value2)
533+ , benchFold "filterAllOut" filterAllOutNested (sourceUnfoldrM value2)
534+ , benchFold "toNullApPure" toNullApNested (sourceUnfoldr value2)
535+ , benchFold "toNullPure" toNullNested (sourceUnfoldr value2)
536+ , benchFold "toNull3Pure" toNullNested3 (sourceUnfoldr value3)
537+ , benchFold "filterAllInPure" filterAllInNested (sourceUnfoldr value2)
538+ , benchFold "filterAllOutPure" filterAllOutNested (sourceUnfoldr value2)
683539 ]
684540 where
685− streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
686− streamLen3 = round (P.fromIntegral streamLen**(1/3::P.Double)) -- triple nested loop
541+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
542+ value3 = round (P.fromIntegral value**(1/3::P.Double)) -- triple nested loop
687543
688544o_1_space_transformation :: Int -> Benchmark
689−o_1_space_transformation streamLen =
545+o_1_space_transformation value =
690546 bgroup "transformation"
691− [ benchFold "foldrS" (foldrS 1) (unfoldrM streamLen)
692− , benchFold "scanl'" (scanl' 1) (unfoldrM streamLen)
693− , benchFold "map" (map 1) (unfoldrM streamLen)
694− , benchFold "fmap" (fmapK 1) (unfoldrM streamLen)
695− , benchFold "mapM" (mapM 1) (unfoldrM streamLen)
696− , benchFold "mapMSerial" (mapMSerial 1) (unfoldrM streamLen)
547+ [ bgroup "X1"
548+ [ benchFold "foldrS" (foldrS 1) (sourceUnfoldrM value)
549+ , benchFold "scan" (scan 1) (sourceUnfoldrM value)
550+ , benchFold "map" (map 1) (sourceUnfoldrM value)
551+ , benchFold "fmap" (fmapK 1) (sourceUnfoldrM value)
552+ , benchFold "mapM" (mapM 1) (sourceUnfoldrM value)
553+ , benchFold "mapMSerial" (mapMSerial 1) (sourceUnfoldrM value)
697554 ]
698−
699−o_1_space_transformationX4 :: Int -> Benchmark
700−o_1_space_transformationX4 streamLen =
701− bgroup "transformationX4"
702− [ benchFold "scanl'" (scanl' 4) (unfoldrM streamLen)
703− , benchFold "map" (map 4) (unfoldrM streamLen)
704− , benchFold "fmap" (fmapK 4) (unfoldrM streamLen)
705− , benchFold "mapM" (mapM 4) (unfoldrM streamLen)
706− , benchFold "mapMSerial" (mapMSerial 4) (unfoldrM streamLen)
555+ , bgroup "X4"
556+ [ benchFold "scan" (scan 4) (sourceUnfoldrM value)
557+ , benchFold "map" (map 4) (sourceUnfoldrM value)
558+ , benchFold "fmap" (fmapK 4) (sourceUnfoldrM value)
559+ , benchFold "mapM" (mapM 4) (sourceUnfoldrM value)
560+ , benchFold "mapMSerial" (mapMSerial 4) (sourceUnfoldrM value)
707561 -- XXX this is horribly slow
708− -- , benchFold "concatMap" (concatMap 4) (unfoldrM streamLen16)
562+ -- , benchFold "concatMap" (concatMap 4) (sourceUnfoldrM value16)
709563 ]
564+ ]
710565
711566o_1_space_concat :: Int -> Benchmark
712−o_1_space_concat streamLen =
567+o_1_space_concat value =
713568 bgroup "concat"
714569 [ benchIOSrc1 "concatMapPure (n of 1)"
715− (concatMapPure streamLen 1)
570+ (concatMapPure value 1)
716571 , benchIOSrc1 "concatMapPure (sqrt n of sqrt n)"
717− (concatMapPure streamLen2 streamLen2)
572+ (concatMapPure value2 value2)
718573 , benchIOSrc1 "concatMapPure (1 of n)"
719− (concatMapPure 1 streamLen)
574+ (concatMapPure 1 value)
720575
721576 , benchIOSrc1 "concatMap (n of 1)"
722− (concatMap streamLen 1)
577+ (concatMap value 1)
723578 , benchIOSrc1 "concatMap (sqrt n of sqrt n)"
724− (concatMap streamLen2 streamLen2)
579+ (concatMap value2 value2)
725580 , benchIOSrc1 "concatMap (1 of n)"
726− (concatMap 1 streamLen)
581+ (concatMap 1 value)
727582
728583 , benchIOSrc1 "concatMapRepl (sqrt n of sqrt n)"
729− (concatMapRepl streamLen2 streamLen2)
584+ (concatMapRepl value2 value2)
730585
731586 -- This is for comparison with concatMapFoldableWith
732587 , benchIOSrc1 "concatMapWithId (n of 1) (fromFoldable)"
733− (S.drain
734− . S.concatMapWith S.append id
735− . sourceConcatMapId streamLen)
736−
737− , benchIOSrc1 "concatMapBy serial (n of 1)"
738− (concatMapBySerial streamLen 1)
739− , benchIOSrc1 "concatMapBy serial (sqrt n of sqrt n)"
740− (concatMapBySerial streamLen2 streamLen2)
741− , benchIOSrc1 "concatMapBy serial (1 of n)"
742− (concatMapBySerial 1 streamLen)
743− , benchFold "sortBy" sortBy (unfoldrM streamLen)
588+ (S.drain . S.concatMapBy S.serial id . sourceConcatMapId value)
589+
590+ , benchIOSrc1 "concatMapWith (n of 1)"
591+ (concatStreamsWith value 1)
592+ , benchIOSrc1 "concatMapWith (sqrt n of sqrt n)"
593+ (concatStreamsWith value2 value2)
594+ , benchIOSrc1 "concatMapWith (1 of n)"
595+ (concatStreamsWith 1 value)
744596 ]
745597 where
746− streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
598+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
747599
748600o_1_space_filtering :: Int -> Benchmark
749−o_1_space_filtering streamLen =
601+o_1_space_filtering value =
750602 bgroup "filtering"
751− [ benchFold "filter-even" (filterEven 1) (unfoldrM streamLen)
752− , benchFold "filter-all-out" (filterAllOut streamLen 1) (unfoldrM streamLen)
753− , benchFold "filter-all-in" (filterAllIn streamLen 1) (unfoldrM streamLen)
754− , benchFold "take-all" (takeAll streamLen 1) (unfoldrM streamLen)
755− , benchFold "takeWhile-true" (takeWhileTrue streamLen 1) (unfoldrM streamLen)
756− , benchFold "drop-one" (dropOne 1) (unfoldrM streamLen)
757− , benchFold "drop-all" (dropAll streamLen 1) (unfoldrM streamLen)
758− , benchFold "dropWhile-true" (dropWhileTrue streamLen 1) (unfoldrM streamLen)
759− , benchFold "dropWhile-false" (dropWhileFalse 1) (unfoldrM streamLen)
603+ [ bgroup "X1"
604+ [ benchFold "filter-even" (filterEven 1) (sourceUnfoldrM value)
605+ , benchFold "filter-all-out" (filterAllOut maxValue 1) (sourceUnfoldrM value)
606+ , benchFold "filter-all-in" (filterAllIn maxValue 1) (sourceUnfoldrM value)
607+ , benchFold "take-all" (takeAll maxValue 1) (sourceUnfoldrM value)
608+ , benchFold "takeWhile-true" (takeWhileTrue maxValue 1) (sourceUnfoldrM value)
609+ , benchFold "drop-one" (dropOne 1) (sourceUnfoldrM value)
610+ , benchFold "drop-all" (dropAll maxValue 1) (sourceUnfoldrM value)
611+ , benchFold "dropWhile-true" (dropWhileTrue maxValue 1) (sourceUnfoldrM value)
612+ , benchFold "dropWhile-false" (dropWhileFalse 1) (sourceUnfoldrM value)
760613 ]
761−
762−o_1_space_filteringX4 :: Int -> Benchmark
763−o_1_space_filteringX4 streamLen =
764− bgroup "filteringX4"
765− [ benchFold "filter-even" (filterEven 4) (unfoldrM streamLen)
766− , benchFold "filter-all-out" (filterAllOut streamLen 4) (unfoldrM streamLen)
767− , benchFold "filter-all-in" (filterAllIn streamLen 4) (unfoldrM streamLen)
768− , benchFold "take-all" (takeAll streamLen 4) (unfoldrM streamLen)
769− , benchFold "takeWhile-true" (takeWhileTrue streamLen 4) (unfoldrM streamLen)
770− , benchFold "drop-one" (dropOne 4) (unfoldrM streamLen)
771− , benchFold "drop-all" (dropAll streamLen 4) (unfoldrM streamLen)
772− , benchFold "dropWhile-true" (dropWhileTrue streamLen 4) (unfoldrM streamLen)
773− , benchFold "dropWhile-false" (dropWhileFalse 4) (unfoldrM streamLen)
614+ , bgroup "X4"
615+ [ benchFold "filter-even" (filterEven 4) (sourceUnfoldrM value)
616+ , benchFold "filter-all-out" (filterAllOut maxValue 4) (sourceUnfoldrM value)
617+ , benchFold "filter-all-in" (filterAllIn maxValue 4) (sourceUnfoldrM value)
618+ , benchFold "take-all" (takeAll maxValue 4) (sourceUnfoldrM value)
619+ , benchFold "takeWhile-true" (takeWhileTrue maxValue 4) (sourceUnfoldrM value)
620+ , benchFold "drop-one" (dropOne 4) (sourceUnfoldrM value)
621+ , benchFold "drop-all" (dropAll maxValue 4) (sourceUnfoldrM value)
622+ , benchFold "dropWhile-true" (dropWhileTrue maxValue 4) (sourceUnfoldrM value)
623+ , benchFold "dropWhile-false" (dropWhileFalse 4) (sourceUnfoldrM value)
774624 ]
625+ ]
626+ where
627+
628+ maxValue = value
629+
775630
776631o_1_space_zipping :: Int -> Benchmark
777−o_1_space_zipping streamLen =
632+o_1_space_zipping value =
778633 bgroup "zipping"
779− [ benchFold "zipWith" zipWith (unfoldrM streamLen)
780− , benchFold "zipWithM" zipWithM (unfoldrM streamLen)
634+ [ benchFold "zip" zip (sourceUnfoldrM value)
781635 ]
782636
783637o_1_space_mixed :: Int -> Benchmark
784−o_1_space_mixed streamLen =
638+o_1_space_mixed value =
785639 bgroup "mixed"
786− [ benchFold "scan-map" (scanMap 1) (unfoldrM streamLen)
787− , benchFold "drop-map" (dropMap 1) (unfoldrM streamLen)
788− , benchFold "drop-scan" (dropScan 1) (unfoldrM streamLen)
789− , benchFold "take-drop" (takeDrop streamLen 1) (unfoldrM streamLen)
790− , benchFold "take-scan" (takeScan streamLen 1) (unfoldrM streamLen)
791− , benchFold "take-map" (takeMap streamLen 1) (unfoldrM streamLen)
792− , benchFold "filter-drop" (filterDrop streamLen 1) (unfoldrM streamLen)
793− , benchFold "filter-take" (filterTake streamLen 1) (unfoldrM streamLen)
794− , benchFold "filter-scan" (filterScan 1) (unfoldrM streamLen)
795− , benchFold "filter-map" (filterMap streamLen 1) (unfoldrM streamLen)
640+ [ bgroup "X1"
641+ [ benchFold "scan-map" (scanMap 1) (sourceUnfoldrM value)
642+ , benchFold "drop-map" (dropMap 1) (sourceUnfoldrM value)
643+ , benchFold "drop-scan" (dropScan 1) (sourceUnfoldrM value)
644+ , benchFold "take-drop" (takeDrop maxValue 1) (sourceUnfoldrM value)
645+ , benchFold "take-scan" (takeScan maxValue 1) (sourceUnfoldrM value)
646+ , benchFold "take-map" (takeMap maxValue 1) (sourceUnfoldrM value)
647+ , benchFold "filter-drop" (filterDrop maxValue 1) (sourceUnfoldrM value)
648+ , benchFold "filter-take" (filterTake maxValue 1) (sourceUnfoldrM value)
649+ , benchFold "filter-scan" (filterScan maxValue 1) (sourceUnfoldrM value)
650+ , benchFold "filter-map" (filterMap maxValue 1) (sourceUnfoldrM value)
796651 ]
797−
798−o_1_space_mixedX2 :: Int -> Benchmark
799−o_1_space_mixedX2 streamLen =
800− bgroup "mixedX2"
801− [ benchFold "scan-map" (scanMap 2) (unfoldrM streamLen)
802− , benchFold "drop-map" (dropMap 2) (unfoldrM streamLen)
803− , benchFold "drop-scan" (dropScan 2) (unfoldrM streamLen)
804− , benchFold "take-drop" (takeDrop streamLen 2) (unfoldrM streamLen)
805− , benchFold "take-scan" (takeScan streamLen 2) (unfoldrM streamLen)
806− , benchFold "take-map" (takeMap streamLen 2) (unfoldrM streamLen)
807− , benchFold "filter-drop" (filterDrop streamLen 2) (unfoldrM streamLen)
808− , benchFold "filter-take" (filterTake streamLen 2) (unfoldrM streamLen)
809− , benchFold "filter-scan" (filterScan 2) (unfoldrM streamLen)
810− , benchFold "filter-map" (filterMap streamLen 2) (unfoldrM streamLen)
652+ , bgroup "X2"
653+ [ benchFold "scan-map" (scanMap 2) (sourceUnfoldrM value)
654+ , benchFold "drop-map" (dropMap 2) (sourceUnfoldrM value)
655+ , benchFold "drop-scan" (dropScan 2) (sourceUnfoldrM value)
656+ , benchFold "take-drop" (takeDrop maxValue 2) (sourceUnfoldrM value)
657+ , benchFold "take-scan" (takeScan maxValue 2) (sourceUnfoldrM value)
658+ , benchFold "take-map" (takeMap maxValue 2) (sourceUnfoldrM value)
659+ , benchFold "filter-drop" (filterDrop maxValue 2) (sourceUnfoldrM value)
660+ , benchFold "filter-take" (filterTake maxValue 2) (sourceUnfoldrM value)
661+ , benchFold "filter-scan" (filterScan maxValue 2) (sourceUnfoldrM value)
662+ , benchFold "filter-map" (filterMap maxValue 2) (sourceUnfoldrM value)
811663 ]
812−
813−o_1_space_mixedX4 :: Int -> Benchmark
814−o_1_space_mixedX4 streamLen =
815− bgroup "mixedX4"
816− [ benchFold "scan-map" (scanMap 4) (unfoldrM streamLen)
817− , benchFold "drop-map" (dropMap 4) (unfoldrM streamLen)
818− , benchFold "drop-scan" (dropScan 4) (unfoldrM streamLen)
819− , benchFold "take-drop" (takeDrop streamLen 4) (unfoldrM streamLen)
820− , benchFold "take-scan" (takeScan streamLen 4) (unfoldrM streamLen)
821− , benchFold "take-map" (takeMap streamLen 4) (unfoldrM streamLen)
822− , benchFold "filter-drop" (filterDrop streamLen 4) (unfoldrM streamLen)
823− , benchFold "filter-take" (filterTake streamLen 4) (unfoldrM streamLen)
824− , benchFold "filter-scan" (filterScan 4) (unfoldrM streamLen)
825− , benchFold "filter-map" (filterMap streamLen 4) (unfoldrM streamLen)
664+ , bgroup "X4"
665+ [ benchFold "scan-map" (scanMap 4) (sourceUnfoldrM value)
666+ , benchFold "drop-map" (dropMap 4) (sourceUnfoldrM value)
667+ , benchFold "drop-scan" (dropScan 4) (sourceUnfoldrM value)
668+ , benchFold "take-drop" (takeDrop maxValue 4) (sourceUnfoldrM value)
669+ , benchFold "take-scan" (takeScan maxValue 4) (sourceUnfoldrM value)
670+ , benchFold "take-map" (takeMap maxValue 4) (sourceUnfoldrM value)
671+ , benchFold "filter-drop" (filterDrop maxValue 4) (sourceUnfoldrM value)
672+ , benchFold "filter-take" (filterTake maxValue 4) (sourceUnfoldrM value)
673+ , benchFold "filter-scan" (filterScan maxValue 4) (sourceUnfoldrM value)
674+ , benchFold "filter-map" (filterMap maxValue 4) (sourceUnfoldrM value)
826675 ]
676+ ]
677+ where
678+
679+ maxValue = value
827680
828681o_1_space_list :: Int -> Benchmark
829−o_1_space_list streamLen =
682+o_1_space_list value =
830683 bgroup "list"
831684 [ bgroup "elimination"
832− [ benchList "last" (\xs -> [List.last xs]) (unfoldrList streamLen)
685+ [ benchList "last" (\xs -> [List.last xs]) (sourceUnfoldrList value)
833686 ]
834687 , bgroup "nested"
835− [ benchList "toNullAp" toNullApNestedList (unfoldrList streamLen2)
836− , benchList "toNull" toNullNestedList (unfoldrList streamLen2)
837− , benchList "toNull3" toNullNestedList3 (unfoldrList streamLen3)
838− , benchList "filterAllIn" filterAllInNestedList (unfoldrList streamLen2)
839− , benchList "filterAllOut" filterAllOutNestedList (unfoldrList streamLen2)
688+ [ benchList "toNullAp" toNullApNestedList (sourceUnfoldrList value2)
689+ , benchList "toNull" toNullNestedList (sourceUnfoldrList value2)
690+ , benchList "toNull3" toNullNestedList3 (sourceUnfoldrList value3)
691+ , benchList "filterAllIn" filterAllInNestedList (sourceUnfoldrList value2)
692+ , benchList "filterAllOut" filterAllOutNestedList (sourceUnfoldrList value2)
840693 ]
841694 ]
842695 where
843696
844− streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
845− streamLen3 = round (P.fromIntegral streamLen**(1/3::P.Double)) -- triple nested loop
697+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
698+ value3 = round (P.fromIntegral value**(1/3::P.Double)) -- triple nested loop
846699
847700o_1_space :: Int -> Benchmark
848−o_1_space streamLen =
701+o_1_space value =
849702 bgroup (o_1_space_prefix moduleName)
850− [ o_1_space_generation streamLen
851− , o_1_space_elimination streamLen
852− , o_1_space_nested streamLen
853− , o_1_space_transformation streamLen
854− , o_1_space_transformationX4 streamLen
855− , o_1_space_concat streamLen
856− , o_1_space_filtering streamLen
857− , o_1_space_filteringX4 streamLen
858− , o_1_space_zipping streamLen
859− , o_1_space_mixed streamLen
860− , o_1_space_mixedX2 streamLen
861− , o_1_space_mixedX4 streamLen
862− , o_1_space_list streamLen
703+ [ o_1_space_generation value
704+ , o_1_space_elimination value
705+ , o_1_space_nested value
706+ , o_1_space_transformation value
707+ , o_1_space_concat value
708+ , o_1_space_filtering value
709+ , o_1_space_zipping value
710+ , o_1_space_mixed value
711+ , o_1_space_list value
863712 ]
864713
865714o_n_heap :: Int -> Benchmark
866−o_n_heap streamLen =
715+o_n_heap value =
867716 bgroup (o_n_heap_prefix moduleName)
868717 [ bgroup "transformation"
869− [ benchFold "foldlS" (foldlS 1) (unfoldrM streamLen)
718+ [ benchFold "foldlS" (foldlS 1) (sourceUnfoldrM value)
870719 ]
871720 ]
872721
873722{-# INLINE benchK #-}
874723benchK :: P.String -> (Int -> Stream P.IO Int) -> Benchmark
875−benchK name f = bench name $ nfIO $ randomRIO (1,1) >>= drain . f
724+benchK name f = bench name $ nfIO $ randomRIO (1,1) >>= toNull . f
876725
877726o_n_stack :: Int -> Int -> Int -> Benchmark
878−o_n_stack streamLen iterStreamLen maxIters =
727+o_n_stack value iterStreamLen maxIters =
879728 bgroup (o_n_stack_prefix moduleName)
880729 [ bgroup "elimination"
881− [ benchFold "tail" tail (unfoldrM streamLen)
882− , benchFold "nullTail" nullTail (unfoldrM streamLen)
883− , benchFold "headTail" headTail (unfoldrM streamLen)
730+ [ benchFold "tail" tail (sourceUnfoldrM value)
731+ , benchFold "nullTail" nullTail (sourceUnfoldrM value)
732+ , benchFold "headTail" headTail (sourceUnfoldrM value)
884733 ]
885734 , bgroup "transformation"
886735 [
887736 -- XXX why do these need so much stack
888− benchFold "intersperse" (intersperse streamLen 1) (unfoldrM streamLen2)
889− , benchFold "interspersePure" (intersperse streamLen 1) (unfoldr streamLen2)
737+ benchFold "intersperse" (intersperse maxValue 1) (sourceUnfoldrM value2)
738+ , benchFold "interspersePure" (intersperse maxValue 1) (sourceUnfoldr value2)
890739 ]
891740 , bgroup "transformationX4"
892741 [
893− benchFold "intersperse" (intersperse streamLen 4) (unfoldrM streamLen16)
742+ benchFold "intersperse" (intersperse maxValue 4) (sourceUnfoldrM value16)
894743 ]
895744 , bgroup "iterated"
896745 [ benchK "mapM" (iterateMapM iterStreamLen maxIters)
897746 , benchK "scan(1/10)" (iterateScan iterStreamLen maxIters)
898747 , benchK "filterEven" (iterateFilterEven iterStreamLen maxIters)
899− , benchK "takeAll" (iterateTakeAll streamLen iterStreamLen maxIters)
748+ , benchK "takeAll" (iterateTakeAll maxValue iterStreamLen maxIters)
900749 , benchK "dropOne" (iterateDropOne iterStreamLen maxIters)
901− , benchK "dropWhileFalse(1/10)" (iterateDropWhileFalse streamLen iterStreamLen maxIters)
902− , benchK "dropWhileTrue" (iterateDropWhileTrue streamLen iterStreamLen maxIters)
750+ , benchK "dropWhileFalse(1/10)" (iterateDropWhileFalse maxValue iterStreamLen maxIters)
751+ , benchK "dropWhileTrue" (iterateDropWhileTrue maxValue iterStreamLen maxIters)
903752 ]
904753 ]
905754 where
906− streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop
907− streamLen16 = round (P.fromIntegral streamLen**(1/16::P.Double)) -- triple nested loop
755+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
756+ value16 = round (P.fromIntegral value**(1/16::P.Double)) -- triple nested loop
757+ maxValue = value
908758
909759o_n_space :: Int -> Benchmark
910−o_n_space streamLen =
760+o_n_space value =
911761 bgroup (o_n_space_prefix moduleName)
912762 [ bgroup "elimination"
913− [ benchFold "toList" toList (unfoldrM streamLen)
763+ [ benchFold "toList" toList (sourceUnfoldrM value)
914764 ]
915765 ]
916766
@@ -921,14 +771,14 @@ benchList name run f = bench name $ nfIO $ randomRIO (1,1) >>= return . run . f
921771main :: IO ()
922772main =
923773 defaultMain
924− [ o_1_space streamLen
925− , o_n_stack streamLen iterStreamLen maxIters
926− , o_n_heap streamLen
927− , o_n_space streamLen
774+ [ o_1_space value
775+ , o_n_stack value iterStreamLen maxIters
776+ , o_n_heap value
777+ , o_n_space value
928778 ]
929779
930780 where
931781
932− streamLen = 100000
782+ value = 100000
933783 maxIters = 10000
934784 iterStreamLen = 10