e3893e2 · streamly · git.iko.soy

173

174o_1_space_serial_elimination :: Int -> [Benchmark]

175o_1_space_serial_elimination value =

176− [ bgroup "serially"

177− [ bgroup "elimination"

176+ [ bgroup "elimination"

178− [ benchIOSink value "drain" (S.fold FL.drain)

177+ [ benchIOSink value "drain" (S.fold FL.drain)

179− , benchIOSink value "drainBy" (S.fold (FL.drainBy return))

178+ , benchIOSink value "drainBy" (S.fold (FL.drainBy return))

180− , benchIOSink value "drainN" (S.fold (FL.drainN value))

179+ , benchIOSink value "drainN" (S.fold (FL.drainN value))

181− , benchIOSink

180+ , benchIOSink

182− value

181+ value

183− "drainSepByTrue"

182+ "drainSepByTrue"

184− (S.fold (FL.drainSepBy $ (<=) (value + 1)))

183+ (S.fold (FL.drainSepBy $ (<=) (value + 1)))

185− , benchIOSink

184+ , benchIOSink

186− value

185+ value

187− "drainSepByFalse"

186+ "drainSepByFalse"

188− (S.fold (FL.drainSepBy $ (>=) (value + 1)))

187+ (S.fold (FL.drainSepBy $ (>=) (value + 1)))

189− , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)

188+ , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)

190− , benchIOSink value "last" (S.fold FL.last)

189+ , benchIOSink value "last" (S.fold FL.last)

191− , benchIOSink value "length" (S.fold FL.length)

190+ , benchIOSink value "length" (S.fold FL.length)

192− , benchIOSink value "sum" (S.fold FL.sum)

191+ , benchIOSink value "sum" (S.fold FL.sum)

193− , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))

192+ , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))

194− , benchIOSink value "product" (S.fold FL.product)

193+ , benchIOSink value "product" (S.fold FL.product)

195− , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))

194+ , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))

196− , benchIOSink value "maximum" (S.fold FL.maximum)

195+ , benchIOSink value "maximum" (S.fold FL.maximum)

197− , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))

196+ , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))

198− , benchIOSink value "minimum" (S.fold FL.minimum)

197+ , benchIOSink value "minimum" (S.fold FL.minimum)

199− , benchIOSink

198+ , benchIOSink

200− value

199+ value

201− "mean"

200+ "mean"

202− (\s ->

201+ (\s ->

203− S.fold

202+ S.fold

204− FL.mean

203+ FL.mean

205− (S.map (fromIntegral :: Int -> Double) s))

204+ (S.map (fromIntegral :: Int -> Double) s))

206− , benchIOSink

205+ , benchIOSink

207− value

206+ value

208− "variance"

207+ "variance"

209− (\s ->

208+ (\s ->

210− S.fold

209+ S.fold

211− FL.variance

210+ FL.variance

212− (S.map (fromIntegral :: Int -> Double) s))

211+ (S.map (fromIntegral :: Int -> Double) s))

213− , benchIOSink

212+ , benchIOSink

214− value

213+ value

215− "stdDev"

214+ "stdDev"

216− (\s ->

215+ (\s ->

217− S.fold

216+ S.fold

218− FL.stdDev

217+ FL.stdDev

219− (S.map (fromIntegral :: Int -> Double) s))

218+ (S.map (fromIntegral :: Int -> Double) s))

220− , benchIOSink

219+ , benchIOSink

221− value

220+ value

222− "mconcat"

221+ "mconcat"

223− (S.fold FL.mconcat . (S.map (Last . Just)))

222+ (S.fold FL.mconcat . (S.map (Last . Just)))

224− , benchIOSink

223+ , benchIOSink

225− value

224+ value

226− "foldMap"

225+ "foldMap"

227− (S.fold (FL.foldMap (Last . Just)))

226+ (S.fold (FL.foldMap (Last . Just)))

228− , benchIOSink

227+ , benchIOSink

229− value

228+ value

230− "foldMapM"

