@@ -173,149 +173,141 @@ moduleName = "Data.Fold"
173173
174174o_1_space_serial_elimination :: Int -> [Benchmark]
175175o_1_space_serial_elimination value =
176− [ bgroup "serially"
177− [ bgroup "elimination"
178− [ benchIOSink value "drain" (S.fold FL.drain)
179− , benchIOSink value "drainBy" (S.fold (FL.drainBy return))
180− , benchIOSink value "drainN" (S.fold (FL.drainN value))
181− , benchIOSink
182− value
183− "drainSepByTrue"
184− (S.fold (FL.drainSepBy $ (<=) (value + 1)))
185− , benchIOSink
186− value
187− "drainSepByFalse"
188− (S.fold (FL.drainSepBy $ (>=) (value + 1)))
189− , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)
190− , benchIOSink value "last" (S.fold FL.last)
191− , benchIOSink value "length" (S.fold FL.length)
192− , benchIOSink value "sum" (S.fold FL.sum)
193− , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))
194− , benchIOSink value "product" (S.fold FL.product)
195− , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))
196− , benchIOSink value "maximum" (S.fold FL.maximum)
197− , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))
198− , benchIOSink value "minimum" (S.fold FL.minimum)
199− , benchIOSink
200− value
201− "mean"
202− (\s ->
203− S.fold
204− FL.mean
205− (S.map (fromIntegral :: Int -> Double) s))
206− , benchIOSink
207− value
208− "variance"
209− (\s ->
210− S.fold
211− FL.variance
212− (S.map (fromIntegral :: Int -> Double) s))
213− , benchIOSink
214− value
215− "stdDev"
216− (\s ->
217− S.fold
218− FL.stdDev
219− (S.map (fromIntegral :: Int -> Double) s))
220− , benchIOSink
221− value
222− "mconcat"
223− (S.fold FL.mconcat . (S.map (Last . Just)))
224− , benchIOSink
225− value
226− "foldMap"
227− (S.fold (FL.foldMap (Last . Just)))
228− , benchIOSink
229− value
230− "foldMapM"
231− (S.fold (FL.foldMapM (return . Last . Just)))
232− , benchIOSink value "index" (S.fold (FL.index (value + 1)))
233− , benchIOSink value "head" (S.fold FL.head)
234− , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))
235− , benchIOSink
236− value
237− "lookup"
238− (S.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))
239− , benchIOSink
240− value
241− "findIndex"
242− (S.fold (FL.findIndex (== (value + 1))))
243− , benchIOSink
244− value
245− "elemIndex"
246− (S.fold (FL.elemIndex (value + 1)))
247− , benchIOSink value "null" (S.fold FL.null)
248− , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))
249− , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))
250− , benchIOSink value "all" $ all value
251− , benchIOSink value "any" $ any value
252− , benchIOSink value "take" $ take value
253− , benchIOSink value "takeSepBy" $ takeSepBy value
254− , benchIOSink
255− value
256− "and"
257− (\s -> S.fold FL.and (S.map (<= (value + 1)) s))
258− , benchIOSink
259− value
260− "or"
261− (\s -> S.fold FL.or (S.map (> (value + 1)) s))
262− ]
176+ [ bgroup "elimination"
177+ [ benchIOSink value "drain" (S.fold FL.drain)
178+ , benchIOSink value "drainBy" (S.fold (FL.drainBy return))
179+ , benchIOSink value "drainN" (S.fold (FL.drainN value))
180+ , benchIOSink
181+ value
182+ "drainSepByTrue"
183+ (S.fold (FL.drainSepBy $ (<=) (value + 1)))
184+ , benchIOSink
185+ value
186+ "drainSepByFalse"
187+ (S.fold (FL.drainSepBy $ (>=) (value + 1)))
188+ , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)
189+ , benchIOSink value "last" (S.fold FL.last)
190+ , benchIOSink value "length" (S.fold FL.length)
191+ , benchIOSink value "sum" (S.fold FL.sum)
192+ , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))
193+ , benchIOSink value "product" (S.fold FL.product)
194+ , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))
195+ , benchIOSink value "maximum" (S.fold FL.maximum)
196+ , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))
197+ , benchIOSink value "minimum" (S.fold FL.minimum)
198+ , benchIOSink
199+ value
200+ "mean"
201+ (\s ->
202+ S.fold
203+ FL.mean
204+ (S.map (fromIntegral :: Int -> Double) s))
205+ , benchIOSink
206+ value
207+ "variance"
208+ (\s ->
209+ S.fold
210+ FL.variance
211+ (S.map (fromIntegral :: Int -> Double) s))
212+ , benchIOSink
213+ value
214+ "stdDev"
215+ (\s ->
216+ S.fold
217+ FL.stdDev
218+ (S.map (fromIntegral :: Int -> Double) s))
219+ , benchIOSink
220+ value
221+ "mconcat"
222+ (S.fold FL.mconcat . (S.map (Last . Just)))
223+ , benchIOSink
224+ value
225+ "foldMap"
226+ (S.fold (FL.foldMap (Last . Just)))
227+ , benchIOSink
228+ value
229+ "foldMapM"
230+ (S.fold (FL.foldMapM (return . Last . Just)))
231+ , benchIOSink value "index" (S.fold (FL.index (value + 1)))
232+ , benchIOSink value "head" (S.fold FL.head)
233+ , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))
234+ , benchIOSink
235+ value
236+ "lookup"
237+ (S.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))
238+ , benchIOSink
239+ value
240+ "findIndex"
241+ (S.fold (FL.findIndex (== (value + 1))))
242+ , benchIOSink
243+ value
244+ "elemIndex"
245+ (S.fold (FL.elemIndex (value + 1)))
246+ , benchIOSink value "null" (S.fold FL.null)
247+ , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))
248+ , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))
249+ , benchIOSink value "all" $ all value
250+ , benchIOSink value "any" $ any value
251+ , benchIOSink value "take" $ take value
252+ , benchIOSink value "takeSepBy" $ takeSepBy value
253+ , benchIOSink
254+ value
255+ "and"
256+ (\s -> S.fold FL.and (S.map (<= (value + 1)) s))
257+ , benchIOSink
258+ value
259+ "or"
260+ (\s -> S.fold FL.or (S.map (> (value + 1)) s))
263261 ]
264262 ]
265263
266−
267264o_1_space_serial_transformation :: Int -> [Benchmark]
268265o_1_space_serial_transformation value =
269− [ bgroup "serially"
270− [ bgroup "transformation"
271− [ benchIOSink value "lmap" (S.fold (FL.lmap (+ 1) FL.drain))
272− , let f x = if even x then Just x else Nothing
273− fld = FL.mapMaybe f FL.drain
274− in benchIOSink value "mapMaybe" (S.fold fld)
275− , benchIOSink
276− value
277− "sequence"
278− (S.fold (FL.sequence (return <$> FL.drain)))
279− , benchIOSink value "mapM" (S.fold (FL.mapM return FL.drain))
280− , benchIOSink
281− value
282− "pipe-mapM"
283− (S.fold
284− (FL.transform
285− (Pipe.mapM (\x -> return $ x + 1))
286− FL.drain))
287− ]
266+ [ bgroup "transformation"
267+ [ benchIOSink value "lmap" (S.fold (FL.lmap (+ 1) FL.drain))
268+ , let f x = if even x then Just x else Nothing
269+ fld = FL.mapMaybe f FL.drain
270+ in benchIOSink value "mapMaybe" (S.fold fld)
271+ , benchIOSink
272+ value
273+ "sequence"
274+ (S.fold (FL.sequence (return <$> FL.drain)))
275+ , benchIOSink value "mapM" (S.fold (FL.mapM return FL.drain))
276+ , benchIOSink
277+ value
278+ "pipe-mapM"
279+ (S.fold
280+ (FL.transform
281+ (Pipe.mapM (\x -> return $ x + 1))
282+ FL.drain))
288283 ]
289284 ]
290285
291286o_1_space_serial_composition :: Int -> [Benchmark]
292287o_1_space_serial_composition value =
293− [ bgroup
294− "serially"
295− [ bgroup
296− "composition"
297− -- Applicative
298− [ benchIOSink value "tee (all, any)" $ teeAllAny value
299− , benchIOSink value "tee (sum, length)" $ teeSumLength
300− -- , benchIOSink value "applicative (all, any)"
301− -- $ applicativeAllAny value
302− -- , benchIOSink value "applicative (sum, length)"
303− -- $ applicativeSumLength
304− , benchIOSink value "distribute_ [sum, length]" $ distribute_
305− , benchIOSink value "distribute [sum, length]" $ distribute
306− , benchIOSink value "partition (sum, length)" $ partition
307− , benchIOSink value "unzip (sum, length)" $ unzip
308− , benchIOSink value "demuxWith [sum, length]" $ demuxWith fn mp
309− , benchIOSink value "demuxWith_ [sum, length]"
310− $ demuxWith_ fn mp
311− , benchIOSink value "demuxWithDefault_ [sum, length] sum"
312− $ demuxWithDefault_ fn mp
313− , benchIOSink value "classifyWith sum" $ classifyWith (fst . fn)
314− , benchIOSink value "many length sum" many
315− , benchIOSink value "split (all, any)" $ splitAllAny value
316− ]
317− ]
318− ]
288+ [ bgroup
289+ "composition"
290+ -- Applicative
291+ [ benchIOSink value "tee (all, any)" $ teeAllAny value
292+ , benchIOSink value "tee (sum, length)" $ teeSumLength
293+ -- , benchIOSink value "applicative (all, any)"
294+ -- $ applicativeAllAny value
295+ -- , benchIOSink value "applicative (sum, length)"
296+ -- $ applicativeSumLength
297+ , benchIOSink value "distribute_ [sum, length]" $ distribute_
298+ , benchIOSink value "distribute [sum, length]" $ distribute
299+ , benchIOSink value "partition (sum, length)" $ partition
300+ , benchIOSink value "unzip (sum, length)" $ unzip
301+ , benchIOSink value "demuxWith [sum, length]" $ demuxWith fn mp
302+ , benchIOSink value "demuxWith_ [sum, length]"
303+ $ demuxWith_ fn mp
304+ , benchIOSink value "demuxWithDefault_ [sum, length] sum"
305+ $ demuxWithDefault_ fn mp
306+ , benchIOSink value "classifyWith sum" $ classifyWith (fst . fn)
307+ , benchIOSink value "many length sum" many
308+ , benchIOSink value "split (all, any)" $ splitAllAny value
309+ ]
310+ ]
319311
320312 where
321313
@@ -325,15 +317,13 @@ o_1_space_serial_composition value =
325317
326318o_n_heap_serial :: Int -> [Benchmark]
327319o_n_heap_serial value =
328− [ bgroup "serially"
329− [ bgroup "elimination"
330− -- Left folds for building a structure are inherently non-streaming
331− -- as the structure cannot be lazily consumed until fully built.
332− [
333− benchIOSink value "toList" (S.fold FL.toList)
334− , benchIOSink value "toListRevF" (S.fold FL.toListRevF)
335− ]
336− ]
320+ [ bgroup "elimination"
321+ -- Left folds for building a structure are inherently non-streaming
322+ -- as the structure cannot be lazily consumed until fully built.
323+ [
324+ benchIOSink value "toList" (S.fold FL.toList)
325+ , benchIOSink value "toListRevF" (S.fold FL.toListRevF)
326+ ]
337327 ]
338328
339329-------------------------------------------------------------------------------