git.iko.soy/streamly
on master help sign in
Use from-to style instead of take-from in many unfold benchmarks
b1a9af0adithyaov
benchmark/Streamly/Benchmark/Data/Unfold.hs+33−23
compare with master
unifiedsplit
@@ -45,8 +45,8 @@ drainTransformation unf f seed = drainGeneration (f unf) seed
45{-# INLINE drainTransformationDefault #-}
45{-# INLINE drainTransformationDefault #-}
46drainTransformationDefault ::
46drainTransformationDefault ::
47 Monad m => Int -> (Unfold m Int Int -> Unfold m c d) -> c -> m ()
47 Monad m => Int -> (Unfold m Int Int -> Unfold m c d) -> c -> m ()
48−drainTransformationDefault size =
48+drainTransformationDefault to =
49− drainTransformation (UF.take size UF.enumerateFromIntegral)
49+ drainTransformation (UF.enumerateFromToIntegral to)
50
50
51{-# INLINE drainProduct #-}
51{-# INLINE drainProduct #-}
52drainProduct ::
52drainProduct ::
@@ -65,12 +65,11 @@ drainProductDefault ::
65 -> (Unfold m Int Int -> Unfold m Int Int -> Unfold m e f)
65 -> (Unfold m Int Int -> Unfold m Int Int -> Unfold m e f)
66 -> e
66 -> e
67 -> m ()
67 -> m ()
68−drainProductDefault size = drainProduct src1 src2
68+drainProductDefault to = drainProduct src src
69
69
70 where
70 where
71
71
72− src1 = UF.take size UF.enumerateFromIntegral
72+ src = UF.enumerateFromToIntegral to
73− src2 = UF.take size (UF.supplySecond UF.enumerateFromStepIntegral 2)
74
73
75-------------------------------------------------------------------------------
74-------------------------------------------------------------------------------
76-- Operations on input
75-- Operations on input
@@ -78,17 +77,18 @@ drainProductDefault size = drainProduct src1 src2
78
77
79{-# INLINE lmap #-}
78{-# INLINE lmap #-}
80lmap :: Monad m => Int -> Int -> m ()
79lmap :: Monad m => Int -> Int -> m ()
80+lmap size start =
81−lmap size start = drainTransformationDefault size (UF.lmap (+ 1)) start
81+ drainTransformationDefault (size + start) (UF.lmap (+ 1)) start
82
82
83{-# INLINE lmapM #-}
83{-# INLINE lmapM #-}
84lmapM :: Monad m => Int -> Int -> m ()
84lmapM :: Monad m => Int -> Int -> m ()
85lmapM size start =
85lmapM size start =
86− drainTransformationDefault size (UF.lmapM (return . (+) 1)) start
86+ drainTransformationDefault (size + start) (UF.lmapM (return . (+) 1)) start
87
87
88{-# INLINE supply #-}
88{-# INLINE supply #-}
89supply :: Monad m => Int -> Int -> m ()
89supply :: Monad m => Int -> Int -> m ()
90supply size start =
90supply size start =
91− drainTransformationDefault size (flip UF.supply start) undefined
91+ drainTransformationDefault (size + start) (flip UF.supply start) undefined
92
92
93
93
94{-# INLINE supplyFirst #-}
94{-# INLINE supplyFirst #-}
@@ -110,12 +110,12 @@ supplySecond size start =
110{-# INLINE discardFirst #-}
110{-# INLINE discardFirst #-}
111discardFirst :: Monad m => Int -> Int -> m ()
111discardFirst :: Monad m => Int -> Int -> m ()
112discardFirst size start =
112discardFirst size start =
113− drainTransformationDefault size UF.discardFirst (start, start)
113+ drainTransformationDefault (size + start) UF.discardFirst (start, start)
114
114
115{-# INLINE discardSecond #-}
115{-# INLINE discardSecond #-}
116discardSecond :: Monad m => Int -> Int -> m ()
116discardSecond :: Monad m => Int -> Int -> m ()
117discardSecond size start =
117discardSecond size start =
118− drainTransformationDefault size UF.discardSecond (start, start)
118+ drainTransformationDefault (size + start) UF.discardSecond (start, start)
119
119
120{-# INLINE swap #-}
120{-# INLINE swap #-}
121swap :: Monad m => Int -> Int -> m ()
121swap :: Monad m => Int -> Int -> m ()
@@ -151,7 +151,8 @@ _nilM _ start = drainGeneration (UF.nilM return) start
151
151
152{-# INLINE consM #-}
152{-# INLINE consM #-}
153consM :: Monad m => Int -> Int -> m ()
153consM :: Monad m => Int -> Int -> m ()
154+consM size start =
154−consM size start = drainTransformationDefault size (UF.consM return) start
155+ drainTransformationDefault (size + start) (UF.consM return) start
155
156
156{-# INLINE _effect #-}
157{-# INLINE _effect #-}
157_effect :: Monad m => Int -> Int -> m ()
158_effect :: Monad m => Int -> Int -> m ()
@@ -260,12 +261,12 @@ enumerateFromToFractional size start =
260
261
261{-# INLINE map #-}
262{-# INLINE map #-}
262map :: Monad m => Int -> Int -> m ()
263map :: Monad m => Int -> Int -> m ()
263−map size start = drainTransformationDefault size (UF.map (+1)) start
264+map size start = drainTransformationDefault (size + start) (UF.map (+1)) start
264
265
265{-# INLINE mapM #-}
266{-# INLINE mapM #-}
266mapM :: Monad m => Int -> Int -> m ()
267mapM :: Monad m => Int -> Int -> m ()
267mapM size start =
268mapM size start =
268− drainTransformationDefault size (UF.mapM (return . (+) 1)) start
269+ drainTransformationDefault (size + start) (UF.mapM (return . (+) 1)) start
269
270
270{-# INLINE mapMWithInput #-}
271{-# INLINE mapMWithInput #-}
271mapMWithInput :: Monad m => Int -> Int -> m ()
272mapMWithInput :: Monad m => Int -> Int -> m ()
@@ -297,37 +298,46 @@ takeWhile size start =
297
298
298{-# INLINE take #-}
299{-# INLINE take #-}
299take :: Monad m => Int -> Int -> m ()
300take :: Monad m => Int -> Int -> m ()
300−take size start = drainTransformationDefault size (UF.take size) start
301+take size start = drainTransformationDefault (size + start) (UF.take size) start
301
302
302{-# INLINE filter #-}
303{-# INLINE filter #-}
303filter :: Monad m => Int -> Int -> m ()
304filter :: Monad m => Int -> Int -> m ()
304filter size start =
305filter size start =
305− drainTransformationDefault size (UF.filter (\_ -> True)) start
306+ drainTransformationDefault (size + start) (UF.filter (\_ -> True)) start
306
307
307{-# INLINE filterM #-}
308{-# INLINE filterM #-}
308filterM :: Monad m => Int -> Int -> m ()
309filterM :: Monad m => Int -> Int -> m ()
309filterM size start =
310filterM size start =
310− drainTransformationDefault size (UF.filterM (\_ -> (return True))) start
311+ drainTransformationDefault
312+ (size + start)
313+ (UF.filterM (\_ -> (return True)))
314+ start
311
315
312{-# INLINE _dropOne #-}
316{-# INLINE _dropOne #-}
313_dropOne :: Monad m => Int -> Int -> m ()
317_dropOne :: Monad m => Int -> Int -> m ()
314_dropOne size start =
318_dropOne size start =
315− drainTransformationDefault size (UF.drop 1) start
319+ drainTransformationDefault (size + start) (UF.drop 1) start
316
320
317{-# INLINE dropAll #-}
321{-# INLINE dropAll #-}
318dropAll :: Monad m => Int -> Int -> m ()
322dropAll :: Monad m => Int -> Int -> m ()
319dropAll size start =
323dropAll size start =
320− drainTransformationDefault size (UF.drop (size + 1)) start
324+ drainTransformationDefault (size + start) (UF.drop (size + 1)) start
321
325
322{-# INLINE dropWhileTrue #-}
326{-# INLINE dropWhileTrue #-}
323dropWhileTrue :: Monad m => Int -> Int -> m ()
327dropWhileTrue :: Monad m => Int -> Int -> m ()
324dropWhileTrue size start =
328dropWhileTrue size start =
325− drainTransformationDefault size (UF.dropWhileM (\_ -> return True)) start
329+ drainTransformationDefault
330+ (size + start)
331+ (UF.dropWhileM (\_ -> return True))
332+ start
326
333
327{-# INLINE dropWhileFalse #-}
334{-# INLINE dropWhileFalse #-}
328dropWhileFalse :: Monad m => Int -> Int -> m ()
335dropWhileFalse :: Monad m => Int -> Int -> m ()
329dropWhileFalse size start =
336dropWhileFalse size start =
330− drainTransformationDefault size (UF.dropWhileM (\_ -> return False)) start
337+ drainTransformationDefault
338+ (size + start)
339+ (UF.dropWhileM (\_ -> return False))
340+ start
331
341
332{-# INLINE dropWhileMTrue #-}
342{-# INLINE dropWhileMTrue #-}
333dropWhileMTrue :: Monad m => Int -> Int -> m ()
343dropWhileMTrue :: Monad m => Int -> Int -> m ()
@@ -352,20 +362,20 @@ dropWhileMFalse size start =
352{-# INLINE zipWith #-}
362{-# INLINE zipWith #-}
353zipWith :: Monad m => Int -> Int -> m ()
363zipWith :: Monad m => Int -> Int -> m ()
354zipWith size start =
364zipWith size start =
355− drainProductDefault size (UF.zipWith (+)) (start, start + 1)
365+ drainProductDefault (size + start) (UF.zipWith (+)) (start, start + 1)
356
366
357{-# INLINE zipWithM #-}
367{-# INLINE zipWithM #-}
358zipWithM :: Monad m => Int -> Int -> m ()
368zipWithM :: Monad m => Int -> Int -> m ()
359zipWithM size start =
369zipWithM size start =
360 drainProductDefault
370 drainProductDefault
361− size
371+ (size + start)
362 (UF.zipWithM (\a b -> return $ a + b))
372 (UF.zipWithM (\a b -> return $ a + b))
363 (start, start + 1)
373 (start, start + 1)
364
374
365{-# INLINE teeZipWith #-}
375{-# INLINE teeZipWith #-}
366teeZipWith :: Monad m => Int -> Int -> m ()
376teeZipWith :: Monad m => Int -> Int -> m ()
367teeZipWith size start =
377teeZipWith size start =
368− drainProductDefault size (UF.teeZipWith (+)) start
378+ drainProductDefault (size + start) (UF.teeZipWith (+)) start
369
379
370-------------------------------------------------------------------------------
380-------------------------------------------------------------------------------
371-- Nested
381-- Nested