229+ "foldMapM"

231− (S.fold (FL.foldMapM (return . Last . Just)))

230+ (S.fold (FL.foldMapM (return . Last . Just)))

232− , benchIOSink value "index" (S.fold (FL.index (value + 1)))

231+ , benchIOSink value "index" (S.fold (FL.index (value + 1)))

233− , benchIOSink value "head" (S.fold FL.head)

232+ , benchIOSink value "head" (S.fold FL.head)

234− , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))

233+ , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))

235− , benchIOSink

234+ , benchIOSink

236− value

235+ value

237− "lookup"

236+ "lookup"

238− (S.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))

237+ (S.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))

239− , benchIOSink

238+ , benchIOSink

240− value

239+ value

241− "findIndex"

240+ "findIndex"

242− (S.fold (FL.findIndex (== (value + 1))))

241+ (S.fold (FL.findIndex (== (value + 1))))

243− , benchIOSink

242+ , benchIOSink

244− value

243+ value

245− "elemIndex"

244+ "elemIndex"

246− (S.fold (FL.elemIndex (value + 1)))

245+ (S.fold (FL.elemIndex (value + 1)))

247− , benchIOSink value "null" (S.fold FL.null)

246+ , benchIOSink value "null" (S.fold FL.null)

248− , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))

247+ , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))

249− , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))

248+ , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))

250− , benchIOSink value "all" $ all value

249+ , benchIOSink value "all" $ all value

251− , benchIOSink value "any" $ any value

250+ , benchIOSink value "any" $ any value

252− , benchIOSink value "take" $ take value

251+ , benchIOSink value "take" $ take value

253− , benchIOSink value "takeSepBy" $ takeSepBy value

252+ , benchIOSink value "takeSepBy" $ takeSepBy value

254− , benchIOSink

253+ , benchIOSink

255− value

254+ value

256− "and"

255+ "and"

257− (\s -> S.fold FL.and (S.map (<= (value + 1)) s))

256+ (\s -> S.fold FL.and (S.map (<= (value + 1)) s))

258− , benchIOSink

257+ , benchIOSink

259− value

258+ value

260− "or"

259+ "or"

261− (\s -> S.fold FL.or (S.map (> (value + 1)) s))

260+ (\s -> S.fold FL.or (S.map (> (value + 1)) s))

262− ]

263 ]

261 ]

264 ]

262 ]

265

263

266−

267o_1_space_serial_transformation :: Int -> [Benchmark]

264o_1_space_serial_transformation :: Int -> [Benchmark]

268o_1_space_serial_transformation value =

265o_1_space_serial_transformation value =

269− [ bgroup "serially"

270− [ bgroup "transformation"

266+ [ bgroup "transformation"

271− [ benchIOSink value "lmap" (S.fold (FL.lmap (+ 1) FL.drain))

267+ [ benchIOSink value "lmap" (S.fold (FL.lmap (+ 1) FL.drain))

272− , let f x = if even x then Just x else Nothing

268+ , let f x = if even x then Just x else Nothing

273− fld = FL.mapMaybe f FL.drain

269+ fld = FL.mapMaybe f FL.drain

274− in benchIOSink value "mapMaybe" (S.fold fld)

270+ in benchIOSink value "mapMaybe" (S.fold fld)

275− , benchIOSink

271+ , benchIOSink

276− value

272+ value

277− "sequence"

273+ "sequence"

278− (S.fold (FL.sequence (return <$> FL.drain)))

274+ (S.fold (FL.sequence (return <$> FL.drain)))

279− , benchIOSink value "mapM" (S.fold (FL.mapM return FL.drain))

275+ , benchIOSink value "mapM" (S.fold (FL.mapM return FL.drain))

280− , benchIOSink

276+ , benchIOSink

281− value

277+ value

282− "pipe-mapM"

278+ "pipe-mapM"

283− (S.fold

279+ (S.fold

284− (FL.transform

280+ (FL.transform

285− (Pipe.mapM (\x -> return $ x + 1))

281+ (Pipe.mapM (\x -> return $ x + 1))

286− FL.drain))

282+ FL.drain))

287− ]

288 ]

283 ]

289 ]

284 ]

