git.iko.soy/streamly
on a05abfc help sign in
streamly/benchmark/Streamly/Benchmark/Data/Stream/StreamD.hs
617 lines 22 kB history raw
1-- |
2-- Module : Streamly.Benchmark.Data.Stream.StreamD
3-- Copyright : (c) 2018 Composewell Technologies
4--
5-- License : BSD3
6-- Maintainer : streamly@composewell.com
8{-# LANGUAGE CPP #-}
9{-# LANGUAGE FlexibleContexts #-}
10{-# LANGUAGE ScopedTypeVariables #-}
12#ifdef __HADDOCK_VERSION__
13#undef INSPECTION
14#endif
16#ifdef INSPECTION
17{-# LANGUAGE TemplateHaskell #-}
18{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}
19#endif
21module Main (main) where
23import Control.Monad (when)
24import Data.Maybe (isJust)
25import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)
26import System.Random (randomRIO)
27import Prelude hiding (tail, mapM_, foldl, last, map, mapM, concatMap, zip)
29import qualified Prelude as P
30import qualified Streamly.Internal.Data.Stream.StreamD as S
31import qualified Streamly.Internal.Data.Unfold as UF
33import Streamly.Benchmark.Common
35#ifdef INSPECTION
36import GHC.Types (SPEC(..))
37import Test.Inspection
38#endif
40-- We try to keep the total number of iterations same irrespective of nesting
41-- of the loops so that the overhead is easy to compare.
42value, value2, value3, value16, maxValue :: Int
43value = 100000
44value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
45value3 = round (P.fromIntegral value**(1/3::P.Double)) -- triple nested loop
46value16 = round (P.fromIntegral value**(1/16::P.Double)) -- triple nested loop
47maxValue = value
49-------------------------------------------------------------------------------
50-- Stream generation and elimination
51-------------------------------------------------------------------------------
53type Stream m a = S.Stream m a
55{-# INLINE sourceUnfoldr #-}
56sourceUnfoldr :: Monad m => Int -> Stream m Int
57sourceUnfoldr n = S.unfoldr step n
58 where
59 step cnt =
60 if cnt > n + value
61 then Nothing
62 else Just (cnt, cnt + 1)
64{-# INLINE sourceUnfoldrN #-}
65sourceUnfoldrN :: Monad m => Int -> Int -> Stream m Int
66sourceUnfoldrN m n = S.unfoldr step n
67 where
68 step cnt =
69 if cnt > n + m
70 then Nothing
71 else Just (cnt, cnt + 1)
73{-# INLINE sourceUnfoldrMN #-}
74sourceUnfoldrMN :: Monad m => Int -> Int -> Stream m Int
75sourceUnfoldrMN m n = S.unfoldrM step n
76 where
77 step cnt =
78 if cnt > n + m
79 then return Nothing
80 else return (Just (cnt, cnt + 1))
82{-# INLINE sourceUnfoldrM #-}
83sourceUnfoldrM :: Monad m => Int -> Stream m Int
84sourceUnfoldrM n = S.unfoldrM step n
85 where
86 step cnt =
87 if cnt > n + value
88 then return Nothing
89 else return (Just (cnt, cnt + 1))
91{-# INLINE sourceIntFromTo #-}
92sourceIntFromTo :: Monad m => Int -> Stream m Int
93sourceIntFromTo n = S.enumerateFromToIntegral n (n + value)
95{-# INLINE sourceFromList #-}
96sourceFromList :: Monad m => Int -> Stream m Int
97sourceFromList n = S.fromList [n..n+value]
99-------------------------------------------------------------------------------
100-- Elimination
101-------------------------------------------------------------------------------
103{-# INLINE runStream #-}
104runStream :: Monad m => Stream m a -> m ()
105runStream = S.drain
107{-# INLINE mapM_ #-}
108mapM_ :: Monad m => Stream m a -> m ()
109mapM_ = S.mapM_ (\_ -> return ())
111{-# INLINE toNull #-}
112toNull :: Monad m => Stream m Int -> m ()
113toNull = runStream
115{-# INLINE uncons #-}
116{-# INLINE nullTail #-}
117{-# INLINE headTail #-}
118uncons, nullTail, headTail
119 :: Monad m
120 => Stream m Int -> m ()
122uncons s = do
123 r <- S.uncons s
124 case r of
125 Nothing -> return ()
126 Just (_, t) -> uncons t
128{-# INLINE tail #-}
129tail :: Monad m => Stream m a -> m ()
130tail s = S.tail s >>= P.mapM_ tail
132nullTail s = do
133 r <- S.null s
134 when (not r) $ S.tail s >>= P.mapM_ nullTail
136headTail s = do
137 h <- S.head s
138 when (isJust h) $ S.tail s >>= P.mapM_ headTail
140{-# INLINE toList #-}
141toList :: Monad m => Stream m Int -> m [Int]
142toList = S.toList
144{-# INLINE foldl #-}
145foldl :: Monad m => Stream m Int -> m Int
146foldl = S.foldl' (+) 0
148{-# INLINE last #-}
149last :: Monad m => Stream m Int -> m (Maybe Int)
150last = S.last
152-------------------------------------------------------------------------------
153-- Transformation
154-------------------------------------------------------------------------------
156{-# INLINE transform #-}
157transform :: Monad m => Stream m a -> m ()
158transform = runStream
160{-# INLINE composeN #-}
161composeN
162 :: Monad m
163 => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()
164composeN n f =
165 case n of
166 1 -> transform . f
167 2 -> transform . f . f
168 3 -> transform . f . f . f
169 4 -> transform . f . f . f . f
170 _ -> undefined
172{-# INLINE scan #-}
173{-# INLINE map #-}
174{-# INLINE fmapD #-}
175{-# INLINE mapM #-}
176{-# INLINE mapMaybe #-}
177{-# INLINE mapMaybeM #-}
178{-# INLINE filterEven #-}
179{-# INLINE filterAllOut #-}
180{-# INLINE filterAllIn #-}
181{-# INLINE _takeOne #-}
182{-# INLINE takeAll #-}
183{-# INLINE takeWhileTrue #-}
184{-# INLINE _takeWhileMTrue #-}
185{-# INLINE dropOne #-}
186{-# INLINE dropAll #-}
187{-# INLINE dropWhileTrue #-}
188{-# INLINE _dropWhileMTrue #-}
189{-# INLINE dropWhileFalse #-}
190{-# INLINE _foldrS #-}
191{-# INLINE _foldlS #-}
192{-# INLINE intersperse #-}
193scan, map, fmapD, mapM, mapMaybe, mapMaybeM, filterEven, filterAllOut,
194 filterAllIn, _takeOne, takeAll, takeWhileTrue, _takeWhileMTrue, dropOne,
195 dropAll, dropWhileTrue, _dropWhileMTrue, dropWhileFalse, _foldrS, _foldlS,
196 intersperse
197 :: Monad m
198 => Int -> Stream m Int -> m ()
200scan n = composeN n $ S.scanl' (+) 0
201fmapD n = composeN n $ Prelude.fmap (+1)
202map n = composeN n $ S.map (+1)
203mapM n = composeN n $ S.mapM return
204mapMaybe n = composeN n $ S.mapMaybe
205 (\x -> if Prelude.odd x then Nothing else Just x)
206mapMaybeM n = composeN n $ S.mapMaybeM
207 (\x -> if Prelude.odd x then return Nothing else return $ Just x)
208filterEven n = composeN n $ S.filter even
209filterAllOut n = composeN n $ S.filter (> maxValue)
210filterAllIn n = composeN n $ S.filter (<= maxValue)
211_takeOne n = composeN n $ S.take 1
212takeAll n = composeN n $ S.take maxValue
213takeWhileTrue n = composeN n $ S.takeWhile (<= maxValue)
214_takeWhileMTrue n = composeN n $ S.takeWhileM (return . (<= maxValue))
215dropOne n = composeN n $ S.drop 1
216dropAll n = composeN n $ S.drop maxValue
217dropWhileTrue n = composeN n $ S.dropWhile (<= maxValue)
218_dropWhileMTrue n = composeN n $ S.dropWhileM (return . (<= maxValue))
219dropWhileFalse n = composeN n $ S.dropWhile (> maxValue)
220_foldrS n = composeN n $ S.foldrS S.cons S.nil
221_foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil
222intersperse n = composeN n $ S.intersperse maxValue
224-------------------------------------------------------------------------------
225-- Iteration
226-------------------------------------------------------------------------------
228iterStreamLen, maxIters :: Int
229iterStreamLen = 10
230maxIters = 10000
232{-# INLINE iterateSource #-}
233iterateSource
234 :: Monad m
235 => (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
236iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)
237 where
238 f (0 :: Int) m = g m
239 f x m = g (f (x P.- 1) m)
241{-# INLINE iterateMapM #-}
242{-# INLINE iterateScan #-}
243{-# INLINE iterateFilterEven #-}
244{-# INLINE iterateTakeAll #-}
245{-# INLINE iterateDropOne #-}
246{-# INLINE iterateDropWhileFalse #-}
247{-# INLINE iterateDropWhileTrue #-}
248iterateMapM, iterateScan, iterateFilterEven, iterateTakeAll, iterateDropOne,
249 iterateDropWhileFalse, iterateDropWhileTrue
250 :: Monad m
251 => Int -> Stream m Int
253-- this is quadratic
254iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)
255iterateDropWhileFalse = iterateSource (S.dropWhile (> maxValue))
256 (maxIters `div` 10)
258iterateMapM = iterateSource (S.mapM return) maxIters
259iterateFilterEven = iterateSource (S.filter even) maxIters
260iterateTakeAll = iterateSource (S.take maxValue) maxIters
261iterateDropOne = iterateSource (S.drop 1) maxIters
262iterateDropWhileTrue = iterateSource (S.dropWhile (<= maxValue)) maxIters
264{-# INLINE iterateM #-}
265iterateM :: Monad m => Int -> Stream m Int
266iterateM i = S.take maxIters (S.iterateM (\x -> return (x + 1)) (return i))
268-------------------------------------------------------------------------------
269-- Zipping
270-------------------------------------------------------------------------------
272{-# INLINE eqBy #-}
273eqBy :: (Monad m, P.Eq a) => S.Stream m a -> m P.Bool
274eqBy src = S.eqBy (==) src src
276{-# INLINE cmpBy #-}
277cmpBy :: (Monad m, P.Ord a) => S.Stream m a -> m P.Ordering
278cmpBy src = S.cmpBy P.compare src src
280{-# INLINE zip #-}
281zip :: Monad m => Stream m Int -> m ()
282zip src = transform $ S.zipWith (,) src src
284-------------------------------------------------------------------------------
285-- Mixed Composition
286-------------------------------------------------------------------------------
288{-# INLINE scanMap #-}
289{-# INLINE dropMap #-}
290{-# INLINE dropScan #-}
291{-# INLINE takeDrop #-}
292{-# INLINE takeScan #-}
293{-# INLINE takeMap #-}
294{-# INLINE filterDrop #-}
295{-# INLINE filterTake #-}
296{-# INLINE filterScan #-}
297{-# INLINE filterMap #-}
298scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
299 filterTake, filterScan, filterMap
300 :: Monad m => Int -> Stream m Int -> m ()
302scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0
303dropMap n = composeN n $ S.map (subtract 1) . S.drop 1
304dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
305takeDrop n = composeN n $ S.drop 1 . S.take maxValue
306takeScan n = composeN n $ S.scanl' (+) 0 . S.take maxValue
307takeMap n = composeN n $ S.map (subtract 1) . S.take maxValue
308filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)
309filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)
310filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
311filterMap n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)
313-------------------------------------------------------------------------------
314-- Nested Composition
315-------------------------------------------------------------------------------
317{-# INLINE toNullApNested #-}
318toNullApNested :: Monad m => Stream m Int -> m ()
319toNullApNested s = runStream $ do
320 (+) <$> s <*> s
322{-# INLINE toNullNested #-}
323toNullNested :: Monad m => Stream m Int -> m ()
324toNullNested s = runStream $ do
325 x <- s
326 y <- s
327 return $ x + y
329{-# INLINE toNullNested3 #-}
330toNullNested3 :: Monad m => Stream m Int -> m ()
331toNullNested3 s = runStream $ do
332 x <- s
333 y <- s
334 z <- s
335 return $ x + y + z
337{-# INLINE filterAllOutNested #-}
338filterAllOutNested
339 :: Monad m
340 => Stream m Int -> m ()
341filterAllOutNested str = runStream $ do
342 x <- str
343 y <- str
344 let s = x + y
345 if s < 0
346 then return s
347 else S.nil
349{-# INLINE filterAllInNested #-}
350filterAllInNested
351 :: Monad m
352 => Stream m Int -> m ()
353filterAllInNested str = runStream $ do
354 x <- str
355 y <- str
356 let s = x + y
357 if s > 0
358 then return s
359 else S.nil
361-------------------------------------------------------------------------------
362-- ConcatMap
363-------------------------------------------------------------------------------
365-- concatMap unfoldrM/unfoldrM
367{-# INLINE concatMap #-}
368concatMap :: Int -> Int -> Int -> IO ()
369concatMap outer inner n =
370 S.drain $ S.concatMap
371 (\_ -> sourceUnfoldrMN inner n)
372 (sourceUnfoldrMN outer n)
374#ifdef INSPECTION
375inspect $ hasNoTypeClasses 'concatMap
376inspect $ 'concatMap `hasNoType` ''SPEC
377#endif
379-- concatMap unfoldr/unfoldr
381{-# INLINE concatMapPure #-}
382concatMapPure :: Int -> Int -> Int -> IO ()
383concatMapPure outer inner n =
384 S.drain $ S.concatMap
385 (\_ -> sourceUnfoldrN inner n)
386 (sourceUnfoldrN outer n)
388#ifdef INSPECTION
389inspect $ hasNoTypeClasses 'concatMapPure
390inspect $ 'concatMapPure `hasNoType` ''SPEC
391#endif
393-- concatMap replicate/unfoldrM
395{-# INLINE concatMapRepl #-}
396concatMapRepl :: Int -> Int -> Int -> IO ()
397concatMapRepl outer inner n =
398 S.drain $ S.concatMap (S.replicate inner) (sourceUnfoldrMN outer n)
400#ifdef INSPECTION
401inspect $ hasNoTypeClasses 'concatMapRepl
402inspect $ 'concatMapRepl `hasNoType` ''SPEC
403#endif
405-- unfoldMany replicate/unfoldrM
407{-# INLINE unfoldManyRepl #-}
408unfoldManyRepl :: Int -> Int -> Int -> IO ()
409unfoldManyRepl outer inner n =
410 S.drain
411 $ S.unfoldMany
412 (UF.lmap return (UF.replicateM inner))
413 (sourceUnfoldrMN outer n)
415#ifdef INSPECTION
416inspect $ hasNoTypeClasses 'unfoldManyRepl
417inspect $ 'unfoldManyRepl `hasNoType` ''S.ConcatMapUState
418inspect $ 'unfoldManyRepl `hasNoType` ''SPEC
419#endif
421-------------------------------------------------------------------------------
422-- Benchmarks
423-------------------------------------------------------------------------------
425moduleName :: String
426moduleName = "Data.Stream.StreamD"
428o_1_space :: [Benchmark]
429o_1_space =
430 [ bgroup (o_1_space_prefix moduleName)
431 [ bgroup "generation"
432 [ benchFold "unfoldr" toNull sourceUnfoldr
433 , benchFold "unfoldrM" toNull sourceUnfoldrM
434 , benchFold "intFromTo" toNull sourceIntFromTo
436 , benchFold "fromList" toNull sourceFromList
437 ]
438 , bgroup "elimination"
439 [ benchFold "toNull" toNull sourceUnfoldrM
440 , benchFold "mapM_" mapM_ sourceUnfoldrM
441 , benchFold "uncons" uncons sourceUnfoldrM
442 , benchFold "foldl'" foldl sourceUnfoldrM
443 , benchFold "last" last sourceUnfoldrM
444 ]
445 , bgroup "nested"
446 [ benchFold "toNullAp" toNullApNested (sourceUnfoldrMN value2)
447 , benchFold "toNull" toNullNested (sourceUnfoldrMN value2)
448 , benchFold "toNull3" toNullNested3 (sourceUnfoldrMN value3)
449 , benchFold "filterAllIn" filterAllInNested (sourceUnfoldrMN value2)
450 , benchFold "filterAllOut" filterAllOutNested (sourceUnfoldrMN value2)
451 , benchFold "toNullApPure" toNullApNested (sourceUnfoldrN value2)
452 , benchFold "toNullPure" toNullNested (sourceUnfoldrN value2)
453 , benchFold "toNull3Pure" toNullNested3 (sourceUnfoldrN value3)
454 , benchFold "filterAllInPure" filterAllInNested (sourceUnfoldrN value2)
455 , benchFold "filterAllOutPure" filterAllOutNested (sourceUnfoldrN value2)
456 ]
457 , bgroup "transformation"
458 [ benchFold "scan" (scan 1) sourceUnfoldrM
459 , benchFold "map" (map 1) sourceUnfoldrM
460 , benchFold "fmap" (fmapD 1) sourceUnfoldrM
461 , benchFold "mapM" (mapM 1) sourceUnfoldrM
462 , benchFold "mapMaybe" (mapMaybe 1) sourceUnfoldrM
463 , benchFold "mapMaybeM" (mapMaybeM 1) sourceUnfoldrM
464 ]
465 , bgroup "transformationX4"
466 [ benchFold "scan" (scan 4) sourceUnfoldrM
467 , benchFold "map" (map 4) sourceUnfoldrM
468 , benchFold "fmap" (fmapD 4) sourceUnfoldrM
469 , benchFold "mapM" (mapM 4) sourceUnfoldrM
470 , benchFold "mapMaybe" (mapMaybe 4) sourceUnfoldrM
471 , benchFold "mapMaybeM" (mapMaybeM 4) sourceUnfoldrM
472 -- XXX this is horribly slow
473 -- , benchFold "concatMap" (concatMap 4) (sourceUnfoldrMN value16)
474 ]
476 , bgroup "concat"
477 [ benchIOSrc1 "concatMapPure (n of 1)"
478 (concatMapPure value 1)
479 , benchIOSrc1 "concatMapPure (sqrt n of sqrt n)"
480 (concatMapPure value2 value2)
481 , benchIOSrc1 "concatMapPure (1 of n)"
482 (concatMapPure 1 value)
484 , benchIOSrc1 "concatMap (n of 1)"
485 (concatMap value 1)
486 , benchIOSrc1 "concatMap (sqrt n of sqrt n)"
487 (concatMap value2 value2)
488 , benchIOSrc1 "concatMap (1 of n)"
489 (concatMap 1 value)
491 -- concatMap vs unfoldMany
492 , benchIOSrc1 "concatMapRepl (sqrt n of sqrt n)"
493 (concatMapRepl value2 value2)
494 , benchIOSrc1 "unfoldManyRepl (sqrt n of sqrt n)"
495 (unfoldManyRepl value2 value2)
496 ]
497 , bgroup "filtering"
498 [ benchFold "filter-even" (filterEven 1) sourceUnfoldrM
499 , benchFold "filter-all-out" (filterAllOut 1) sourceUnfoldrM
500 , benchFold "filter-all-in" (filterAllIn 1) sourceUnfoldrM
501 , benchFold "take-all" (takeAll 1) sourceUnfoldrM
502 , benchFold "takeWhile-true" (takeWhileTrue 1) sourceUnfoldrM
503 , benchFold "drop-one" (dropOne 1) sourceUnfoldrM
504 , benchFold "drop-all" (dropAll 1) sourceUnfoldrM
505 , benchFold "dropWhile-true" (dropWhileTrue 1) sourceUnfoldrM
506 , benchFold "dropWhile-false" (dropWhileFalse 1) sourceUnfoldrM
507 ]
508 , bgroup "filteringX4"
509 [ benchFold "filter-even" (filterEven 4) sourceUnfoldrM
510 , benchFold "filter-all-out" (filterAllOut 4) sourceUnfoldrM
511 , benchFold "filter-all-in" (filterAllIn 4) sourceUnfoldrM
512 , benchFold "take-all" (takeAll 4) sourceUnfoldrM
513 , benchFold "takeWhile-true" (takeWhileTrue 4) sourceUnfoldrM
514 , benchFold "drop-one" (dropOne 4) sourceUnfoldrM
515 , benchFold "drop-all" (dropAll 4) sourceUnfoldrM
516 , benchFold "dropWhile-true" (dropWhileTrue 4) sourceUnfoldrM
517 , benchFold "dropWhile-false" (dropWhileFalse 4) sourceUnfoldrM
518 ]
519 , bgroup "zipping"
520 [ benchFold "eqBy" eqBy sourceUnfoldrM
521 , benchFold "cmpBy" cmpBy sourceUnfoldrM
522 , benchFold "zip" zip sourceUnfoldrM
523 ]
524 , bgroup "mixed"
525 [ benchFold "scan-map" (scanMap 1) sourceUnfoldrM
526 , benchFold "drop-map" (dropMap 1) sourceUnfoldrM
527 , benchFold "drop-scan" (dropScan 1) sourceUnfoldrM
528 , benchFold "take-drop" (takeDrop 1) sourceUnfoldrM
529 , benchFold "take-scan" (takeScan 1) sourceUnfoldrM
530 , benchFold "take-map" (takeMap 1) sourceUnfoldrM
531 , benchFold "filter-drop" (filterDrop 1) sourceUnfoldrM
532 , benchFold "filter-take" (filterTake 1) sourceUnfoldrM
533 , benchFold "filter-scan" (filterScan 1) sourceUnfoldrM
534 , benchFold "filter-map" (filterMap 1) sourceUnfoldrM
535 ]
536 , bgroup "mixedX2"
537 [ benchFold "scan-map" (scanMap 2) sourceUnfoldrM
538 , benchFold "drop-map" (dropMap 2) sourceUnfoldrM
539 , benchFold "drop-scan" (dropScan 2) sourceUnfoldrM
540 , benchFold "take-drop" (takeDrop 2) sourceUnfoldrM
541 , benchFold "take-scan" (takeScan 2) sourceUnfoldrM
542 , benchFold "take-map" (takeMap 2) sourceUnfoldrM
543 , benchFold "filter-drop" (filterDrop 2) sourceUnfoldrM
544 , benchFold "filter-take" (filterTake 2) sourceUnfoldrM
545 , benchFold "filter-scan" (filterScan 2) sourceUnfoldrM
546 , benchFold "filter-map" (filterMap 2) sourceUnfoldrM
547 ]
548 , bgroup "mixedX4"
549 [ benchFold "scan-map" (scanMap 4) sourceUnfoldrM
550 , benchFold "drop-map" (dropMap 4) sourceUnfoldrM
551 , benchFold "drop-scan" (dropScan 4) sourceUnfoldrM
552 , benchFold "take-drop" (takeDrop 4) sourceUnfoldrM
553 , benchFold "take-scan" (takeScan 4) sourceUnfoldrM
554 , benchFold "take-map" (takeMap 4) sourceUnfoldrM
555 , benchFold "filter-drop" (filterDrop 4) sourceUnfoldrM
556 , benchFold "filter-take" (filterTake 4) sourceUnfoldrM
557 , benchFold "filter-scan" (filterScan 4) sourceUnfoldrM
558 , benchFold "filter-map" (filterMap 4) sourceUnfoldrM
559 ]
560 ]
561 ]
563-- | Takes a source, and uses it with a default drain/fold method.
564{-# INLINE benchD #-}
565benchD :: P.String -> (Int -> Stream P.IO Int) -> Benchmark
566benchD name f = bench name $ nfIO $ randomRIO (1,1) >>= toNull . f
568o_n_stack :: [Benchmark]
569o_n_stack =
570 [ bgroup (o_n_stack_prefix moduleName)
571 [ bgroup "elimination"
572 [ benchFold "tail" tail sourceUnfoldrM
573 , benchFold "nullTail" nullTail sourceUnfoldrM
574 , benchFold "headTail" headTail sourceUnfoldrM
575 ]
576 , bgroup "transformation"
577 [
578 -- this is horribly slow
579 -- benchFold "foldrS" (_foldrS 1) sourceUnfoldrM
580 -- XXX why do these need so much stack
581 benchFold "intersperse" (intersperse 1) (sourceUnfoldrMN value2)
582 , benchFold "interspersePure" (intersperse 1) (sourceUnfoldrN value2)
583 ]
584 , bgroup "transformationX4"
585 [
586 benchFold "intersperse" (intersperse 4) (sourceUnfoldrMN value16)
587 ]
588 , bgroup "iterated"
589 [ benchD "mapM" iterateMapM
590 , benchD "scan(1/10)" iterateScan
591 , benchD "filterEven" iterateFilterEven
592 , benchD "takeAll" iterateTakeAll
593 , benchD "dropOne" iterateDropOne
594 , benchD "dropWhileFalse(1/10)" iterateDropWhileFalse
595 , benchD "dropWhileTrue" iterateDropWhileTrue
596 , benchD "iterateM" iterateM
597 ]
598 ]
599 ]
601o_n_space :: [Benchmark]
602o_n_space =
603 [ bgroup (o_n_space_prefix moduleName)
604 [ bgroup "elimination"
605 [ benchFold "toList" toList sourceUnfoldrM
606 ]
607 , bgroup "transformation"
608 [
610 -- This is horribly slow, never finishes
611 -- benchFold "foldlS" (_foldlS 1) sourceUnfoldrM
612 ]
613 ]
614 ]
616main :: IO ()
617main = defaultMain $ concat [o_1_space, o_n_stack, o_n_space]