benchmark/Streamly/Benchmark/Data/Stream/StreamD.hs · streamly

git.iko.soy/streamly

on 240a082 help sign in

streamly/benchmark/Streamly/Benchmark/Data/Stream/StreamD.hs

614 lines 21 kB history raw

1-- |

2-- Module : Streamly.Benchmark.Data.Stream.StreamD

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-------------------------------------------------------------------------------

102

103{-# INLINE runStream #-}

104runStream :: Monad m => Stream m a -> m ()

105runStream = S.drain

106

107{-# INLINE mapM_ #-}

108mapM_ :: Monad m => Stream m a -> m ()

109mapM_ = S.mapM_ (\_ -> return ())

110

111{-# INLINE toNull #-}

112toNull :: Monad m => Stream m Int -> m ()

113toNull = runStream

114

115{-# INLINE uncons #-}

116{-# INLINE nullTail #-}

117{-# INLINE headTail #-}

118uncons, nullTail, headTail

119 :: Monad m

120 => Stream m Int -> m ()

121

122uncons s = do

123 r <- S.uncons s

124 case r of

125 Nothing -> return ()

126 Just (_, t) -> uncons t

127

128{-# INLINE tail #-}

129tail :: Monad m => Stream m a -> m ()

130tail s = S.tail s >>= P.mapM_ tail

131

132nullTail s = do

133 r <- S.null s

134 when (not r) $ S.tail s >>= P.mapM_ nullTail

135

136headTail s = do

137 h <- S.head s

138 when (isJust h) $ S.tail s >>= P.mapM_ headTail

139

140{-# INLINE toList #-}

141toList :: Monad m => Stream m Int -> m [Int]

142toList = S.toList

143

144{-# INLINE foldl #-}

145foldl :: Monad m => Stream m Int -> m Int

146foldl = S.foldl' (+) 0

147

148{-# INLINE last #-}

149last :: Monad m => Stream m Int -> m (Maybe Int)

150last = S.last

151

152-------------------------------------------------------------------------------

153-- Transformation

154-------------------------------------------------------------------------------

155

156{-# INLINE transform #-}

157transform :: Monad m => Stream m a -> m ()

158transform = runStream

159

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

171

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 ()

199

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

223

224-------------------------------------------------------------------------------

225-- Iteration

226-------------------------------------------------------------------------------

227

228iterStreamLen, maxIters :: Int

229iterStreamLen = 10

230maxIters = 10000

231

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)

240

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

252

253-- this is quadratic

254iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)

255iterateDropWhileFalse = iterateSource (S.dropWhile (> maxValue))

256 (maxIters `div` 10)

257

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

263

264{-# INLINE iterateM #-}

265iterateM :: Monad m => Int -> Stream m Int

266iterateM i = S.take maxIters (S.iterateM (\x -> return (x + 1)) (return i))

267

268-------------------------------------------------------------------------------

269-- Zipping

270-------------------------------------------------------------------------------

271

272{-# INLINE eqBy #-}

273eqBy :: (Monad m, P.Eq a) => S.Stream m a -> m P.Bool

274eqBy src = S.eqBy (==) src src

275

276{-# INLINE cmpBy #-}

277cmpBy :: (Monad m, P.Ord a) => S.Stream m a -> m P.Ordering

278cmpBy src = S.cmpBy P.compare src src

279

280{-# INLINE zip #-}

281zip :: Monad m => Stream m Int -> m ()

282zip src = transform $ S.zipWith (,) src src

283

284-------------------------------------------------------------------------------

285-- Mixed Composition

286-------------------------------------------------------------------------------

287

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 ()

301

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)

312

313-------------------------------------------------------------------------------

314-- Nested Composition

315-------------------------------------------------------------------------------

316

317{-# INLINE toNullApNested #-}

318toNullApNested :: Monad m => Stream m Int -> m ()

319toNullApNested s = runStream $ do

320 (+) <$> s <*> s

321

322{-# INLINE toNullNested #-}

323toNullNested :: Monad m => Stream m Int -> m ()

324toNullNested s = runStream $ do

325 x <- s

326 y <- s

327 return $ x + y

328

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

336

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

348

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

360

361-------------------------------------------------------------------------------

362-- ConcatMap

363-------------------------------------------------------------------------------

364

365-- concatMap unfoldrM/unfoldrM

366

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)

373

374#ifdef INSPECTION

375inspect $ hasNoTypeClasses 'concatMap

376inspect $ 'concatMap `hasNoType` ''SPEC

377#endif

378

379-- concatMap unfoldr/unfoldr

380

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)

387

388#ifdef INSPECTION

389inspect $ hasNoTypeClasses 'concatMapPure

390inspect $ 'concatMapPure `hasNoType` ''SPEC

391#endif

392

393-- concatMap replicate/unfoldrM

394

395{-# INLINE concatMapRepl #-}

396concatMapRepl :: Int -> Int -> Int -> IO ()

397concatMapRepl outer inner n =

398 S.drain $ S.concatMap (S.replicate inner) (sourceUnfoldrMN outer n)

399

400#ifdef INSPECTION

401inspect $ hasNoTypeClasses 'concatMapRepl

402inspect $ 'concatMapRepl `hasNoType` ''SPEC

403#endif

404

405-- concatUnfold replicate/unfoldrM

406

407{-# INLINE concatUnfoldRepl #-}

408concatUnfoldRepl :: Int -> Int -> Int -> IO ()

409concatUnfoldRepl outer inner n =

410 S.drain $ S.concatMapU (UF.replicateM inner) (sourceUnfoldrMN outer n)

411

412#ifdef INSPECTION

413inspect $ hasNoTypeClasses 'concatUnfoldRepl

414inspect $ 'concatUnfoldRepl `hasNoType` ''S.ConcatMapUState

415inspect $ 'concatUnfoldRepl `hasNoType` ''SPEC

416#endif

417

418-------------------------------------------------------------------------------

419-- Benchmarks

420-------------------------------------------------------------------------------

421

422moduleName :: String

423moduleName = "Data.Stream.StreamD"

424

425o_1_space :: [Benchmark]

426o_1_space =

427 [ bgroup (o_1_space_prefix moduleName)

428 [ bgroup "generation"

429 [ benchFold "unfoldr" toNull sourceUnfoldr

430 , benchFold "unfoldrM" toNull sourceUnfoldrM

431 , benchFold "intFromTo" toNull sourceIntFromTo

432

433 , benchFold "fromList" toNull sourceFromList

434 ]

435 , bgroup "elimination"

436 [ benchFold "toNull" toNull sourceUnfoldrM

437 , benchFold "mapM_" mapM_ sourceUnfoldrM

438 , benchFold "uncons" uncons sourceUnfoldrM

439 , benchFold "foldl'" foldl sourceUnfoldrM

440 , benchFold "last" last sourceUnfoldrM

441 ]

442 , bgroup "nested"

443 [ benchFold "toNullAp" toNullApNested (sourceUnfoldrMN value2)

444 , benchFold "toNull" toNullNested (sourceUnfoldrMN value2)

445 , benchFold "toNull3" toNullNested3 (sourceUnfoldrMN value3)

446 , benchFold "filterAllIn" filterAllInNested (sourceUnfoldrMN value2)

447 , benchFold "filterAllOut" filterAllOutNested (sourceUnfoldrMN value2)

448 , benchFold "toNullApPure" toNullApNested (sourceUnfoldrN value2)

449 , benchFold "toNullPure" toNullNested (sourceUnfoldrN value2)

450 , benchFold "toNull3Pure" toNullNested3 (sourceUnfoldrN value3)

451 , benchFold "filterAllInPure" filterAllInNested (sourceUnfoldrN value2)

452 , benchFold "filterAllOutPure" filterAllOutNested (sourceUnfoldrN value2)

453 ]

454 , bgroup "transformation"

455 [ benchFold "scan" (scan 1) sourceUnfoldrM

456 , benchFold "map" (map 1) sourceUnfoldrM

457 , benchFold "fmap" (fmapD 1) sourceUnfoldrM

458 , benchFold "mapM" (mapM 1) sourceUnfoldrM

459 , benchFold "mapMaybe" (mapMaybe 1) sourceUnfoldrM

460 , benchFold "mapMaybeM" (mapMaybeM 1) sourceUnfoldrM

461 ]

462 , bgroup "transformationX4"

463 [ benchFold "scan" (scan 4) sourceUnfoldrM

464 , benchFold "map" (map 4) sourceUnfoldrM

465 , benchFold "fmap" (fmapD 4) sourceUnfoldrM

466 , benchFold "mapM" (mapM 4) sourceUnfoldrM

467 , benchFold "mapMaybe" (mapMaybe 4) sourceUnfoldrM

468 , benchFold "mapMaybeM" (mapMaybeM 4) sourceUnfoldrM

469 -- XXX this is horribly slow

470 -- , benchFold "concatMap" (concatMap 4) (sourceUnfoldrMN value16)

471 ]

472

473 , bgroup "concat"

474 [ benchIOSrc1 "concatMapPure (n of 1)"

475 (concatMapPure value 1)

476 , benchIOSrc1 "concatMapPure (sqrt n of sqrt n)"

477 (concatMapPure value2 value2)

478 , benchIOSrc1 "concatMapPure (1 of n)"

479 (concatMapPure 1 value)

480

481 , benchIOSrc1 "concatMap (n of 1)"

482 (concatMap value 1)

483 , benchIOSrc1 "concatMap (sqrt n of sqrt n)"

484 (concatMap value2 value2)

485 , benchIOSrc1 "concatMap (1 of n)"

486 (concatMap 1 value)

487

488 -- concatMap vs concatUnfold

489 , benchIOSrc1 "concatMapRepl (sqrt n of sqrt n)"

490 (concatMapRepl value2 value2)

491 , benchIOSrc1 "concatUnfoldRepl (sqrt n of sqrt n)"

492 (concatUnfoldRepl value2 value2)

493 ]

494 , bgroup "filtering"

495 [ benchFold "filter-even" (filterEven 1) sourceUnfoldrM

496 , benchFold "filter-all-out" (filterAllOut 1) sourceUnfoldrM

497 , benchFold "filter-all-in" (filterAllIn 1) sourceUnfoldrM

498 , benchFold "take-all" (takeAll 1) sourceUnfoldrM

499 , benchFold "takeWhile-true" (takeWhileTrue 1) sourceUnfoldrM

500 , benchFold "drop-one" (dropOne 1) sourceUnfoldrM

501 , benchFold "drop-all" (dropAll 1) sourceUnfoldrM

502 , benchFold "dropWhile-true" (dropWhileTrue 1) sourceUnfoldrM

503 , benchFold "dropWhile-false" (dropWhileFalse 1) sourceUnfoldrM

504 ]

505 , bgroup "filteringX4"

506 [ benchFold "filter-even" (filterEven 4) sourceUnfoldrM

507 , benchFold "filter-all-out" (filterAllOut 4) sourceUnfoldrM

508 , benchFold "filter-all-in" (filterAllIn 4) sourceUnfoldrM

509 , benchFold "take-all" (takeAll 4) sourceUnfoldrM

510 , benchFold "takeWhile-true" (takeWhileTrue 4) sourceUnfoldrM

511 , benchFold "drop-one" (dropOne 4) sourceUnfoldrM

512 , benchFold "drop-all" (dropAll 4) sourceUnfoldrM

513 , benchFold "dropWhile-true" (dropWhileTrue 4) sourceUnfoldrM

514 , benchFold "dropWhile-false" (dropWhileFalse 4) sourceUnfoldrM

515 ]

516 , bgroup "zipping"

517 [ benchFold "eqBy" eqBy sourceUnfoldrM

518 , benchFold "cmpBy" cmpBy sourceUnfoldrM

519 , benchFold "zip" zip sourceUnfoldrM

520 ]

521 , bgroup "mixed"

522 [ benchFold "scan-map" (scanMap 1) sourceUnfoldrM

523 , benchFold "drop-map" (dropMap 1) sourceUnfoldrM

524 , benchFold "drop-scan" (dropScan 1) sourceUnfoldrM

525 , benchFold "take-drop" (takeDrop 1) sourceUnfoldrM

526 , benchFold "take-scan" (takeScan 1) sourceUnfoldrM

527 , benchFold "take-map" (takeMap 1) sourceUnfoldrM

528 , benchFold "filter-drop" (filterDrop 1) sourceUnfoldrM

529 , benchFold "filter-take" (filterTake 1) sourceUnfoldrM

530 , benchFold "filter-scan" (filterScan 1) sourceUnfoldrM

531 , benchFold "filter-map" (filterMap 1) sourceUnfoldrM

532 ]

533 , bgroup "mixedX2"

534 [ benchFold "scan-map" (scanMap 2) sourceUnfoldrM

535 , benchFold "drop-map" (dropMap 2) sourceUnfoldrM

536 , benchFold "drop-scan" (dropScan 2) sourceUnfoldrM

537 , benchFold "take-drop" (takeDrop 2) sourceUnfoldrM

538 , benchFold "take-scan" (takeScan 2) sourceUnfoldrM

539 , benchFold "take-map" (takeMap 2) sourceUnfoldrM

540 , benchFold "filter-drop" (filterDrop 2) sourceUnfoldrM

541 , benchFold "filter-take" (filterTake 2) sourceUnfoldrM

542 , benchFold "filter-scan" (filterScan 2) sourceUnfoldrM

543 , benchFold "filter-map" (filterMap 2) sourceUnfoldrM

544 ]

545 , bgroup "mixedX4"

546 [ benchFold "scan-map" (scanMap 4) sourceUnfoldrM

547 , benchFold "drop-map" (dropMap 4) sourceUnfoldrM

548 , benchFold "drop-scan" (dropScan 4) sourceUnfoldrM

549 , benchFold "take-drop" (takeDrop 4) sourceUnfoldrM

550 , benchFold "take-scan" (takeScan 4) sourceUnfoldrM

551 , benchFold "take-map" (takeMap 4) sourceUnfoldrM

552 , benchFold "filter-drop" (filterDrop 4) sourceUnfoldrM

553 , benchFold "filter-take" (filterTake 4) sourceUnfoldrM

554 , benchFold "filter-scan" (filterScan 4) sourceUnfoldrM

555 , benchFold "filter-map" (filterMap 4) sourceUnfoldrM

556 ]

557 ]

558 ]

559

560-- | Takes a source, and uses it with a default drain/fold method.

561{-# INLINE benchD #-}

562benchD :: P.String -> (Int -> Stream P.IO Int) -> Benchmark

563benchD name f = bench name $ nfIO $ randomRIO (1,1) >>= toNull . f

564

565o_n_stack :: [Benchmark]

566o_n_stack =

567 [ bgroup (o_n_stack_prefix moduleName)

568 [ bgroup "elimination"

569 [ benchFold "tail" tail sourceUnfoldrM

570 , benchFold "nullTail" nullTail sourceUnfoldrM

571 , benchFold "headTail" headTail sourceUnfoldrM

572 ]

573 , bgroup "transformation"

574 [

575 -- this is horribly slow

576 -- benchFold "foldrS" (_foldrS 1) sourceUnfoldrM

577 -- XXX why do these need so much stack

578 benchFold "intersperse" (intersperse 1) (sourceUnfoldrMN value2)

579 , benchFold "interspersePure" (intersperse 1) (sourceUnfoldrN value2)

580 ]

581 , bgroup "transformationX4"

582 [

583 benchFold "intersperse" (intersperse 4) (sourceUnfoldrMN value16)

584 ]

585 , bgroup "iterated"

586 [ benchD "mapM" iterateMapM

587 , benchD "scan(1/10)" iterateScan

588 , benchD "filterEven" iterateFilterEven

589 , benchD "takeAll" iterateTakeAll

590 , benchD "dropOne" iterateDropOne

591 , benchD "dropWhileFalse(1/10)" iterateDropWhileFalse

592 , benchD "dropWhileTrue" iterateDropWhileTrue

593 , benchD "iterateM" iterateM

594 ]

595 ]

596 ]

597

598o_n_space :: [Benchmark]

599o_n_space =

600 [ bgroup (o_n_space_prefix moduleName)

601 [ bgroup "elimination"

602 [ benchFold "toList" toList sourceUnfoldrM

603 ]

604 , bgroup "transformation"

605 [

606

607 -- This is horribly slow, never finishes

608 -- benchFold "foldlS" (_foldlS 1) sourceUnfoldrM

609 ]

610 ]

611 ]

612

613main :: IO ()

614main = defaultMain $ concat [o_1_space, o_n_stack, o_n_space]