290

285

291o_1_space_serial_composition :: Int -> [Benchmark]

286o_1_space_serial_composition :: Int -> [Benchmark]

292o_1_space_serial_composition value =

287o_1_space_serial_composition value =

293− [ bgroup

288+ [ bgroup

294− "serially"

295− [ bgroup

296− "composition"

289+ "composition"

297− -- Applicative

290+ -- Applicative

298− [ benchIOSink value "tee (all, any)" $ teeAllAny value

291+ [ benchIOSink value "tee (all, any)" $ teeAllAny value

299− , benchIOSink value "tee (sum, length)" $ teeSumLength

292+ , benchIOSink value "tee (sum, length)" $ teeSumLength

300− -- , benchIOSink value "applicative (all, any)"

293+ -- , benchIOSink value "applicative (all, any)"

301− -- $ applicativeAllAny value

294+ -- $ applicativeAllAny value

302− -- , benchIOSink value "applicative (sum, length)"

295+ -- , benchIOSink value "applicative (sum, length)"

303− -- $ applicativeSumLength

296+ -- $ applicativeSumLength

304− , benchIOSink value "distribute_ [sum, length]" $ distribute_

297+ , benchIOSink value "distribute_ [sum, length]" $ distribute_

305− , benchIOSink value "distribute [sum, length]" $ distribute

298+ , benchIOSink value "distribute [sum, length]" $ distribute

306− , benchIOSink value "partition (sum, length)" $ partition

299+ , benchIOSink value "partition (sum, length)" $ partition

307− , benchIOSink value "unzip (sum, length)" $ unzip

300+ , benchIOSink value "unzip (sum, length)" $ unzip

308− , benchIOSink value "demuxWith [sum, length]" $ demuxWith fn mp

301+ , benchIOSink value "demuxWith [sum, length]" $ demuxWith fn mp

309− , benchIOSink value "demuxWith_ [sum, length]"

302+ , benchIOSink value "demuxWith_ [sum, length]"

310− $ demuxWith_ fn mp

303+ $ demuxWith_ fn mp

311− , benchIOSink value "demuxWithDefault_ [sum, length] sum"

304+ , benchIOSink value "demuxWithDefault_ [sum, length] sum"

312− $ demuxWithDefault_ fn mp

305+ $ demuxWithDefault_ fn mp

313− , benchIOSink value "classifyWith sum" $ classifyWith (fst . fn)

306+ , benchIOSink value "classifyWith sum" $ classifyWith (fst . fn)

314− , benchIOSink value "many length sum" many

307+ , benchIOSink value "many length sum" many

315− , benchIOSink value "split (all, any)" $ splitAllAny value

308+ , benchIOSink value "split (all, any)" $ splitAllAny value

316− ]

317− ]

309+ ]

318− ]

310+ ]

319

311

320 where

312 where

321

313

325

317

326o_n_heap_serial :: Int -> [Benchmark]

318o_n_heap_serial :: Int -> [Benchmark]

327o_n_heap_serial value =

319o_n_heap_serial value =

328− [ bgroup "serially"

329− [ bgroup "elimination"

320+ [ bgroup "elimination"

330− -- Left folds for building a structure are inherently non-streaming

321+ -- Left folds for building a structure are inherently non-streaming

331− -- as the structure cannot be lazily consumed until fully built.

322+ -- as the structure cannot be lazily consumed until fully built.

332− [

323+ [

333− benchIOSink value "toList" (S.fold FL.toList)

324+ benchIOSink value "toList" (S.fold FL.toList)

334− , benchIOSink value "toListRevF" (S.fold FL.toListRevF)

325+ , benchIOSink value "toListRevF" (S.fold FL.toListRevF)

335− ]

336− ]

326+ ]

337 ]

327 ]

338

328

339-------------------------------------------------------------------------------

329-------------------------------------------------------------------------------