@@ -31,26 +31,27 @@ benchIO name f = bench name $ nfIO $ randomRIO (1,1) >>= f
3131
3232{-# INLINE fromListM #-}
3333fromListM :: Monad m => Int -> Int -> m ()
34−fromListM value n =
35− S.drain $ S.unfold UF.fromListM (Prelude.map return [n .. n + value])
34+fromListM size start =
35+ S.drain
36+ $ S.unfold UF.fromListM (Prelude.map return [start .. start + size])
3637
3738{-# INLINE replicateM #-}
3839replicateM :: Monad m => Int -> Int -> m ()
39−replicateM value n = S.drain $ S.unfold (UF.replicateM value) (return n)
40+replicateM size start = S.drain $ S.unfold (UF.replicateM size) (return start)
4041
4142{-# INLINE repeatM #-}
4243repeatM :: Monad m => Int -> Int -> m ()
43−repeatM value n = S.drain $ S.take value $ S.unfold UF.repeatM (return n)
44+repeatM size start = S.drain $ S.take size $ S.unfold UF.repeatM (return start)
4445
4546{-# INLINE enumerateFromStepIntegral #-}
4647enumerateFromStepIntegral :: Monad m => Int -> Int -> m ()
47−enumerateFromStepIntegral value n = S.drain $
48− S.take value $ S.unfold UF.enumerateFromStepIntegral (n, 1)
48+enumerateFromStepIntegral size start = S.drain $
49+ S.take size $ S.unfold UF.enumerateFromStepIntegral (start, 1)
4950
5051{-# INLINE enumerateFromToIntegral #-}
5152enumerateFromToIntegral :: Monad m => Int -> Int -> m ()
52−enumerateFromToIntegral value n =
53− S.drain $ S.unfold (UF.enumerateFromToIntegral (value + n)) n
53+enumerateFromToIntegral size start =
54+ S.drain $ S.unfold (UF.enumerateFromToIntegral (size + start)) start
5455
5556-------------------------------------------------------------------------------
5657-- Stream transformation
@@ -58,52 +59,55 @@ enumerateFromToIntegral value n =
5859
5960{-# INLINE take #-}
6061take :: Monad m => Int -> Int -> m ()
61−take value n =
62+take size start =
6263 S.drain
63− $ S.unfold (UF.take value (UF.enumerateFromToIntegral (value + n))) n
64+ $ S.unfold
65+ (UF.take size (UF.enumerateFromToIntegral (size + start)))
66+ start
6467
6568{-# INLINE takeWhileM #-}
6669takeWhileM :: Monad m => Int -> Int -> m ()
67−takeWhileM value n =
70+takeWhileM size start =
6871 S.drain
6972 $ S.unfold
7073 (UF.takeWhileM
71− (\b -> return (b <= value + n))
72− (UF.enumerateFromToIntegral (value + n)))
73− n
74+ (\b -> return (b <= size + start))
75+ (UF.enumerateFromToIntegral (size + start)))
76+ start
7477
7578{-# INLINE _dropOne #-}
7679_dropOne :: Monad m => Int -> Int -> m ()
77−_dropOne value n =
78− S.drain $ S.unfold (UF.drop 1 (UF.enumerateFromToIntegral (value + n))) n
80+_dropOne size start =
81+ S.drain
82+ $ S.unfold (UF.drop 1 (UF.enumerateFromToIntegral (size + start))) start
7983
8084{-# INLINE dropAll #-}
8185dropAll :: Monad m => Int -> Int -> m ()
82−dropAll value n =
86+dropAll size start =
8387 S.drain
8488 $ S.unfold
85− (UF.drop (value + 1) (UF.enumerateFromToIntegral (value + n)))
86− n
89+ (UF.drop (size + 1) (UF.enumerateFromToIntegral (size + start)))
90+ start
8791
8892{-# INLINE dropWhileMTrue #-}
8993dropWhileMTrue :: Monad m => Int -> Int -> m ()
90−dropWhileMTrue value n =
94+dropWhileMTrue size start =
9195 S.drain
9296 $ S.unfold
9397 (UF.dropWhileM
9498 (\_ -> return True)
95− (UF.enumerateFromToIntegral (value + n)))
96− n
99+ (UF.enumerateFromToIntegral (size + start)))
100+ start
97101
98102{-# INLINE dropWhileMFalse #-}
99103dropWhileMFalse :: Monad m => Int -> Int -> m ()
100−dropWhileMFalse value n =
104+dropWhileMFalse size start =
101105 S.drain
102106 $ S.unfold
103107 (UF.dropWhileM
104108 (\_ -> return False)
105− (UF.enumerateFromToIntegral (value + n)))
106− n
109+ (UF.enumerateFromToIntegral (size + start)))
110+ start
107111
108112-------------------------------------------------------------------------------
109113-- Stream combination
@@ -111,14 +115,14 @@ dropWhileMFalse value n =
111115
112116{-# INLINE zipWithM #-}
113117zipWithM :: Monad m => Int -> Int -> m ()
114−zipWithM value n =
118+zipWithM size start =
115119 S.drain
116120 $ S.unfold
117121 (UF.zipWithM
118122 (\a b -> return $ a + b)
119− (UF.enumerateFromToIntegral (value + n))
120− (UF.enumerateFromToIntegral (value + n + 1)))
121− (n, n + 1)
123+ (UF.enumerateFromToIntegral (size + start))
124+ (UF.enumerateFromToIntegral (size + start + 1)))
125+ (start, start + 1)
122126
123127-------------------------------------------------------------------------------
124128-- Benchmarks
@@ -128,55 +132,55 @@ moduleName :: String
128132moduleName = "Data.Unfold"
129133
130134o_1_space_serial_generation :: Int -> [Benchmark]
131−o_1_space_serial_generation value =
135+o_1_space_serial_generation size =
132136 [ bgroup "generation"
133− [ benchIO "fromListM" $ fromListM value
134− , benchIO "replicateM" $ replicateM value
135− , benchIO "repeatM" $ repeatM value
136− , benchIO "enumerateFromStepIntegral" $ enumerateFromStepIntegral value
137− , benchIO "enumerateFromToIntegral" $ enumerateFromToIntegral value
137+ [ benchIO "fromListM" $ fromListM size
138+ , benchIO "replicateM" $ replicateM size
139+ , benchIO "repeatM" $ repeatM size
140+ , benchIO "enumerateFromStepIntegral" $ enumerateFromStepIntegral size
141+ , benchIO "enumerateFromToIntegral" $ enumerateFromToIntegral size
138142 ]
139143 ]
140144
141145o_1_space_serial_transformation :: Int -> [Benchmark]
142−o_1_space_serial_transformation value =
146+o_1_space_serial_transformation size =
143147 [ bgroup "transformation"
144− [ benchIO "take" $ take value
145− , benchIO "takeWhileM" $ takeWhileM value
146− , benchIO "filterAllOut" $ filterAllOut value
147− , benchIO "filterAllIn" $ filterAllIn value
148− , benchIO "filterSome" $ filterSome value
148+ [ benchIO "take" $ take size
149+ , benchIO "takeWhileM" $ takeWhileM size
150+ , benchIO "filterAllOut" $ filterAllOut size
151+ , benchIO "filterAllIn" $ filterAllIn size
152+ , benchIO "filterSome" $ filterSome size
149153 -- This will take nanoseconds, We need to fix the benchmark reporting to
150154 -- have microseconds as the minimum unit before uncommenting this.
151− -- , benchIO "dropOne" $ dropOne value
152− , benchIO "dropAll" $ dropAll value
153− , benchIO "dropWhileMTrue" $ dropWhileMTrue value
154− , benchIO "dropWhileMFalse" $ dropWhileMFalse value
155+ -- , benchIO "dropOne" $ dropOne size
156+ , benchIO "dropAll" $ dropAll size
157+ , benchIO "dropWhileMTrue" $ dropWhileMTrue size
158+ , benchIO "dropWhileMFalse" $ dropWhileMFalse size
155159 ]
156160 ]
157161
158162o_1_space_serial_combination :: Int -> [Benchmark]
159−o_1_space_serial_combination value =
163+o_1_space_serial_combination size =
160164 [ bgroup "combination"
161− [ benchIO "zipWithM" $ zipWithM value
165+ [ benchIO "zipWithM" $ zipWithM size
162166 ]
163167 ]
164168
165169o_1_space_serial_outerProduct :: Int -> [Benchmark]
166−o_1_space_serial_outerProduct value =
170+o_1_space_serial_outerProduct size =
167171 [ bgroup "outer-product"
168− [ benchIO "toNull" $ toNull value
169− , benchIO "toNull3" $ toNull3 value
170− , benchIO "concat" $ concat value
171− , benchIO "breakAfterSome" $ breakAfterSome value
172+ [ benchIO "toNull" $ toNull size
173+ , benchIO "toNull3" $ toNull3 size
174+ , benchIO "concat" $ concat size
175+ , benchIO "breakAfterSome" $ breakAfterSome size
172176 ]
173177 ]
174178
175179o_n_space_serial :: Int -> [Benchmark]
176−o_n_space_serial value =
180+o_n_space_serial size =
177181 [ bgroup "outer-product"
178− [ benchIO "toList" $ toList value
179− , benchIO "toListSome" $ toListSome value
182+ [ benchIO "toList" $ toList size
183+ , benchIO "toListSome" $ toListSome size
180184 ]
181185 ]
182186
@@ -186,19 +190,19 @@ o_n_space_serial value =
186190
187191main :: IO ()
188192main = do
189− (value, cfg, benches) <- parseCLIOpts defaultStreamSize
190− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)
193+ (size, cfg, benches) <- parseCLIOpts defaultStreamSize
194+ size `seq` runMode (mode cfg) cfg benches (allBenchmarks size)
191195
192196 where
193197
194− allBenchmarks value =
198+ allBenchmarks size =
195199 [ bgroup (o_1_space_prefix moduleName)
196200 $ Prelude.concat
197− [ o_1_space_serial_generation value
198− , o_1_space_serial_transformation value
199− , o_1_space_serial_combination value
200− , o_1_space_serial_outerProduct value
201+ [ o_1_space_serial_generation size
202+ , o_1_space_serial_transformation size
203+ , o_1_space_serial_combination size
204+ , o_1_space_serial_outerProduct size
201205 ]
202206 , bgroup (o_n_space_prefix moduleName)
203− $ Prelude.concat [o_n_space_serial value]
207+ $ Prelude.concat [o_n_space_serial size]
204208 ]