65ed762 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Remove cpp-options that control length in linear*

65ed762adithyaov7 years ago

benchmark/Linear.hs+279−266

compare with master

unifiedsplit

@@ -14,6 +14,8 @@ import Control.DeepSeq (NFData(..), deepseq)

14import Data.Functor.Identity (Identity, runIdentity)

15import System.Random (randomRIO)

16import Data.Monoid (Last(..))

17+import System.Environment (getArgs)

18+import Text.Read (readMaybe)

18import qualified GHC.Exts as GHC

20import qualified GHC.Exts as GHC

19import qualified Streamly.Benchmark.Prelude as Ops

21import qualified Streamly.Benchmark.Prelude as Ops

@@ -46,15 +48,15 @@ instance NFData Ordering where rnf = (`seq` ())

46{-# INLINE benchIOSink #-}

48{-# INLINE benchIOSink #-}

47benchIOSink

49benchIOSink

48 :: (IsStream t, NFData b)

50 :: (IsStream t, NFData b)

49− => String -> (t IO Int -> IO b) -> Benchmark

51+ => Int -> String -> (t IO Int -> IO b) -> Benchmark

50−benchIOSink name f = bench name $ nfIO $ randomRIO (1,1) >>= f . Ops.source

52+benchIOSink value name f = bench name $ nfIO $ randomRIO (1,1) >>= f . Ops.source value

52{-# INLINE benchHoistSink #-}

54{-# INLINE benchHoistSink #-}

53benchHoistSink

55benchHoistSink

54 :: (IsStream t, NFData b)

56 :: (IsStream t, NFData b)

55− => String -> (t Identity Int -> IO b) -> Benchmark

57+ => Int -> String -> (t Identity Int -> IO b) -> Benchmark

56−benchHoistSink name f =

58+benchHoistSink value name f =

57− bench name $ nfIO $ randomRIO (1,1) >>= f . Ops.sourceUnfoldr

59+ bench name $ nfIO $ randomRIO (1,1) >>= f . Ops.sourceUnfoldr value

59-- XXX once we convert all the functions to use this we can rename this to

61-- XXX once we convert all the functions to use this we can rename this to

60-- benchIOSink

62-- benchIOSink

@@ -67,8 +69,8 @@ benchIOSink1 name f = bench name $ nfIO $ randomRIO (1,1) >>= f

67{-# INLINE benchIdentitySink #-}

69{-# INLINE benchIdentitySink #-}

68benchIdentitySink

70benchIdentitySink

69 :: (IsStream t, NFData b)

71 :: (IsStream t, NFData b)

70− => String -> (t Identity Int -> Identity b) -> Benchmark

72+ => Int -> String -> (t Identity Int -> Identity b) -> Benchmark

71−benchIdentitySink name f = bench name $ nf (f . Ops.sourceUnfoldr) 1

73+benchIdentitySink value name f = bench name $ nf (f . Ops.sourceUnfoldr value) 1

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

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

74{-# INLINE benchIOSrc #-}

76{-# INLINE benchIOSrc #-}

@@ -89,8 +91,8 @@ benchPure :: NFData b => String -> (Int -> a) -> (a -> b) -> Benchmark

89benchPure name src f = bench name $ nfIO $ randomRIO (1,1) >>= return . f . src

91benchPure name src f = bench name $ nfIO $ randomRIO (1,1) >>= return . f . src

91{-# INLINE benchPureSink #-}

93{-# INLINE benchPureSink #-}

92−benchPureSink :: NFData b => String -> (SerialT Identity Int -> b) -> Benchmark

94+benchPureSink :: NFData b => Int -> String -> (SerialT Identity Int -> b) -> Benchmark

93−benchPureSink name f = benchPure name Ops.sourceUnfoldr f

95+benchPureSink value name f = benchPure name (Ops.sourceUnfoldr value) f

95-- XXX once we convert all the functions to use this we can rename this to

97-- XXX once we convert all the functions to use this we can rename this to

96-- benchPureSink

98-- benchPureSink

@@ -102,369 +104,380 @@ benchPureSink1 name f =

102{-# INLINE benchPureSinkIO #-}

104{-# INLINE benchPureSinkIO #-}

103benchPureSinkIO

105benchPureSinkIO

104 :: NFData b

106 :: NFData b

105− => String -> (SerialT Identity Int -> IO b) -> Benchmark

107+ => Int -> String -> (SerialT Identity Int -> IO b) -> Benchmark

106−benchPureSinkIO name f =

108+benchPureSinkIO value name f =

107− bench name $ nfIO $ randomRIO (1, 1) >>= f . Ops.sourceUnfoldr

109+ bench name $ nfIO $ randomRIO (1, 1) >>= f . Ops.sourceUnfoldr value

108

110

109{-# INLINE benchPureSrc #-}

111{-# INLINE benchPureSrc #-}

110benchPureSrc :: String -> (Int -> SerialT Identity a) -> Benchmark

112benchPureSrc :: String -> (Int -> SerialT Identity a) -> Benchmark

111benchPureSrc name src = benchPure name src (runIdentity . S.drain)

113benchPureSrc name src = benchPure name src (runIdentity . S.drain)

112

114

113−mkString :: String

115+mkString :: Int -> String

114−mkString = "fromList [1" ++ concat (replicate Ops.value ",1") ++ "]"

116+mkString value = "fromList [1" ++ concat (replicate value ",1") ++ "]"

115

117

116−mkListString :: String

118+mkListString :: Int -> String

117−mkListString = "[1" ++ concat (replicate Ops.value ",1") ++ "]"

119+mkListString value = "[1" ++ concat (replicate value ",1") ++ "]"

118

120

119−mkList :: [Int]

121+mkList :: Int -> [Int]

120−mkList = [1..Ops.value]

122+mkList value = [1..value]

121

123

122main :: IO ()

124main :: IO ()

123−main =

125+main = do

124− defaultMain

126+ -- Basement.Terminal.initialize required?

127+ args <- getArgs

128+ let (value, args') = parseValue args

129+ (cfg, extra) = parseWith defaultConfig args'

130+ runMode (mode cfg) cfg extra

125 [ bgroup "serially"

131 [ bgroup "serially"

126 [ bgroup "pure"

132 [ bgroup "pure"

127− [ benchPureSink "id" id

133+ [ benchPureSink value "id" id

128− , benchPureSink1 "eqBy" Ops.eqByPure

134+ , benchPureSink1 "eqBy" (Ops.eqByPure value)

129− , benchPureSink "==" Ops.eqInstance

135+ , benchPureSink value "==" Ops.eqInstance

130− , benchPureSink "/=" Ops.eqInstanceNotEq

136+ , benchPureSink value "/=" Ops.eqInstanceNotEq

131− , benchPureSink1 "cmpBy" Ops.cmpByPure

137+ , benchPureSink1 "cmpBy" (Ops.cmpByPure value)

132− , benchPureSink "<" Ops.ordInstance

138+ , benchPureSink value "<" Ops.ordInstance

133− , benchPureSink "min" Ops.ordInstanceMin

139+ , benchPureSink value "min" Ops.ordInstanceMin

134− , benchPureSrc "IsList.fromList" Ops.sourceIsList

140+ , benchPureSrc "IsList.fromList" (Ops.sourceIsList value)

135 -- length is used to check for foldr/build fusion

141 -- length is used to check for foldr/build fusion

136− , benchPureSink "length . IsList.toList" (length . GHC.toList)

142+ , benchPureSink value "length . IsList.toList" (length . GHC.toList)

137− , benchPureSrc "IsString.fromString" Ops.sourceIsString

143+ , benchPureSrc "IsString.fromString" (Ops.sourceIsString value)

138− , mkString `deepseq` (bench "readsPrec pure streams" $

144+ , mkString value `deepseq` (bench "readsPrec pure streams" $

139− nf Ops.readInstance mkString)

145+ nf Ops.readInstance (mkString value))

140− , mkString `deepseq` (bench "readsPrec Haskell lists" $

146+ , mkString value `deepseq` (bench "readsPrec Haskell lists" $

141− nf Ops.readInstanceList mkListString)

147+ nf Ops.readInstanceList (mkListString value))

142− , benchPureSink "showsPrec pure streams" Ops.showInstance

148+ , benchPureSink value "showsPrec pure streams" Ops.showInstance

143− , mkList `deepseq` (bench "showPrec Haskell lists" $

149+ , mkList value `deepseq` (bench "showPrec Haskell lists" $

144− nf Ops.showInstanceList mkList)

150+ nf Ops.showInstanceList (mkList value))

145− , benchPureSink "foldl'" Ops.pureFoldl'

151+ , benchPureSink value "foldl'" Ops.pureFoldl'

146− , benchPureSink "foldable/foldl'" Ops.foldableFoldl'

152+ , benchPureSink value "foldable/foldl'" Ops.foldableFoldl'

147− , benchPureSink "foldable/sum" Ops.foldableSum

153+ , benchPureSink value "foldable/sum" Ops.foldableSum

148− , benchPureSinkIO "traversable/mapM" Ops.traversableMapM

154+ , benchPureSinkIO value "traversable/mapM" Ops.traversableMapM

149 ]

155 ]

150 , bgroup "generation"

156 , bgroup "generation"

151 [ -- Most basic, barely stream continuations running

157 [ -- Most basic, barely stream continuations running

152− benchIOSrc serially "unfoldr" Ops.sourceUnfoldr

158+ benchIOSrc serially "unfoldr" (Ops.sourceUnfoldr value)

153− , benchIOSrc serially "unfoldrM" Ops.sourceUnfoldrM

159+ , benchIOSrc serially "unfoldrM" (Ops.sourceUnfoldrM value)

154− , benchIOSrc serially "intFromTo" Ops.sourceIntFromTo

160+ , benchIOSrc serially "intFromTo" (Ops.sourceIntFromTo value)

155− , benchIOSrc serially "intFromThenTo" Ops.sourceIntFromThenTo

161+ , benchIOSrc serially "intFromThenTo" (Ops.sourceIntFromThenTo value)

156− , benchIOSrc serially "integerFromStep" Ops.sourceIntegerFromStep

162+ , benchIOSrc serially "integerFromStep" (Ops.sourceIntegerFromStep value)

157− , benchIOSrc serially "fracFromThenTo" Ops.sourceFracFromThenTo

163+ , benchIOSrc serially "fracFromThenTo" (Ops.sourceFracFromThenTo value)

158− , benchIOSrc serially "fracFromTo" Ops.sourceFracFromTo

164+ , benchIOSrc serially "fracFromTo" (Ops.sourceFracFromTo value)

159− , benchIOSrc serially "fromList" Ops.sourceFromList

165+ , benchIOSrc serially "fromList" (Ops.sourceFromList value)

160− , benchIOSrc serially "fromListM" Ops.sourceFromListM

166+ , benchIOSrc serially "fromListM" (Ops.sourceFromListM value)

161 -- These are essentially cons and consM

167 -- These are essentially cons and consM

162− , benchIOSrc serially "fromFoldable" Ops.sourceFromFoldable

168+ , benchIOSrc serially "fromFoldable" (Ops.sourceFromFoldable value)

163− , benchIOSrc serially "fromFoldableM" Ops.sourceFromFoldableM

169+ , benchIOSrc serially "fromFoldableM" (Ops.sourceFromFoldableM value)

164 ]

170 ]

165 , bgroup "elimination"

171 , bgroup "elimination"

166 [ bgroup "reduce"

172 [ bgroup "reduce"

167 [ bgroup "IO"

173 [ bgroup "IO"

168− [ benchIOSink "foldrM" Ops.foldrMReduce

174+ [ benchIOSink value "foldrM" Ops.foldrMReduce

169− , benchIOSink "foldl'" Ops.foldl'Reduce

175+ , benchIOSink value "foldl'" Ops.foldl'Reduce

170− , benchIOSink "foldl1'" Ops.foldl1'Reduce

176+ , benchIOSink value "foldl1'" Ops.foldl1'Reduce

171− , benchIOSink "foldlM'" Ops.foldlM'Reduce

177+ , benchIOSink value "foldlM'" Ops.foldlM'Reduce

172 ]

178 ]

173 , bgroup "Identity"

179 , bgroup "Identity"

174− [ benchIdentitySink "foldrM" Ops.foldrMReduce

180+ [ benchIdentitySink value "foldrM" Ops.foldrMReduce

175− , benchIdentitySink "foldl'" Ops.foldl'Reduce

181+ , benchIdentitySink value "foldl'" Ops.foldl'Reduce

176− , benchIdentitySink "foldl1'" Ops.foldl1'Reduce

182+ , benchIdentitySink value "foldl1'" Ops.foldl1'Reduce

177− , benchIdentitySink "foldlM'" Ops.foldlM'Reduce

183+ , benchIdentitySink value "foldlM'" Ops.foldlM'Reduce

178 ]

184 ]

179 ]

185 ]

180

186

181 , bgroup "build"

187 , bgroup "build"

182 [ bgroup "IO"

188 [ bgroup "IO"

183− [ benchIOSink "foldrM" Ops.foldrMBuild

189+ [ benchIOSink value "foldrM" Ops.foldrMBuild

184− , benchIOSink "foldl'" Ops.foldl'Build

190+ , benchIOSink value "foldl'" Ops.foldl'Build

185− , benchIOSink "foldlM'" Ops.foldlM'Build

191+ , benchIOSink value "foldlM'" Ops.foldlM'Build

186 ]

192 ]

187 , bgroup "Identity"

193 , bgroup "Identity"

188− [ benchIdentitySink "foldrM" Ops.foldrMBuild

194+ [ benchIdentitySink value "foldrM" Ops.foldrMBuild

189− , benchIdentitySink "foldl'" Ops.foldl'Build

195+ , benchIdentitySink value "foldl'" Ops.foldl'Build

190− , benchIdentitySink "foldlM'" Ops.foldlM'Build

196+ , benchIdentitySink value "foldlM'" Ops.foldlM'Build

191 ]

197 ]

192 ]

198 ]

193− , benchIOSink "uncons" Ops.uncons

199+ , benchIOSink value "uncons" Ops.uncons

194− , benchIOSink "toNull" $ Ops.toNull serially

200+ , benchIOSink value "toNull" $ Ops.toNull serially

195− , benchIOSink "mapM_" Ops.mapM_

201+ , benchIOSink value "mapM_" Ops.mapM_

196

202

197− , benchIOSink "init" Ops.init

203+ , benchIOSink value "init" Ops.init

198− , benchIOSink "tail" Ops.tail

204+ , benchIOSink value "tail" Ops.tail

199− , benchIOSink "nullHeadTail" Ops.nullHeadTail

205+ , benchIOSink value "nullHeadTail" Ops.nullHeadTail

200

206

201 -- this is too low and causes all benchmarks reported in ns

207 -- this is too low and causes all benchmarks reported in ns

202− -- , benchIOSink "head" Ops.head

208+ -- , benchIOSink value "head" Ops.head

203− , benchIOSink "last" Ops.last

209+ , benchIOSink value "last" Ops.last

204− -- , benchIOSink "lookup" Ops.lookup

210+ -- , benchIOSink value "lookup" Ops.lookup

205− , benchIOSink "find" Ops.find

211+ , benchIOSink value "find" (Ops.find value)

206− , benchIOSink "findIndex" Ops.findIndex

212+ , benchIOSink value "findIndex" (Ops.findIndex value)

207− , benchIOSink "elemIndex" Ops.elemIndex

213+ , benchIOSink value "elemIndex" (Ops.elemIndex value)

208

214

209 -- this is too low and causes all benchmarks reported in ns

215 -- this is too low and causes all benchmarks reported in ns

210− -- , benchIOSink "null" Ops.null

216+ -- , benchIOSink value "null" Ops.null

211− , benchIOSink "elem" Ops.elem

217+ , benchIOSink value "elem" (Ops.elem value)

212− , benchIOSink "notElem" Ops.notElem

218+ , benchIOSink value "notElem" (Ops.notElem value)

213− , benchIOSink "all" Ops.all

219+ , benchIOSink value "all" (Ops.all value)

214− , benchIOSink "any" Ops.any

220+ , benchIOSink value "any" (Ops.any value)

215− , benchIOSink "and" Ops.and

221+ , benchIOSink value "and" (Ops.and value)

216− , benchIOSink "or" Ops.or

222+ , benchIOSink value "or" (Ops.or value)

217−

223+

218− , benchIOSink "length" Ops.length

224+ , benchIOSink value "length" Ops.length

219− , benchHoistSink "length . generally" (Ops.length . IP.generally)

225+ , benchHoistSink value "length . generally" (Ops.length . IP.generally)

220− , benchIOSink "sum" Ops.sum

226+ , benchIOSink value "sum" Ops.sum

221− , benchIOSink "product" Ops.product

227+ , benchIOSink value "product" Ops.product

222−

228+

223− , benchIOSink "maximumBy" Ops.maximumBy

229+ , benchIOSink value "maximumBy" Ops.maximumBy

224− , benchIOSink "maximum" Ops.maximum

230+ , benchIOSink value "maximum" Ops.maximum

225− , benchIOSink "minimumBy" Ops.minimumBy

231+ , benchIOSink value "minimumBy" Ops.minimumBy

226− , benchIOSink "minimum" Ops.minimum

232+ , benchIOSink value "minimum" Ops.minimum

227−

233+

228− , benchIOSink "toList" Ops.toList

234+ , benchIOSink value "toList" Ops.toList

229− , benchIOSink "toListRev" Ops.toListRev

235+ , benchIOSink value "toListRev" Ops.toListRev

230 ]

236 ]

231 , bgroup "folds"

237 , bgroup "folds"

232− [ benchIOSink "drain" (S.fold FL.drain)

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

233− , benchIOSink "drainN" (S.fold (IFL.drainN Ops.value))

239+ , benchIOSink value "drainN" (S.fold (IFL.drainN value))

234− , benchIOSink "drainWhileTrue" (S.fold (IFL.drainWhile $ (<=) Ops.maxValue))

240+ , benchIOSink value "drainWhileTrue" (S.fold (IFL.drainWhile $ (<=) (value + 1)))

235− , benchIOSink "drainWhileFalse" (S.fold (IFL.drainWhile $ (>=) Ops.maxValue))

241+ , benchIOSink value "drainWhileFalse" (S.fold (IFL.drainWhile $ (>=) (value + 1)))

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

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

237− , benchIOSink "last" (S.fold FL.last)

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

238− , benchIOSink "lastN.1" (S.fold (IA.lastN 1))

244+ , benchIOSink value "lastN.1" (S.fold (IA.lastN 1))

239− , benchIOSink "lastN.10" (S.fold (IA.lastN 10))

245+ , benchIOSink value "lastN.10" (S.fold (IA.lastN 10))

240− , benchIOSink "lastN.Max" (S.fold (IA.lastN Ops.maxValue))

246+ , benchIOSink value "lastN.Max" (S.fold (IA.lastN (value + 1)))

241− , benchIOSink "length" (S.fold FL.length)

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

242− , benchIOSink "sum" (S.fold FL.sum)

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

243− , benchIOSink "product" (S.fold FL.product)

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

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

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

245− , benchIOSink "maximum" (S.fold FL.maximum)

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

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

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

247− , benchIOSink "minimum" (S.fold FL.minimum)

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

248− , benchIOSink "mean" (\s -> S.fold FL.mean (S.map (fromIntegral :: Int -> Double) s))

254+ , benchIOSink value "mean" (\s -> S.fold FL.mean (S.map (fromIntegral :: Int -> Double) s))

249− , benchIOSink "variance" (\s -> S.fold FL.variance (S.map (fromIntegral :: Int -> Double) s))

255+ , benchIOSink value "variance" (\s -> S.fold FL.variance (S.map (fromIntegral :: Int -> Double) s))

250− , benchIOSink "stdDev" (\s -> S.fold FL.stdDev (S.map (fromIntegral :: Int -> Double) s))

256+ , benchIOSink value "stdDev" (\s -> S.fold FL.stdDev (S.map (fromIntegral :: Int -> Double) s))

251−

257+

252− , benchIOSink "mconcat" (S.fold FL.mconcat . (S.map (Last . Just)))

258+ , benchIOSink value "mconcat" (S.fold FL.mconcat . (S.map (Last . Just)))

253− , benchIOSink "foldMap" (S.fold (FL.foldMap (Last . Just)))

259+ , benchIOSink value "foldMap" (S.fold (FL.foldMap (Last . Just)))

254−

260+

255− , benchIOSink "toList" (S.fold FL.toList)

261+ , benchIOSink value "toList" (S.fold FL.toList)

256− , benchIOSink "toListRevF" (S.fold IFL.toListRevF)

262+ , benchIOSink value "toListRevF" (S.fold IFL.toListRevF)

257− , benchIOSink "toStream" (S.fold IP.toStream)

263+ , benchIOSink value "toStream" (S.fold IP.toStream)

258− , benchIOSink "toStreamRev" (S.fold IP.toStreamRev)

264+ , benchIOSink value "toStreamRev" (S.fold IP.toStreamRev)

259− , benchIOSink "writeN" (S.fold (A.writeN Ops.value))

265+ , benchIOSink value "writeN" (S.fold (A.writeN value))

260−

266+

261− , benchIOSink "index" (S.fold (FL.index Ops.maxValue))

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

262− , benchIOSink "head" (S.fold FL.head)

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

263− , benchIOSink "find" (S.fold (FL.find (== Ops.maxValue)))

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

264− , benchIOSink "findIndex" (S.fold (FL.findIndex (== Ops.maxValue)))

270+ , benchIOSink value "findIndex" (S.fold (FL.findIndex (== (value + 1))))

265− , benchIOSink "elemIndex" (S.fold (FL.elemIndex Ops.maxValue))

271+ , benchIOSink value "elemIndex" (S.fold (FL.elemIndex (value + 1)))

266−

272+

267− , benchIOSink "null" (S.fold FL.null)

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

268− , benchIOSink "elem" (S.fold (FL.elem Ops.maxValue))

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

269− , benchIOSink "notElem" (S.fold (FL.notElem Ops.maxValue))

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

270− , benchIOSink "all" (S.fold (FL.all (<= Ops.maxValue)))

276+ , benchIOSink value "all" (S.fold (FL.all (<= (value + 1))))

271− , benchIOSink "any" (S.fold (FL.any (> Ops.maxValue)))

277+ , benchIOSink value "any" (S.fold (FL.any (> (value + 1))))

272− , benchIOSink "and" (\s -> S.fold FL.and (S.map (<= Ops.maxValue) s))

278+ , benchIOSink value "and" (\s -> S.fold FL.and (S.map (<= (value + 1)) s))

273− , benchIOSink "or" (\s -> S.fold FL.or (S.map (> Ops.maxValue) s))

279+ , benchIOSink value "or" (\s -> S.fold FL.or (S.map (> (value + 1)) s))

274 ]

280 ]

275 , bgroup "fold-multi-stream"

281 , bgroup "fold-multi-stream"

276− [ benchIOSink1 "eqBy" Ops.eqBy

282+ [ benchIOSink1 "eqBy" (Ops.eqBy value)

277− , benchIOSink1 "cmpBy" Ops.cmpBy

283+ , benchIOSink1 "cmpBy" (Ops.cmpBy value)

278− , benchIOSink "isPrefixOf" Ops.isPrefixOf

284+ , benchIOSink value "isPrefixOf" Ops.isPrefixOf

279− , benchIOSink "isSubsequenceOf" Ops.isSubsequenceOf

285+ , benchIOSink value "isSubsequenceOf" Ops.isSubsequenceOf

280− , benchIOSink "stripPrefix" Ops.stripPrefix

286+ , benchIOSink value "stripPrefix" Ops.stripPrefix

281 ]

287 ]

282 , bgroup "folds-transforms"

288 , bgroup "folds-transforms"

283− [ benchIOSink "drain" (S.fold FL.drain)

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

284− , benchIOSink "lmap" (S.fold (IFL.lmap (+1) FL.drain))

290+ , benchIOSink value "lmap" (S.fold (IFL.lmap (+1) FL.drain))

285− , benchIOSink "pipe-mapM"

291+ , benchIOSink value "pipe-mapM"

286 (S.fold (IFL.transform (Pipe.mapM (\x -> return $ x + 1)) FL.drain))

292 (S.fold (IFL.transform (Pipe.mapM (\x -> return $ x + 1)) FL.drain))

287 ]

293 ]

288 , bgroup "folds-compositions" -- Applicative

294 , bgroup "folds-compositions" -- Applicative

289 [

295 [

290− benchIOSink "all,any" (S.fold ((,) <$> FL.all (<= Ops.maxValue)

296+ benchIOSink value "all,any" (S.fold ((,) <$> FL.all (<= (value + 1))

291− <*> FL.any (> Ops.maxValue)))

297+ <*> FL.any (> (value + 1))))

292− , benchIOSink "sum,length" (S.fold ((,) <$> FL.sum <*> FL.length))

298+ , benchIOSink value "sum,length" (S.fold ((,) <$> FL.sum <*> FL.length))

293 ]

299 ]

294 , bgroup "pipes"

300 , bgroup "pipes"

295− [ benchIOSink "mapM" (Ops.transformMapM serially 1)

301+ [ benchIOSink value "mapM" (Ops.transformMapM serially 1)

296− , benchIOSink "compose" (Ops.transformComposeMapM serially 1)

302+ , benchIOSink value "compose" (Ops.transformComposeMapM serially 1)

297− , benchIOSink "tee" (Ops.transformTeeMapM serially 1)

303+ , benchIOSink value "tee" (Ops.transformTeeMapM serially 1)

298− , benchIOSink "zip" (Ops.transformZipMapM serially 1)

304+ , benchIOSink value "zip" (Ops.transformZipMapM serially 1)

299 ]

305 ]

300 , bgroup "pipesX4"

306 , bgroup "pipesX4"

301− [ benchIOSink "mapM" (Ops.transformMapM serially 4)

307+ [ benchIOSink value "mapM" (Ops.transformMapM serially 4)

302− , benchIOSink "compose" (Ops.transformComposeMapM serially 4)

308+ , benchIOSink value "compose" (Ops.transformComposeMapM serially 4)

303− , benchIOSink "tee" (Ops.transformTeeMapM serially 4)

309+ , benchIOSink value "tee" (Ops.transformTeeMapM serially 4)

304− , benchIOSink "zip" (Ops.transformZipMapM serially 4)

310+ , benchIOSink value "zip" (Ops.transformZipMapM serially 4)

305 ]

311 ]

306 , bgroup "transformer"

312 , bgroup "transformer"

307− [ benchIOSrc serially "evalState" Ops.evalStateT

313+ [ benchIOSrc serially "evalState" (Ops.evalStateT value)

308− , benchIOSrc serially "withState" Ops.withState

314+ , benchIOSrc serially "withState" (Ops.withState value)

309 ]

315 ]

310 , bgroup "transformation"

316 , bgroup "transformation"

311− [ benchIOSink "scanl" (Ops.scan 1)

317+ [ benchIOSink value "scanl" (Ops.scan 1)

312− , benchIOSink "scanl1'" (Ops.scanl1' 1)

318+ , benchIOSink value "scanl1'" (Ops.scanl1' 1)

313− , benchIOSink "map" (Ops.map 1)

319+ , benchIOSink value "map" (Ops.map 1)

314− , benchIOSink "fmap" (Ops.fmap 1)

320+ , benchIOSink value "fmap" (Ops.fmap 1)

315− , benchIOSink "mapM" (Ops.mapM serially 1)

321+ , benchIOSink value "mapM" (Ops.mapM serially 1)

316− , benchIOSink "mapMaybe" (Ops.mapMaybe 1)

322+ , benchIOSink value "mapMaybe" (Ops.mapMaybe 1)

317− , benchIOSink "mapMaybeM" (Ops.mapMaybeM 1)

323+ , benchIOSink value "mapMaybeM" (Ops.mapMaybeM 1)

318 , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->

324 , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->

319− Ops.sequence serially (Ops.sourceUnfoldrMAction n)

325+ Ops.sequence serially (Ops.sourceUnfoldrMAction value n)

320− , benchIOSink "findIndices" (Ops.findIndices 1)

326+ , benchIOSink value "findIndices" (Ops.findIndices value 1)

321− , benchIOSink "elemIndices" (Ops.elemIndices 1)

327+ , benchIOSink value "elemIndices" (Ops.elemIndices value 1)

322− , benchIOSink "reverse" (Ops.reverse 1)

328+ , benchIOSink value "reverse" (Ops.reverse 1)

323− , benchIOSink "reverse'" (Ops.reverse' 1)

329+ , benchIOSink value "reverse'" (Ops.reverse' 1)

324− , benchIOSink "foldrS" (Ops.foldrS 1)

330+ , benchIOSink value "foldrS" (Ops.foldrS 1)

325− , benchIOSink "foldrSMap" (Ops.foldrSMap 1)

331+ , benchIOSink value "foldrSMap" (Ops.foldrSMap 1)

326− , benchIOSink "foldrT" (Ops.foldrT 1)

332+ , benchIOSink value "foldrT" (Ops.foldrT 1)

327− , benchIOSink "foldrTMap" (Ops.foldrTMap 1)

333+ , benchIOSink value "foldrTMap" (Ops.foldrTMap 1)

328− , benchIOSink "tap" (Ops.tap 1)

334+ , benchIOSink value "tap" (Ops.tap 1)

329− , benchIOSink "tapRate 1 second" (Ops.tapRate 1)

335+ , benchIOSink value "tapRate 1 second" (Ops.tapRate 1)

330− , benchIOSink "pollCounts 1 second" (Ops.pollCounts 1)

336+ , benchIOSink value "pollCounts 1 second" (Ops.pollCounts 1)

331− , benchIOSink "tapAsync" (Ops.tapAsync 1)

337+ , benchIOSink value "tapAsync" (Ops.tapAsync 1)

332− , benchIOSink "tapAsyncS" (Ops.tapAsyncS 1)

338+ , benchIOSink value "tapAsyncS" (Ops.tapAsyncS 1)

333 ]

339 ]

334 , bgroup "transformationX4"

340 , bgroup "transformationX4"

335− [ benchIOSink "scan" (Ops.scan 4)

341+ [ benchIOSink value "scan" (Ops.scan 4)

336− , benchIOSink "scanl1'" (Ops.scanl1' 4)

342+ , benchIOSink value "scanl1'" (Ops.scanl1' 4)

337− , benchIOSink "map" (Ops.map 4)

343+ , benchIOSink value "map" (Ops.map 4)

338− , benchIOSink "fmap" (Ops.fmap 4)

344+ , benchIOSink value "fmap" (Ops.fmap 4)

339− , benchIOSink "mapM" (Ops.mapM serially 4)

345+ , benchIOSink value "mapM" (Ops.mapM serially 4)

340− , benchIOSink "mapMaybe" (Ops.mapMaybe 4)

346+ , benchIOSink value "mapMaybe" (Ops.mapMaybe 4)

341− , benchIOSink "mapMaybeM" (Ops.mapMaybeM 4)

347+ , benchIOSink value "mapMaybeM" (Ops.mapMaybeM 4)

342 -- , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->

348 -- , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->

343 -- Ops.sequence serially (Ops.sourceUnfoldrMAction n)

349 -- Ops.sequence serially (Ops.sourceUnfoldrMAction n)

344− , benchIOSink "findIndices" (Ops.findIndices 4)

350+ , benchIOSink value "findIndices" (Ops.findIndices value 4)

345− , benchIOSink "elemIndices" (Ops.elemIndices 4)

351+ , benchIOSink value "elemIndices" (Ops.elemIndices value 4)

346 ]

352 ]

347 , bgroup "filtering"

353 , bgroup "filtering"

348− [ benchIOSink "filter-even" (Ops.filterEven 1)

354+ [ benchIOSink value "filter-even" (Ops.filterEven 1)

349− , benchIOSink "filter-all-out" (Ops.filterAllOut 1)

355+ , benchIOSink value "filter-all-out" (Ops.filterAllOut value 1)

350− , benchIOSink "filter-all-in" (Ops.filterAllIn 1)

356+ , benchIOSink value "filter-all-in" (Ops.filterAllIn value 1)

351− , benchIOSink "take-all" (Ops.takeAll 1)

357+ , benchIOSink value "take-all" (Ops.takeAll value 1)

352− , benchIOSink "takeWhile-true" (Ops.takeWhileTrue 1)

358+ , benchIOSink value "takeWhile-true" (Ops.takeWhileTrue value 1)

353− --, benchIOSink "takeWhileM-true" (Ops.takeWhileMTrue 1)

359+ --, benchIOSink value "takeWhileM-true" (Ops.takeWhileMTrue 1)

354− , benchIOSink "drop-one" (Ops.dropOne 1)

360+ , benchIOSink value "drop-one" (Ops.dropOne 1)

355− , benchIOSink "drop-all" (Ops.dropAll 1)

361+ , benchIOSink value "drop-all" (Ops.dropAll value 1)

356− , benchIOSink "dropWhile-true" (Ops.dropWhileTrue 1)

362+ , benchIOSink value "dropWhile-true" (Ops.dropWhileTrue value 1)

357− --, benchIOSink "dropWhileM-true" (Ops.dropWhileMTrue 1)

363+ --, benchIOSink value "dropWhileM-true" (Ops.dropWhileMTrue 1)

358− , benchIOSink "dropWhile-false" (Ops.dropWhileFalse 1)

364+ , benchIOSink value "dropWhile-false" (Ops.dropWhileFalse value 1)

359− , benchIOSink "deleteBy" (Ops.deleteBy 1)

365+ , benchIOSink value "deleteBy" (Ops.deleteBy value 1)

360− , benchIOSink "intersperse" (Ops.intersperse 1)

366+ , benchIOSink value "intersperse" (Ops.intersperse value 1)

361− , benchIOSink "insertBy" (Ops.insertBy 1)

367+ , benchIOSink value "insertBy" (Ops.insertBy value 1)

362 ]

368 ]

363 , bgroup "filteringX4"

369 , bgroup "filteringX4"

364− [ benchIOSink "filter-even" (Ops.filterEven 4)

370+ [ benchIOSink value "filter-even" (Ops.filterEven 4)

365− , benchIOSink "filter-all-out" (Ops.filterAllOut 4)

371+ , benchIOSink value "filter-all-out" (Ops.filterAllOut value 4)

366− , benchIOSink "filter-all-in" (Ops.filterAllIn 4)

372+ , benchIOSink value "filter-all-in" (Ops.filterAllIn value 4)

367− , benchIOSink "take-all" (Ops.takeAll 4)

373+ , benchIOSink value "take-all" (Ops.takeAll value 4)

368− , benchIOSink "takeWhile-true" (Ops.takeWhileTrue 4)

374+ , benchIOSink value "takeWhile-true" (Ops.takeWhileTrue value 4)

369− --, benchIOSink "takeWhileM-true" (Ops.takeWhileMTrue 4)

375+ --, benchIOSink value "takeWhileM-true" (Ops.takeWhileMTrue 4)

370− , benchIOSink "drop-one" (Ops.dropOne 4)

376+ , benchIOSink value "drop-one" (Ops.dropOne 4)

371− , benchIOSink "drop-all" (Ops.dropAll 4)

377+ , benchIOSink value "drop-all" (Ops.dropAll value 4)

372− , benchIOSink "dropWhile-true" (Ops.dropWhileTrue 4)

378+ , benchIOSink value "dropWhile-true" (Ops.dropWhileTrue value 4)

373− --, benchIOSink "dropWhileM-true" (Ops.dropWhileMTrue 4)

379+ --, benchIOSink value "dropWhileM-true" (Ops.dropWhileMTrue 4)

374− , benchIOSink "dropWhile-false" (Ops.dropWhileFalse 4)

380+ , benchIOSink value "dropWhile-false" (Ops.dropWhileFalse value 4)

375− , benchIOSink "deleteBy" (Ops.deleteBy 4)

381+ , benchIOSink value "deleteBy" (Ops.deleteBy value 4)

376− , benchIOSink "intersperse" (Ops.intersperse 4)

382+ , benchIOSink value "intersperse" (Ops.intersperse value 4)

377− , benchIOSink "insertBy" (Ops.insertBy 4)

383+ , benchIOSink value "insertBy" (Ops.insertBy value 4)

378 ]

384 ]

379 , bgroup "joining"

385 , bgroup "joining"

380− [ benchIOSrc1 "zip (2,x/2)" (Ops.zip (Ops.value `div` 2))

386+ [ benchIOSrc1 "zip (2,x/2)" (Ops.zip (value `div` 2))

381− , benchIOSrc1 "zipM (2,x/2)" (Ops.zipM (Ops.value `div` 2))

387+ , benchIOSrc1 "zipM (2,x/2)" (Ops.zipM (value `div` 2))

382− , benchIOSrc1 "mergeBy (2,x/2)" (Ops.mergeBy (Ops.value `div` 2))

388+ , benchIOSrc1 "mergeBy (2,x/2)" (Ops.mergeBy (value `div` 2))

383− , benchIOSrc1 "serial (2,x/2)" (Ops.serial2 (Ops.value `div` 2))

389+ , benchIOSrc1 "serial (2,x/2)" (Ops.serial2 (value `div` 2))

384− , benchIOSrc1 "append (2,x/2)" (Ops.append2 (Ops.value `div` 2))

390+ , benchIOSrc1 "append (2,x/2)" (Ops.append2 (value `div` 2))

385− , benchIOSrc1 "serial (2,2,x/4)" (Ops.serial4 (Ops.value `div` 4))

391+ , benchIOSrc1 "serial (2,2,x/4)" (Ops.serial4 (value `div` 4))

386− , benchIOSrc1 "append (2,2,x/4)" (Ops.append4 (Ops.value `div` 4))

392+ , benchIOSrc1 "append (2,2,x/4)" (Ops.append4 (value `div` 4))

387− , benchIOSrc1 "wSerial (2,x/2)" Ops.wSerial2

393+ , benchIOSrc1 "wSerial (2,x/2)" (Ops.wSerial2 value)

388− , benchIOSrc1 "interleave (2,x/2)" Ops.interleave2

394+ , benchIOSrc1 "interleave (2,x/2)" (Ops.interleave2 value)

389− , benchIOSrc1 "roundRobin (2,x/2)" Ops.roundRobin2

395+ , benchIOSrc1 "roundRobin (2,x/2)" (Ops.roundRobin2 value)

390 ]

396 ]

391 , bgroup "concat-foldable"

397 , bgroup "concat-foldable"

392− [ benchIOSrc serially "foldMapWith" Ops.sourceFoldMapWith

398+ [ benchIOSrc serially "foldMapWith" (Ops.sourceFoldMapWith value)

393− , benchIOSrc serially "foldMapWithM" Ops.sourceFoldMapWithM

399+ , benchIOSrc serially "foldMapWithM" (Ops.sourceFoldMapWithM value)

394− , benchIOSrc serially "foldMapM" Ops.sourceFoldMapM

400+ , benchIOSrc serially "foldMapM" (Ops.sourceFoldMapM value)

395− , benchIOSrc serially "foldWithConcatMapId" Ops.sourceConcatMapId

401+ , benchIOSrc serially "foldWithConcatMapId" (Ops.sourceConcatMapId value)

396 ]

402 ]

397 , bgroup "concat-serial"

403 , bgroup "concat-serial"

398− [ benchIOSrc1 "concatMapPure (2,x/2)" (Ops.concatMapPure 2 (Ops.value `div` 2))

404+ [ benchIOSrc1 "concatMapPure (2,x/2)" (Ops.concatMapPure 2 (value `div` 2))

399− , benchIOSrc1 "concatMap (2,x/2)" (Ops.concatMap 2 (Ops.value `div` 2))

405+ , benchIOSrc1 "concatMap (2,x/2)" (Ops.concatMap 2 (value `div` 2))

400− , benchIOSrc1 "concatMap (x/2,2)" (Ops.concatMap (Ops.value `div` 2) 2)

406+ , benchIOSrc1 "concatMap (x/2,2)" (Ops.concatMap (value `div` 2) 2)

401− , benchIOSrc1 "concatMapRepl (x/4,4)" Ops.concatMapRepl4xN

407+ , benchIOSrc1 "concatMapRepl (x/4,4)" (Ops.concatMapRepl4xN value)

402− , benchIOSrc1 "concatUnfoldRepl (x/4,4)" Ops.concatUnfoldRepl4xN

408+ , benchIOSrc1 "concatUnfoldRepl (x/4,4)" (Ops.concatUnfoldRepl4xN value)

403

409

404 , benchIOSrc1 "concatMapWithSerial (2,x/2)"

410 , benchIOSrc1 "concatMapWithSerial (2,x/2)"

405− (Ops.concatMapWithSerial 2 (Ops.value `div` 2))

411+ (Ops.concatMapWithSerial 2 (value `div` 2))

406 , benchIOSrc1 "concatMapWithSerial (x/2,2)"

412 , benchIOSrc1 "concatMapWithSerial (x/2,2)"

407− (Ops.concatMapWithSerial (Ops.value `div` 2) 2)

413+ (Ops.concatMapWithSerial (value `div` 2) 2)

408

414

409 , benchIOSrc1 "concatMapWithAppend (2,x/2)"

415 , benchIOSrc1 "concatMapWithAppend (2,x/2)"

410− (Ops.concatMapWithAppend 2 (Ops.value `div` 2))

416+ (Ops.concatMapWithAppend 2 (value `div` 2))

411 ]

417 ]

412 , bgroup "concat-interleave"

418 , bgroup "concat-interleave"

413 [ benchIOSrc1 "concatMapWithWSerial (2,x/2)"

419 [ benchIOSrc1 "concatMapWithWSerial (2,x/2)"

414− (Ops.concatMapWithWSerial 2 (Ops.value `div` 2))

420+ (Ops.concatMapWithWSerial 2 (value `div` 2))

415 , benchIOSrc1 "concatMapWithWSerial (x/2,2)"

421 , benchIOSrc1 "concatMapWithWSerial (x/2,2)"

416− (Ops.concatMapWithWSerial (Ops.value `div` 2) 2)

422+ (Ops.concatMapWithWSerial (value `div` 2) 2)

417 , benchIOSrc1 "concatUnfoldInterleaveRepl (x/4,4)"

423 , benchIOSrc1 "concatUnfoldInterleaveRepl (x/4,4)"

418− Ops.concatUnfoldInterleaveRepl4xN

424+ (Ops.concatUnfoldInterleaveRepl4xN value)

419 , benchIOSrc1 "concatUnfoldRoundrobinRepl (x/4,4)"

425 , benchIOSrc1 "concatUnfoldRoundrobinRepl (x/4,4)"

420− Ops.concatUnfoldRoundrobinRepl4xN

426+ (Ops.concatUnfoldRoundrobinRepl4xN value)

421 ]

427 ]

422 -- scanl-map and foldl-map are equivalent to the scan and fold in the foldl

428 -- scanl-map and foldl-map are equivalent to the scan and fold in the foldl

423 -- library. If scan/fold followed by a map is efficient enough we may not

429 -- library. If scan/fold followed by a map is efficient enough we may not

424 -- need monolithic implementations of these.

430 -- need monolithic implementations of these.

425 , bgroup "mixed"

431 , bgroup "mixed"

426− [ benchIOSink "scanl-map" (Ops.scanMap 1)

432+ [ benchIOSink value "scanl-map" (Ops.scanMap 1)

427− , benchIOSink "foldl-map" Ops.foldl'ReduceMap

433+ , benchIOSink value "foldl-map" Ops.foldl'ReduceMap

428− , benchIOSink "sum-product-fold" Ops.sumProductFold

434+ , benchIOSink value "sum-product-fold" Ops.sumProductFold

429− , benchIOSink "sum-product-scan" Ops.sumProductScan

435+ , benchIOSink value "sum-product-scan" Ops.sumProductScan

430 ]

436 ]

431 , bgroup "mixedX4"

437 , bgroup "mixedX4"

432− [ benchIOSink "scan-map" (Ops.scanMap 4)

438+ [ benchIOSink value "scan-map" (Ops.scanMap 4)

433− , benchIOSink "drop-map" (Ops.dropMap 4)

439+ , benchIOSink value "drop-map" (Ops.dropMap 4)

434− , benchIOSink "drop-scan" (Ops.dropScan 4)

440+ , benchIOSink value "drop-scan" (Ops.dropScan 4)

435− , benchIOSink "take-drop" (Ops.takeDrop 4)

441+ , benchIOSink value "take-drop" (Ops.takeDrop value 4)

436− , benchIOSink "take-scan" (Ops.takeScan 4)

442+ , benchIOSink value "take-scan" (Ops.takeScan value 4)

437− , benchIOSink "take-map" (Ops.takeMap 4)

443+ , benchIOSink value "take-map" (Ops.takeMap value 4)

438− , benchIOSink "filter-drop" (Ops.filterDrop 4)

444+ , benchIOSink value "filter-drop" (Ops.filterDrop value 4)

439− , benchIOSink "filter-take" (Ops.filterTake 4)

445+ , benchIOSink value "filter-take" (Ops.filterTake value 4)

440− , benchIOSink "filter-scan" (Ops.filterScan 4)

446+ , benchIOSink value "filter-scan" (Ops.filterScan 4)

441− , benchIOSink "filter-scanl1" (Ops.filterScanl1 4)

447+ , benchIOSink value "filter-scanl1" (Ops.filterScanl1 4)

442− , benchIOSink "filter-map" (Ops.filterMap 4)

448+ , benchIOSink value "filter-map" (Ops.filterMap value 4)

443 ]

449 ]

444 , bgroup "iterated"

450 , bgroup "iterated"

445 [ benchIOSrc serially "mapM" Ops.iterateMapM

451 [ benchIOSrc serially "mapM" Ops.iterateMapM

446 , benchIOSrc serially "scan(1/100)" Ops.iterateScan

452 , benchIOSrc serially "scan(1/100)" Ops.iterateScan

447 , benchIOSrc serially "scanl1(1/100)" Ops.iterateScanl1

453 , benchIOSrc serially "scanl1(1/100)" Ops.iterateScanl1

448 , benchIOSrc serially "filterEven" Ops.iterateFilterEven

454 , benchIOSrc serially "filterEven" Ops.iterateFilterEven

449− , benchIOSrc serially "takeAll" Ops.iterateTakeAll

455+ , benchIOSrc serially "takeAll" (Ops.iterateTakeAll value)

450 , benchIOSrc serially "dropOne" Ops.iterateDropOne

456 , benchIOSrc serially "dropOne" Ops.iterateDropOne

451− , benchIOSrc serially "dropWhileFalse" Ops.iterateDropWhileFalse

457+ , benchIOSrc serially "dropWhileFalse" (Ops.iterateDropWhileFalse value)

452− , benchIOSrc serially "dropWhileTrue" Ops.iterateDropWhileTrue

458+ , benchIOSrc serially "dropWhileTrue" (Ops.iterateDropWhileTrue value)

453 ]

459 ]

454 ]

460 ]

455 , bgroup "wSerially"

461 , bgroup "wSerially"

456 [ bgroup "transformation"

462 [ bgroup "transformation"

457− [ benchIOSink "fmap" $ Ops.fmap' wSerially 1

463+ [ benchIOSink value "fmap" $ Ops.fmap' wSerially 1

458 ]

464 ]

459 ]

465 ]

460 , bgroup "zipSerially"

466 , bgroup "zipSerially"

461 [ bgroup "transformation"

467 [ bgroup "transformation"

462− [ benchIOSink "fmap" $ Ops.fmap' zipSerially 1

468+ [ benchIOSink value "fmap" $ Ops.fmap' zipSerially 1

463 ]

469 ]

464 ]

470 ]

465 , bgroup "zipAsyncly"

471 , bgroup "zipAsyncly"

466 [ bgroup "transformation"

472 [ bgroup "transformation"

467− [ benchIOSink "fmap" $ Ops.fmap' zipAsyncly 1

473+ [ benchIOSink value "fmap" $ Ops.fmap' zipAsyncly 1

468 ]

474 ]

469 ]

475 ]

470 ]

476 ]

477+ where

478+ defaultValue = 100000

479+ parseValue [] = (defaultValue, [])

480+ parseValue a@(x:xs) =

481+ case (readMaybe x :: Maybe Int) of

482+ Just value -> (value, xs)

483+ Nothing -> (defaultValue, a)

benchmark/LinearAsync.hs+76−63

@@ -9,6 +9,8 @@

9import Control.DeepSeq (NFData)

10-- import Data.Functor.Identity (Identity, runIdentity)

11import System.Random (randomRIO)

12+import Text.Read (readMaybe)

13+import System.Environment (getArgs)

12import qualified Streamly.Benchmark.Prelude as Ops

14import qualified Streamly.Benchmark.Prelude as Ops

14import Streamly

16import Streamly

@@ -19,8 +21,8 @@ import Gauge

19--

21--

20-- | Takes a fold method, and uses it with a default source.

22-- | Takes a fold method, and uses it with a default source.

21{-# INLINE benchIO #-}

23{-# INLINE benchIO #-}

22−benchIO :: (IsStream t, NFData b) => String -> (t IO Int -> IO b) -> Benchmark

24+benchIO :: (IsStream t, NFData b) => Int -> String -> (t IO Int -> IO b) -> Benchmark

23−benchIO name f = bench name $ nfIO $ randomRIO (1,1) >>= f . Ops.source

25+benchIO value name f = bench name $ nfIO $ randomRIO (1,1) >>= f . Ops.source value

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

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

26{-# INLINE benchSrcIO #-}

28{-# INLINE benchSrcIO #-}

@@ -42,94 +44,105 @@ _benchId name f = bench name $ nf (runIdentity . f) (Ops.source 10)

42-}

44-}

44main :: IO ()

46main :: IO ()

45−main =

47+main = do

46− defaultMainWith (defaultConfig

48+ -- Basement.Terminal.initialize required?

47− { timeLimit = Just 1

49+ args <- getArgs

48− , minDuration = 0

50+ let (value, args') = parseValue args

49−#ifdef LONG_BENCHMARKS

51+ (cfg, extra) = parseWith (newConfig value) args'

50− , includeFirstIter = True

52+ runMode (mode cfg) cfg extra

51−#endif

52− })

53 [ bgroup "asyncly"

54− [ benchSrcIO asyncly "unfoldr" Ops.sourceUnfoldr

54+ [ benchSrcIO asyncly "unfoldr" (Ops.sourceUnfoldr value)

55− , benchSrcIO asyncly "unfoldrM" Ops.sourceUnfoldrM

55+ , benchSrcIO asyncly "unfoldrM" (Ops.sourceUnfoldrM value)

56− , benchSrcIO asyncly "fromFoldable" Ops.sourceFromFoldable

56+ , benchSrcIO asyncly "fromFoldable" (Ops.sourceFromFoldable value)

57− , benchSrcIO asyncly "fromFoldableM" Ops.sourceFromFoldableM

57+ , benchSrcIO asyncly "fromFoldableM" (Ops.sourceFromFoldableM value)

58− , benchSrcIO asyncly "foldMapWith" Ops.sourceFoldMapWith

58+ , benchSrcIO asyncly "foldMapWith" (Ops.sourceFoldMapWith value)

59− , benchSrcIO asyncly "foldMapWithM" Ops.sourceFoldMapWithM

59+ , benchSrcIO asyncly "foldMapWithM" (Ops.sourceFoldMapWithM value)

60− , benchSrcIO asyncly "foldMapM" Ops.sourceFoldMapM

60+ , benchSrcIO asyncly "foldMapM" (Ops.sourceFoldMapM value)

61− , benchIO "map" $ Ops.map' asyncly 1

61+ , benchIO value "map" $ Ops.map' asyncly 1

62− , benchIO "fmap" $ Ops.fmap' asyncly 1

62+ , benchIO value "fmap" $ Ops.fmap' asyncly 1

63− , benchIO "mapM" $ Ops.mapM asyncly 1

63+ , benchIO value "mapM" $ Ops.mapM asyncly 1

64 , benchSrcIO asyncly "unfoldrM maxThreads 1"

65− (maxThreads 1 . Ops.sourceUnfoldrM)

65+ (maxThreads 1 . Ops.sourceUnfoldrM value)

66 , benchSrcIO asyncly "unfoldrM maxBuffer 1 (x/10 ops)"

67− (maxBuffer 1 . Ops.sourceUnfoldrMN (Ops.value `div` 10))

67+ (maxBuffer 1 . Ops.sourceUnfoldrMN (value `div` 10))

68 , benchMonadicSrcIO "concatMapWith (2,x/2)"

69− (Ops.concatStreamsWith async 2 (Ops.value `div` 2))

69+ (Ops.concatStreamsWith async 2 (value `div` 2))

70 , benchMonadicSrcIO "concatMapWith (x/2,2)"

71− (Ops.concatStreamsWith async (Ops.value `div` 2) 2)

71+ (Ops.concatStreamsWith async (value `div` 2) 2)

72 ]

73 , bgroup "wAsyncly"

74− [ benchSrcIO wAsyncly "unfoldr" Ops.sourceUnfoldr

74+ [ benchSrcIO wAsyncly "unfoldr" (Ops.sourceUnfoldr value)

75− , benchSrcIO wAsyncly "unfoldrM" Ops.sourceUnfoldrM

75+ , benchSrcIO wAsyncly "unfoldrM" (Ops.sourceUnfoldrM value)

76− , benchSrcIO wAsyncly "fromFoldable" Ops.sourceFromFoldable

76+ , benchSrcIO wAsyncly "fromFoldable" (Ops.sourceFromFoldable value)

77− , benchSrcIO wAsyncly "fromFoldableM" Ops.sourceFromFoldableM

77+ , benchSrcIO wAsyncly "fromFoldableM" (Ops.sourceFromFoldableM value)

78− , benchSrcIO wAsyncly "foldMapWith" Ops.sourceFoldMapWith

78+ , benchSrcIO wAsyncly "foldMapWith" (Ops.sourceFoldMapWith value)

79− , benchSrcIO wAsyncly "foldMapWithM" Ops.sourceFoldMapWithM

79+ , benchSrcIO wAsyncly "foldMapWithM" (Ops.sourceFoldMapWithM value)

80− , benchSrcIO wAsyncly "foldMapM" Ops.sourceFoldMapM

80+ , benchSrcIO wAsyncly "foldMapM" (Ops.sourceFoldMapM value)

81− , benchIO "map" $ Ops.map' wAsyncly 1

81+ , benchIO value "map" $ Ops.map' wAsyncly 1

82− , benchIO "fmap" $ Ops.fmap' wAsyncly 1

82+ , benchIO value "fmap" $ Ops.fmap' wAsyncly 1

83− , benchIO "mapM" $ Ops.mapM wAsyncly 1

83+ , benchIO value "mapM" $ Ops.mapM wAsyncly 1

84 , benchMonadicSrcIO "concatMapWith (2,x/2)"

85− (Ops.concatStreamsWith wAsync 2 (Ops.value `div` 2))

85+ (Ops.concatStreamsWith wAsync 2 (value `div` 2))

86 , benchMonadicSrcIO "concatMapWith (x/2,2)"

87− (Ops.concatStreamsWith wAsync (Ops.value `div` 2) 2)

87+ (Ops.concatStreamsWith wAsync (value `div` 2) 2)

88 ]

89 -- unfoldr and fromFoldable are always serial and thereofore the same for

90 -- all stream types.

91 , bgroup "aheadly"

92− [ benchSrcIO aheadly "unfoldr" Ops.sourceUnfoldr

92+ [ benchSrcIO aheadly "unfoldr" (Ops.sourceUnfoldr value)

93− , benchSrcIO aheadly "unfoldrM" Ops.sourceUnfoldrM

93+ , benchSrcIO aheadly "unfoldrM" (Ops.sourceUnfoldrM value)

94− , benchSrcIO aheadly "fromFoldableM" Ops.sourceFromFoldableM

94+ , benchSrcIO aheadly "fromFoldableM" (Ops.sourceFromFoldableM value)

95 -- , benchSrcIO aheadly "foldMapWith" Ops.sourceFoldMapWith

96− , benchSrcIO aheadly "foldMapWithM" Ops.sourceFoldMapWithM

96+ , benchSrcIO aheadly "foldMapWithM" (Ops.sourceFoldMapWithM value)

97− , benchSrcIO aheadly "foldMapM" Ops.sourceFoldMapM

97+ , benchSrcIO aheadly "foldMapM" (Ops.sourceFoldMapM value)

98− , benchIO "map" $ Ops.map' aheadly 1

98+ , benchIO value "map" $ Ops.map' aheadly 1

99− , benchIO "fmap" $ Ops.fmap' aheadly 1

99+ , benchIO value "fmap" $ Ops.fmap' aheadly 1

100− , benchIO "mapM" $ Ops.mapM aheadly 1

100+ , benchIO value "mapM" $ Ops.mapM aheadly 1

101 , benchSrcIO aheadly "unfoldrM maxThreads 1"

102− (maxThreads 1 . Ops.sourceUnfoldrM)

102+ (maxThreads 1 . Ops.sourceUnfoldrM value)

103 , benchSrcIO aheadly "unfoldrM maxBuffer 1 (x/10 ops)"

104− (maxBuffer 1 . Ops.sourceUnfoldrMN (Ops.value `div` 10))

104+ (maxBuffer 1 . Ops.sourceUnfoldrMN (value `div` 10))

105 -- , benchSrcIO aheadly "fromFoldable" Ops.sourceFromFoldable

106 , benchMonadicSrcIO "concatMapWith (2,x/2)"

107− (Ops.concatStreamsWith ahead 2 (Ops.value `div` 2))

107+ (Ops.concatStreamsWith ahead 2 (value `div` 2))

108 , benchMonadicSrcIO "concatMapWith (x/2,2)"

109− (Ops.concatStreamsWith ahead (Ops.value `div` 2) 2)

109+ (Ops.concatStreamsWith ahead (value `div` 2) 2)

110 ]

111 -- XXX need to use smaller streams to finish in reasonable time

112 , bgroup "parallely"

113− [ benchSrcIO parallely "unfoldr" Ops.sourceUnfoldr

113+ [ benchSrcIO parallely "unfoldr" (Ops.sourceUnfoldr value)

114− , benchSrcIO parallely "unfoldrM" Ops.sourceUnfoldrM

114+ , benchSrcIO parallely "unfoldrM" (Ops.sourceUnfoldrM value)

115 --, benchSrcIO parallely "fromFoldable" Ops.sourceFromFoldable

116− , benchSrcIO parallely "fromFoldableM" Ops.sourceFromFoldableM

116+ , benchSrcIO parallely "fromFoldableM" (Ops.sourceFromFoldableM value)

117 -- , benchSrcIO parallely "foldMapWith" Ops.sourceFoldMapWith

118− , benchSrcIO parallely "foldMapWithM" Ops.sourceFoldMapWithM

118+ , benchSrcIO parallely "foldMapWithM" (Ops.sourceFoldMapWithM value)

119− , benchSrcIO parallely "foldMapM" Ops.sourceFoldMapM

119+ , benchSrcIO parallely "foldMapM" (Ops.sourceFoldMapM value)

120− , benchIO "map" $ Ops.map' parallely 1

120+ , benchIO value "map" $ Ops.map' parallely 1

121− , benchIO "fmap" $ Ops.fmap' parallely 1

121+ , benchIO value "fmap" $ Ops.fmap' parallely 1

122− , benchIO "mapM" $ Ops.mapM parallely 1

122+ , benchIO value "mapM" $ Ops.mapM parallely 1

123 -- Zip has only one parallel flavor

124− , benchIO "zip" Ops.zipAsync

124+ , benchIO value "zip" Ops.zipAsync

125− , benchIO "zipM" Ops.zipAsyncM

125+ , benchIO value "zipM" Ops.zipAsyncM

126− , benchIO "zipAp" Ops.zipAsyncAp

126+ , benchIO value "zipAp" Ops.zipAsyncAp

127 -- Parallel stages in a pipeline

128− , benchIO "parAppMap" Ops.parAppMap

128+ , benchIO value "parAppMap" Ops.parAppMap

129− , benchIO "parAppSum" Ops.parAppSum

129+ , benchIO value "parAppSum" Ops.parAppSum

130 , benchMonadicSrcIO "concatMapWith (2,x/2)"

131− (Ops.concatStreamsWith parallel 2 (Ops.value `div` 2))

131+ (Ops.concatStreamsWith parallel 2 (value `div` 2))

132 , benchMonadicSrcIO "concatMapWith (x/10,10)"

133− (Ops.concatStreamsWith parallel (Ops.value `div` 10) 10)

133+ (Ops.concatStreamsWith parallel (value `div` 10) 10)

134 ]

135 ]

136+ where

137+ defaultValue = 10000

138+ parseValue [] = (defaultValue, [])

139+ parseValue a@(x:xs) =

140+ case (readMaybe x :: Maybe Int) of

141+ Just value -> (value, xs)

142+ Nothing -> (defaultValue, a)

143+ newConfig value =

144+ defaultConfig

145+ { timeLimit = Just 1

146+ , minDuration = 0

147+ , includeFirstIter = value >= 10000000

148+ }

benchmark/LinearRate.hs+24−10

@@ -1,3 +1,4 @@

1+{-# LANGUAGE CPP #-}

1-- |

2-- |

2-- Module : Main

3-- Module : Main

@@ -11,6 +12,8 @@

11-- import Data.Functor.Identity (Identity, runIdentity)

12-- import Data.Functor.Identity (Identity, runIdentity)

12import System.Random (randomRIO)

13import System.Random (randomRIO)

13import qualified Streamly.Benchmark.Prelude as Ops

14import qualified Streamly.Benchmark.Prelude as Ops

15+import System.Environment (getArgs)

16+import Text.Read (readMaybe)

15import Streamly

18import Streamly

16import Gauge

19import Gauge

@@ -31,30 +34,41 @@ _benchId name f = bench name $ nf (runIdentity . f) (Ops.source 10)

31-}

34-}

33main :: IO ()

36main :: IO ()

34−main =

37+main = do

35− defaultMain

38+ -- Basement.Terminal.initialize required?

39+ args <- getArgs

40+ let (value, args') = parseValue args

41+ (cfg, extra) = parseWith defaultConfig args'

42+ runMode (mode cfg) cfg extra

36 -- XXX arbitrarily large rate should be the same as rate Nothing

43 -- XXX arbitrarily large rate should be the same as rate Nothing

37 [ bgroup "avgrate"

44 [ bgroup "avgrate"

38 [ bgroup "asyncly"

45 [ bgroup "asyncly"

39 [ -- benchIO "unfoldr" $ Ops.toNull asyncly

46 [ -- benchIO "unfoldr" $ Ops.toNull asyncly

40− benchSrcIO asyncly "unfoldrM" Ops.sourceUnfoldrM

47+ benchSrcIO asyncly "unfoldrM" (Ops.sourceUnfoldrM value)

41 , benchSrcIO asyncly "unfoldrM/Nothing"

48 , benchSrcIO asyncly "unfoldrM/Nothing"

42− (rate Nothing . Ops.sourceUnfoldrM)

49+ (rate Nothing . Ops.sourceUnfoldrM value)

43 , benchSrcIO asyncly "unfoldrM/1,000,000"

50 , benchSrcIO asyncly "unfoldrM/1,000,000"

44− (avgRate 1000000 . Ops.sourceUnfoldrM)

51+ (avgRate 1000000 . Ops.sourceUnfoldrM value)

45 , benchSrcIO asyncly "unfoldrM/3,000,000"

52 , benchSrcIO asyncly "unfoldrM/3,000,000"

46− (avgRate 3000000 . Ops.sourceUnfoldrM)

53+ (avgRate 3000000 . Ops.sourceUnfoldrM value)

47 , benchSrcIO asyncly "unfoldrM/10,000,000/maxThreads1"

54 , benchSrcIO asyncly "unfoldrM/10,000,000/maxThreads1"

48− (maxThreads 1 . avgRate 10000000 . Ops.sourceUnfoldrM)

55+ (maxThreads 1 . avgRate 10000000 . Ops.sourceUnfoldrM value)

49 , benchSrcIO asyncly "unfoldrM/10,000,000"

56 , benchSrcIO asyncly "unfoldrM/10,000,000"

50− (avgRate 10000000 . Ops.sourceUnfoldrM)

57+ (avgRate 10000000 . Ops.sourceUnfoldrM value)

51 , benchSrcIO asyncly "unfoldrM/20,000,000"

58 , benchSrcIO asyncly "unfoldrM/20,000,000"

52− (avgRate 20000000 . Ops.sourceUnfoldrM)

59+ (avgRate 20000000 . Ops.sourceUnfoldrM value)

53 ]

60 ]

54 , bgroup "aheadly"

61 , bgroup "aheadly"

55 [

62 [

56 benchSrcIO aheadly "unfoldrM/1,000,000"

63 benchSrcIO aheadly "unfoldrM/1,000,000"

57− (avgRate 1000000 . Ops.sourceUnfoldrM)

64+ (avgRate 1000000 . Ops.sourceUnfoldrM value)

58 ]

65 ]

59 ]

66 ]

60 ]

67 ]

68+ where

69+ defaultValue = 100000

70+ parseValue [] = (defaultValue, [])

71+ parseValue a@(x:xs) =

72+ case (readMaybe x :: Maybe Int) of

73+ Just value -> (value, xs)

74+ Nothing -> (defaultValue, a)

benchmark/Streamly/Benchmark/Prelude.hs+138−127

@@ -35,7 +35,7 @@ import Prelude

35 (Monad, Int, (+), ($), (.), return, fmap, even, (>), (<=), (==), (>=),

36 subtract, undefined, Maybe(..), odd, Bool, not, (>>=), mapM_, curry,

37 maxBound, div, IO, compare, Double, fromIntegral, Integer, (<$>),

38− (<*>), flip, (**), (/))

38+ (<*>), flip)

39import qualified Prelude as P

40import qualified Data.Foldable as F

41import qualified GHC.Exts as GHC

@@ -54,18 +54,8 @@ import qualified Streamly.Internal.Data.Unfold as UF

54import qualified Streamly.Internal.Data.Pipe as Pipe

55import qualified Streamly.Internal.Data.Stream.Parallel as Par

57−value, maxValue, value2 :: Int

58−

59−-- To detect memory leak issues we need larger streams

57+-- To detect memory leak issues use larger streams.

60−#ifdef LONG_BENCHMARKS

58+-- See Note in .cabal file on how to generate streams of specific size.

61−value = 10000000

62−#elif defined(LINEAR_ASYNC)

63−value = 10000

64−#else

65−value = 100000

66−#endif

67−maxValue = value + 1

68−value2 = P.round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop

70type Stream m a = S.SerialT m a

60type Stream m a = S.SerialT m a

@@ -76,33 +66,33 @@ type Stream m a = S.SerialT m a

76-- enumerate

66-- enumerate

78{-# INLINE sourceIntFromTo #-}

68{-# INLINE sourceIntFromTo #-}

79−sourceIntFromTo :: (Monad m, S.IsStream t) => Int -> t m Int

69+sourceIntFromTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

80−sourceIntFromTo n = S.enumerateFromTo n (n + value)

70+sourceIntFromTo value n = S.enumerateFromTo n (n + value)

82{-# INLINE sourceIntFromThenTo #-}

72{-# INLINE sourceIntFromThenTo #-}

83−sourceIntFromThenTo :: (Monad m, S.IsStream t) => Int -> t m Int

73+sourceIntFromThenTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

84−sourceIntFromThenTo n = S.enumerateFromThenTo n (n + 1) (n + value)

74+sourceIntFromThenTo value n = S.enumerateFromThenTo n (n + 1) (n + value)

86{-# INLINE sourceFracFromTo #-}

76{-# INLINE sourceFracFromTo #-}

87−sourceFracFromTo :: (Monad m, S.IsStream t) => Int -> t m Double

77+sourceFracFromTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Double

88−sourceFracFromTo n =

78+sourceFracFromTo value n =

89 S.enumerateFromTo (fromIntegral n) (fromIntegral (n + value))

79 S.enumerateFromTo (fromIntegral n) (fromIntegral (n + value))

91{-# INLINE sourceFracFromThenTo #-}

81{-# INLINE sourceFracFromThenTo #-}

92−sourceFracFromThenTo :: (Monad m, S.IsStream t) => Int -> t m Double

82+sourceFracFromThenTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Double

93−sourceFracFromThenTo n = S.enumerateFromThenTo (fromIntegral n)

83+sourceFracFromThenTo value n = S.enumerateFromThenTo (fromIntegral n)

94 (fromIntegral n + 1.0001) (fromIntegral (n + value))

84 (fromIntegral n + 1.0001) (fromIntegral (n + value))

96{-# INLINE sourceIntegerFromStep #-}

86{-# INLINE sourceIntegerFromStep #-}

97−sourceIntegerFromStep :: (Monad m, S.IsStream t) => Int -> t m Integer

87+sourceIntegerFromStep :: (Monad m, S.IsStream t) => Int -> Int -> t m Integer

98−sourceIntegerFromStep n =

88+sourceIntegerFromStep value n =

99 S.take value $ S.enumerateFromThen (fromIntegral n) (fromIntegral n + 1)

89 S.take value $ S.enumerateFromThen (fromIntegral n) (fromIntegral n + 1)

100

101-- unfoldr

91-- unfoldr

102

103{-# INLINE sourceUnfoldr #-}

93{-# INLINE sourceUnfoldr #-}

104−sourceUnfoldr :: (Monad m, S.IsStream t) => Int -> t m Int

94+sourceUnfoldr :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

105−sourceUnfoldr n = S.unfoldr step n

95+sourceUnfoldr value n = S.unfoldr step n

106 where

96 where

107 step cnt =

97 step cnt =

108 if cnt > n + value

98 if cnt > n + value

@@ -119,8 +109,8 @@ sourceUnfoldrN upto start = S.unfoldr step start

119 else Just (cnt, cnt + 1)

109 else Just (cnt, cnt + 1)

120

110

121{-# INLINE sourceUnfoldrM #-}

111{-# INLINE sourceUnfoldrM #-}

122−sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> t m Int

112+sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int

123−sourceUnfoldrM n = S.unfoldrM step n

113+sourceUnfoldrM value n = S.unfoldrM step n

124 where

114 where

125 step cnt =

115 step cnt =

126 if cnt > n + value

116 if cnt > n + value

@@ -128,8 +118,8 @@ sourceUnfoldrM n = S.unfoldrM step n

128 else return (Just (cnt, cnt + 1))

118 else return (Just (cnt, cnt + 1))

129

119

130{-# INLINE source #-}

120{-# INLINE source #-}

131−source :: (S.MonadAsync m, S.IsStream t) => Int -> t m Int

121+source :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

132−source n = sourceUnfoldrM n

122+source = sourceUnfoldrM

133

123

134{-# INLINE sourceUnfoldrMN #-}

124{-# INLINE sourceUnfoldrMN #-}

135sourceUnfoldrMN :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int

125sourceUnfoldrMN :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int

@@ -141,8 +131,8 @@ sourceUnfoldrMN upto start = S.unfoldrM step start

141 else return (Just (cnt, cnt + 1))

131 else return (Just (cnt, cnt + 1))

142

132

143{-# INLINE sourceUnfoldrMAction #-}

133{-# INLINE sourceUnfoldrMAction #-}

144−sourceUnfoldrMAction :: (S.IsStream t, S.MonadAsync m) => Int -> t m (m Int)

134+sourceUnfoldrMAction :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (m Int)

145−sourceUnfoldrMAction n = S.serially $ S.unfoldrM step n

135+sourceUnfoldrMAction value n = S.serially $ S.unfoldrM step n

146 where

136 where

147 step cnt =

137 step cnt =

148 if cnt > n + value

138 if cnt > n + value

@@ -152,40 +142,40 @@ sourceUnfoldrMAction n = S.serially $ S.unfoldrM step n

152-- fromIndices

142-- fromIndices

153

143

154{-# INLINE sourceFromIndices #-}

144{-# INLINE sourceFromIndices #-}

155−sourceFromIndices :: (Monad m, S.IsStream t) => Int -> t m Int

145+sourceFromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

156−sourceFromIndices n = S.take value $ S.fromIndices (+ n)

146+sourceFromIndices value n = S.take value $ S.fromIndices (+ n)

157

147

158{-# INLINE sourceFromIndicesM #-}

148{-# INLINE sourceFromIndicesM #-}

159−sourceFromIndicesM :: (S.MonadAsync m, S.IsStream t) => Int -> t m Int

149+sourceFromIndicesM :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

160−sourceFromIndicesM n = S.take value $ S.fromIndicesM (Prelude.fmap return (+ n))

150+sourceFromIndicesM value n = S.take value $ S.fromIndicesM (Prelude.fmap return (+ n))

161

151

162-- fromList

152-- fromList

163

153

164{-# INLINE sourceFromList #-}

154{-# INLINE sourceFromList #-}

165−sourceFromList :: (Monad m, S.IsStream t) => Int -> t m Int

155+sourceFromList :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

166−sourceFromList n = S.fromList [n..n+value]

156+sourceFromList value n = S.fromList [n..n+value]

167

157

168{-# INLINE sourceFromListM #-}

158{-# INLINE sourceFromListM #-}

169−sourceFromListM :: (S.MonadAsync m, S.IsStream t) => Int -> t m Int

159+sourceFromListM :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

170−sourceFromListM n = S.fromListM (Prelude.fmap return [n..n+value])

160+sourceFromListM value n = S.fromListM (Prelude.fmap return [n..n+value])

171

161

172{-# INLINE sourceIsList #-}

162{-# INLINE sourceIsList #-}

173−sourceIsList :: Int -> S.SerialT Identity Int

163+sourceIsList :: Int -> Int -> S.SerialT Identity Int

174−sourceIsList n = GHC.fromList [n..n+value]

164+sourceIsList value n = GHC.fromList [n..n+value]

175

165

176{-# INLINE sourceIsString #-}

166{-# INLINE sourceIsString #-}

177−sourceIsString :: Int -> S.SerialT Identity P.Char

167+sourceIsString :: Int -> Int -> S.SerialT Identity P.Char

178−sourceIsString n = GHC.fromString (P.replicate (n + value) 'a')

168+sourceIsString value n = GHC.fromString (P.replicate (n + value) 'a')

179

169

180-- fromFoldable

170-- fromFoldable

181

171

182{-# INLINE sourceFromFoldable #-}

172{-# INLINE sourceFromFoldable #-}

183−sourceFromFoldable :: S.IsStream t => Int -> t m Int

173+sourceFromFoldable :: S.IsStream t => Int -> Int -> t m Int

184−sourceFromFoldable n = S.fromFoldable [n..n+value]

174+sourceFromFoldable value n = S.fromFoldable [n..n+value]

185

175

186{-# INLINE sourceFromFoldableM #-}

176{-# INLINE sourceFromFoldableM #-}

187−sourceFromFoldableM :: (S.IsStream t, S.MonadAsync m) => Int -> t m Int

177+sourceFromFoldableM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int

188−sourceFromFoldableM n = S.fromFoldableM (Prelude.fmap return [n..n+value])

178+sourceFromFoldableM value n = S.fromFoldableM (Prelude.fmap return [n..n+value])

189

179

190-------------------------------------------------------------------------------

180-------------------------------------------------------------------------------

191-- Elimination

181-- Elimination

@@ -206,9 +196,12 @@ toList :: Monad m => Stream m Int -> m [Int]

206{-# INLINE findIndex #-}

196{-# INLINE findIndex #-}

207{-# INLINE elemIndex #-}

197{-# INLINE elemIndex #-}

208{-# INLINE foldl1'Reduce #-}

198{-# INLINE foldl1'Reduce #-}

209−head, last, minimum, maximum, find, findIndex, elemIndex, foldl1'Reduce

199+head, last, minimum, maximum, foldl1'Reduce

210 :: Monad m => Stream m Int -> m (Maybe Int)

200 :: Monad m => Stream m Int -> m (Maybe Int)

211

201

202+find, findIndex, elemIndex

203+ :: Monad m => Int -> Stream m Int -> m (Maybe Int)

204+

212{-# INLINE minimumBy #-}

205{-# INLINE minimumBy #-}

213{-# INLINE maximumBy #-}

206{-# INLINE maximumBy #-}

214minimumBy, maximumBy :: Monad m => Stream m Int -> m (Maybe Int)

207minimumBy, maximumBy :: Monad m => Stream m Int -> m (Maybe Int)

@@ -238,7 +231,9 @@ foldrMBuild, foldl'Build, foldlM'Build

238{-# INLINE null #-}

231{-# INLINE null #-}

239{-# INLINE elem #-}

232{-# INLINE elem #-}

240{-# INLINE notElem #-}

233{-# INLINE notElem #-}

234+null :: Monad m => Stream m Int -> m Bool

235+

241−null, elem, notElem, all, any, and, or :: Monad m => Stream m Int -> m Bool

236+elem, notElem, all, any, and, or :: Monad m => Int -> Stream m Int -> m Bool

242

237

243{-# INLINE toNull #-}

238{-# INLINE toNull #-}

244toNull :: Monad m => (t m a -> S.SerialT m a) -> t m a -> m ()

239toNull :: Monad m => (t m a -> S.SerialT m a) -> t m a -> m ()

@@ -291,16 +286,16 @@ foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) 0

291last = S.last

286last = S.last

292null = S.null

287null = S.null

293head = S.head

288head = S.head

294−elem = S.elem maxValue

289+elem value = S.elem (value + 1)

295−notElem = S.notElem maxValue

290+notElem value = S.notElem (value + 1)

296length = S.length

291length = S.length

297−all = S.all (<= maxValue)

292+all value = S.all (<= (value + 1))

298−any = S.any (> maxValue)

293+any value = S.any (> (value + 1))

299−and = S.and . S.map (<= maxValue)

294+and value = S.and . S.map (<= (value + 1))

300−or = S.or . S.map (> maxValue)

295+or value = S.or . S.map (> (value + 1))

301−find = S.find (== maxValue)

296+find value = S.find (== (value + 1))

302−findIndex = S.findIndex (== maxValue)

297+findIndex value = S.findIndex (== (value + 1))

303−elemIndex = S.elemIndex maxValue

298+elemIndex value = S.elemIndex (value + 1)

304maximum = S.maximum

299maximum = S.maximum

305minimum = S.minimum

300minimum = S.minimum

306sum = S.sum

301sum = S.sum

@@ -368,17 +363,24 @@ composeN' n f =

368{-# INLINE foldrSMap #-}

363{-# INLINE foldrSMap #-}

369{-# INLINE foldrT #-}

364{-# INLINE foldrT #-}

370{-# INLINE foldrTMap #-}

365{-# INLINE foldrTMap #-}

371−scan, scanl1', map, fmap, mapMaybe, filterEven, filterAllOut,

366+scan, scanl1', map, fmap, mapMaybe, filterEven,

372− filterAllIn, takeOne, takeAll, takeWhileTrue, takeWhileMTrue, dropOne,

367+ takeOne, dropOne,

373− dropAll, dropWhileTrue, dropWhileMTrue, dropWhileFalse,

374− findIndices, elemIndices, insertBy, deleteBy, reverse, reverse',

368+ reverse, reverse',

375 foldrS, foldrSMap, foldrT, foldrTMap

369 foldrS, foldrSMap, foldrT, foldrTMap

376 :: MonadIO m

370 :: MonadIO m

377 => Int -> Stream m Int -> m ()

371 => Int -> Stream m Int -> m ()

378

372

373+filterAllOut,

374+ filterAllIn, takeAll, takeWhileTrue, takeWhileMTrue,

375+ dropAll, dropWhileTrue, dropWhileMTrue, dropWhileFalse,

376+ findIndices, elemIndices, insertBy, deleteBy

377+ :: MonadIO m

378+ => Int -> Int -> Stream m Int -> m ()

379+

379{-# INLINE mapMaybeM #-}

380{-# INLINE mapMaybeM #-}

380{-# INLINE intersperse #-}

381{-# INLINE intersperse #-}

382+mapMaybeM :: S.MonadAsync m => Int -> Stream m Int -> m ()

381−mapMaybeM, intersperse :: S.MonadAsync m => Int -> Stream m Int -> m ()

383+intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()

382

384

383{-# INLINE mapM #-}

385{-# INLINE mapM #-}

384{-# INLINE map' #-}

386{-# INLINE map' #-}

@@ -431,22 +433,22 @@ mapMaybeM n = composeN n $ S.mapMaybeM

431 (\x -> if Prelude.odd x then return Nothing else return $ Just x)

433 (\x -> if Prelude.odd x then return Nothing else return $ Just x)

432sequence t = transform . t . S.sequence

434sequence t = transform . t . S.sequence

433filterEven n = composeN n $ S.filter even

435filterEven n = composeN n $ S.filter even

434−filterAllOut n = composeN n $ S.filter (> maxValue)

436+filterAllOut value n = composeN n $ S.filter (> (value + 1))

435−filterAllIn n = composeN n $ S.filter (<= maxValue)

437+filterAllIn value n = composeN n $ S.filter (<= (value + 1))

436takeOne n = composeN n $ S.take 1

438takeOne n = composeN n $ S.take 1

437−takeAll n = composeN n $ S.take maxValue

439+takeAll value n = composeN n $ S.take (value + 1)

438−takeWhileTrue n = composeN n $ S.takeWhile (<= maxValue)

440+takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))

439−takeWhileMTrue n = composeN n $ S.takeWhileM (return . (<= maxValue))

441+takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))

440dropOne n = composeN n $ S.drop 1

442dropOne n = composeN n $ S.drop 1

441−dropAll n = composeN n $ S.drop maxValue

443+dropAll value n = composeN n $ S.drop (value + 1)

442−dropWhileTrue n = composeN n $ S.dropWhile (<= maxValue)

444+dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))

443−dropWhileMTrue n = composeN n $ S.dropWhileM (return . (<= maxValue))

445+dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))

444−dropWhileFalse n = composeN n $ S.dropWhile (> maxValue)

446+dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))

445−findIndices n = composeN n $ S.findIndices (== maxValue)

447+findIndices value n = composeN n $ S.findIndices (== (value + 1))

446−elemIndices n = composeN n $ S.elemIndices maxValue

448+elemIndices value n = composeN n $ S.elemIndices (value + 1)

447−intersperse n = composeN n $ S.intersperse maxValue

449+intersperse value n = composeN n $ S.intersperse (value + 1)

448−insertBy n = composeN n $ S.insertBy compare maxValue

450+insertBy value n = composeN n $ S.insertBy compare (value + 1)

449−deleteBy n = composeN n $ S.deleteBy (>=) maxValue

451+deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)

450reverse n = composeN n $ S.reverse

452reverse n = composeN n $ S.reverse

451reverse' n = composeN n $ Internal.reverse'

453reverse' n = composeN n $ Internal.reverse'

452foldrS n = composeN n $ Internal.foldrS S.cons S.nil

454foldrS n = composeN n $ Internal.foldrS S.cons S.nil

@@ -493,21 +495,25 @@ transformZipMapM t n = composeN' n $ t . Internal.transform

493{-# INLINE filterScan #-}

495{-# INLINE filterScan #-}

494{-# INLINE filterScanl1 #-}

496{-# INLINE filterScanl1 #-}

495{-# INLINE filterMap #-}

497{-# INLINE filterMap #-}

496−scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,

498+scanMap, dropMap, dropScan,

497− filterTake, filterScan, filterScanl1, filterMap

499+ filterScan, filterScanl1

498 :: MonadIO m => Int -> Stream m Int -> m ()

500 :: MonadIO m => Int -> Stream m Int -> m ()

499

501

502+takeDrop, takeScan, takeMap, filterDrop,

503+ filterTake, filterMap

504+ :: MonadIO m => Int -> Int -> Stream m Int -> m ()

505+

500scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0

506scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0

501dropMap n = composeN n $ S.map (subtract 1) . S.drop 1

507dropMap n = composeN n $ S.map (subtract 1) . S.drop 1

502dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1

508dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1

503−takeDrop n = composeN n $ S.drop 1 . S.take maxValue

509+takeDrop value n = composeN n $ S.drop 1 . S.take (value + 1)

504−takeScan n = composeN n $ S.scanl' (+) 0 . S.take maxValue

510+takeScan value n = composeN n $ S.scanl' (+) 0 . S.take (value + 1)

505−takeMap n = composeN n $ S.map (subtract 1) . S.take maxValue

511+takeMap value n = composeN n $ S.map (subtract 1) . S.take (value + 1)

506−filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)

512+filterDrop value n = composeN n $ S.drop 1 . S.filter (<= (value + 1))

507−filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)

513+filterTake value n = composeN n $ S.take (value + 1) . S.filter (<= (value + 1))

508filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)

514filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)

509filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)

515filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)

510−filterMap n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)

516+filterMap value n = composeN n $ S.map (subtract 1) . S.filter (<= (value + 1))

511

517

512-------------------------------------------------------------------------------

518-------------------------------------------------------------------------------

513-- Scan and fold

519-- Scan and fold

@@ -549,11 +555,16 @@ iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)

549{-# INLINE iterateDropOne #-}

555{-# INLINE iterateDropOne #-}

550{-# INLINE iterateDropWhileFalse #-}

556{-# INLINE iterateDropWhileFalse #-}

551{-# INLINE iterateDropWhileTrue #-}

557{-# INLINE iterateDropWhileTrue #-}

552−iterateMapM, iterateScan, iterateScanl1, iterateFilterEven, iterateTakeAll,

558+iterateMapM, iterateScan, iterateScanl1, iterateFilterEven,

553− iterateDropOne, iterateDropWhileFalse, iterateDropWhileTrue

559+ iterateDropOne

554 :: S.MonadAsync m

560 :: S.MonadAsync m

555 => Int -> Stream m Int

561 => Int -> Stream m Int

556

562

563+iterateTakeAll,

564+ iterateDropWhileFalse, iterateDropWhileTrue

565+ :: S.MonadAsync m

566+ => Int -> Int -> Stream m Int

567+

557-- this is quadratic

568-- this is quadratic

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

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

559-- so is this

570-- so is this

@@ -561,10 +572,10 @@ iterateScanl1 = iterateSource (S.scanl1' (+)) (maxIters `div` 10)

561

572

562iterateMapM = iterateSource (S.mapM return) maxIters

573iterateMapM = iterateSource (S.mapM return) maxIters

563iterateFilterEven = iterateSource (S.filter even) maxIters

574iterateFilterEven = iterateSource (S.filter even) maxIters

564−iterateTakeAll = iterateSource (S.take maxValue) maxIters

575+iterateTakeAll value = iterateSource (S.take (value + 1)) maxIters

565iterateDropOne = iterateSource (S.drop 1) maxIters

576iterateDropOne = iterateSource (S.drop 1) maxIters

566−iterateDropWhileFalse = iterateSource (S.dropWhile (> maxValue)) maxIters

577+iterateDropWhileFalse value = iterateSource (S.dropWhile (> (value + 1))) maxIters

567−iterateDropWhileTrue = iterateSource (S.dropWhile (<= maxValue)) maxIters

578+iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1))) maxIters

568

579

569-------------------------------------------------------------------------------

580-------------------------------------------------------------------------------

570-- Combining streams

581-- Combining streams

@@ -616,14 +627,14 @@ inspect $ 'append2 `hasNoType` ''D.AppendState

616-------------------------------------------------------------------------------

627-------------------------------------------------------------------------------

617

628

618{-# INLINE wSerial2 #-}

629{-# INLINE wSerial2 #-}

619−wSerial2 :: Int -> IO ()

630+wSerial2 :: Int -> Int -> IO ()

620−wSerial2 n = S.drain $ S.wSerial

631+wSerial2 value n = S.drain $ S.wSerial

621 (sourceUnfoldrMN (value `div` 2) n)

632 (sourceUnfoldrMN (value `div` 2) n)

622 (sourceUnfoldrMN (value `div` 2) (n + 1))

633 (sourceUnfoldrMN (value `div` 2) (n + 1))

623

634

624{-# INLINE interleave2 #-}

635{-# INLINE interleave2 #-}

625−interleave2 :: Int -> IO ()

636+interleave2 :: Int -> Int -> IO ()

626−interleave2 n = S.drain $ Internal.interleave

637+interleave2 value n = S.drain $ Internal.interleave

627 (sourceUnfoldrMN (value `div` 2) n)

638 (sourceUnfoldrMN (value `div` 2) n)

628 (sourceUnfoldrMN (value `div` 2) (n + 1))

639 (sourceUnfoldrMN (value `div` 2) (n + 1))

629

640

@@ -633,8 +644,8 @@ inspect $ 'interleave2 `hasNoType` ''D.InterleaveState

633#endif

644#endif

634

645

635{-# INLINE roundRobin2 #-}

646{-# INLINE roundRobin2 #-}

636−roundRobin2 :: Int -> IO ()

647+roundRobin2 :: Int -> Int -> IO ()

637−roundRobin2 n = S.drain $ Internal.roundrobin

648+roundRobin2 value n = S.drain $ Internal.roundrobin

638 (sourceUnfoldrMN (value `div` 2) n)

649 (sourceUnfoldrMN (value `div` 2) n)

639 (sourceUnfoldrMN (value `div` 2) (n + 1))

650 (sourceUnfoldrMN (value `div` 2) (n + 1))

640

651

@@ -730,8 +741,8 @@ eqBy' :: (Monad m, P.Eq a) => Stream m a -> m P.Bool

730eqBy' src = S.eqBy (==) src src

741eqBy' src = S.eqBy (==) src src

731

742

732{-# INLINE eqBy #-}

743{-# INLINE eqBy #-}

733−eqBy :: Int -> IO Bool

744+eqBy :: Int -> Int -> IO Bool

734−eqBy n = eqBy' (source n)

745+eqBy value n = eqBy' (source value n)

735

746

736#ifdef INSPECTION

747#ifdef INSPECTION

737inspect $ hasNoTypeClasses 'eqBy

748inspect $ hasNoTypeClasses 'eqBy

@@ -740,8 +751,8 @@ inspect $ 'eqBy `hasNoType` ''D.Step

740

751

741

752

742{-# INLINE eqByPure #-}

753{-# INLINE eqByPure #-}

743−eqByPure :: Int -> Identity Bool

754+eqByPure :: Int -> Int -> Identity Bool

744−eqByPure n = eqBy' (sourceUnfoldr n)

755+eqByPure value n = eqBy' (sourceUnfoldr value n)

745

756

746#ifdef INSPECTION

757#ifdef INSPECTION

747inspect $ hasNoTypeClasses 'eqByPure

758inspect $ hasNoTypeClasses 'eqByPure

@@ -753,8 +764,8 @@ cmpBy' :: (Monad m, P.Ord a) => Stream m a -> m P.Ordering

753cmpBy' src = S.cmpBy P.compare src src

764cmpBy' src = S.cmpBy P.compare src src

754

765

755{-# INLINE cmpBy #-}

766{-# INLINE cmpBy #-}

756−cmpBy :: Int -> IO P.Ordering

767+cmpBy :: Int -> Int -> IO P.Ordering

757−cmpBy n = cmpBy' (source n)

768+cmpBy value n = cmpBy' (source value n)

758

769

759#ifdef INSPECTION

770#ifdef INSPECTION

760inspect $ hasNoTypeClasses 'cmpBy

771inspect $ hasNoTypeClasses 'cmpBy

@@ -762,8 +773,8 @@ inspect $ 'cmpBy `hasNoType` ''D.Step

762#endif

773#endif

763

774

764{-# INLINE cmpByPure #-}

775{-# INLINE cmpByPure #-}

765−cmpByPure :: Int -> Identity P.Ordering

776+cmpByPure :: Int -> Int -> Identity P.Ordering

766−cmpByPure n = cmpBy' (sourceUnfoldr n)

777+cmpByPure value n = cmpBy' (sourceUnfoldr value n)

767

778

768#ifdef INSPECTION

779#ifdef INSPECTION

769inspect $ hasNoTypeClasses 'cmpByPure

780inspect $ hasNoTypeClasses 'cmpByPure

@@ -778,23 +789,23 @@ inspect $ 'cmpByPure `hasNoType` ''D.Step

778

789

779{-# INLINE sourceFoldMapWith #-}

790{-# INLINE sourceFoldMapWith #-}

780sourceFoldMapWith :: (S.IsStream t, S.Semigroup (t m Int))

791sourceFoldMapWith :: (S.IsStream t, S.Semigroup (t m Int))

781− => Int -> t m Int

792+ => Int -> Int -> t m Int

782−sourceFoldMapWith n = S.foldMapWith (S.<>) S.yield [n..n+value]

793+sourceFoldMapWith value n = S.foldMapWith (S.<>) S.yield [n..n+value]

783

794

784{-# INLINE sourceFoldMapWithM #-}

795{-# INLINE sourceFoldMapWithM #-}

785sourceFoldMapWithM :: (S.IsStream t, Monad m, S.Semigroup (t m Int))

796sourceFoldMapWithM :: (S.IsStream t, Monad m, S.Semigroup (t m Int))

786− => Int -> t m Int

797+ => Int -> Int -> t m Int

787−sourceFoldMapWithM n = S.foldMapWith (S.<>) (S.yieldM . return) [n..n+value]

798+sourceFoldMapWithM value n = S.foldMapWith (S.<>) (S.yieldM . return) [n..n+value]

788

799

789{-# INLINE sourceFoldMapM #-}

800{-# INLINE sourceFoldMapM #-}

790sourceFoldMapM :: (S.IsStream t, Monad m, P.Monoid (t m Int))

801sourceFoldMapM :: (S.IsStream t, Monad m, P.Monoid (t m Int))

791− => Int -> t m Int

802+ => Int -> Int -> t m Int

792−sourceFoldMapM n = F.foldMap (S.yieldM . return) [n..n+value]

803+sourceFoldMapM value n = F.foldMap (S.yieldM . return) [n..n+value]

793

804

794{-# INLINE sourceConcatMapId #-}

805{-# INLINE sourceConcatMapId #-}

795sourceConcatMapId :: (S.IsStream t, Monad m)

806sourceConcatMapId :: (S.IsStream t, Monad m)

796− => Int -> t m Int

807+ => Int -> Int -> t m Int

797−sourceConcatMapId n =

808+sourceConcatMapId value n =

798 S.concatMap P.id $ S.fromFoldable $ P.map (S.yieldM . return) [n..n+value]

809 S.concatMap P.id $ S.fromFoldable $ P.map (S.yieldM . return) [n..n+value]

799

810

800-- concatMap unfoldrM/unfoldrM

811-- concatMap unfoldrM/unfoldrM

@@ -826,8 +837,8 @@ inspect $ hasNoTypeClasses 'concatMapPure

826-- concatMap replicate/unfoldrM

837-- concatMap replicate/unfoldrM

827

838

828{-# INLINE concatMapRepl4xN #-}

839{-# INLINE concatMapRepl4xN #-}

829−concatMapRepl4xN :: Int -> IO ()

840+concatMapRepl4xN :: Int -> Int -> IO ()

830−concatMapRepl4xN n = S.drain $ S.concatMap (S.replicate 4)

841+concatMapRepl4xN value n = S.drain $ S.concatMap (S.replicate 4)

831 (sourceUnfoldrMN (value `div` 4) n)

842 (sourceUnfoldrMN (value `div` 4) n)

832

843

833#ifdef INSPECTION

844#ifdef INSPECTION

@@ -877,8 +888,8 @@ inspect $ hasNoTypeClasses 'concatMapWithWSerial

877-- concatUnfold replicate/unfoldrM

888-- concatUnfold replicate/unfoldrM

878

889

879{-# INLINE concatUnfoldRepl4xN #-}

890{-# INLINE concatUnfoldRepl4xN #-}

880−concatUnfoldRepl4xN :: Int -> IO ()

891+concatUnfoldRepl4xN :: Int -> Int -> IO ()

881−concatUnfoldRepl4xN n =

892+concatUnfoldRepl4xN value n =

882 S.drain $ S.concatUnfold

893 S.drain $ S.concatUnfold

883 (UF.replicateM 4)

894 (UF.replicateM 4)

884 (sourceUnfoldrMN (value `div` 4) n)

895 (sourceUnfoldrMN (value `div` 4) n)

@@ -889,8 +900,8 @@ inspect $ 'concatUnfoldRepl4xN `hasNoType` ''D.ConcatMapUState

889#endif

900#endif

890

901

891{-# INLINE concatUnfoldInterleaveRepl4xN #-}

902{-# INLINE concatUnfoldInterleaveRepl4xN #-}

892−concatUnfoldInterleaveRepl4xN :: Int -> IO ()

903+concatUnfoldInterleaveRepl4xN :: Int -> Int -> IO ()

893−concatUnfoldInterleaveRepl4xN n =

904+concatUnfoldInterleaveRepl4xN value n =

894 S.drain $ Internal.concatUnfoldInterleave

905 S.drain $ Internal.concatUnfoldInterleave

895 (UF.replicateM 4)

906 (UF.replicateM 4)

896 (sourceUnfoldrMN (value `div` 4) n)

907 (sourceUnfoldrMN (value `div` 4) n)

@@ -901,8 +912,8 @@ inspect $ hasNoTypeClasses 'concatUnfoldInterleaveRepl4xN

901#endif

912#endif

902

913

903{-# INLINE concatUnfoldRoundrobinRepl4xN #-}

914{-# INLINE concatUnfoldRoundrobinRepl4xN #-}

904−concatUnfoldRoundrobinRepl4xN :: Int -> IO ()

915+concatUnfoldRoundrobinRepl4xN :: Int -> Int -> IO ()

905−concatUnfoldRoundrobinRepl4xN n =

916+concatUnfoldRoundrobinRepl4xN value n =

906 S.drain $ Internal.concatUnfoldRoundrobin

917 S.drain $ Internal.concatUnfoldRoundrobin

907 (UF.replicateM 4)

918 (UF.replicateM 4)

908 (sourceUnfoldrMN (value `div` 4) n)

919 (sourceUnfoldrMN (value `div` 4) n)

@@ -918,8 +929,8 @@ inspect $ hasNoTypeClasses 'concatUnfoldRoundrobinRepl4xN

918

929

919{-# INLINE sourceUnfoldrState #-}

930{-# INLINE sourceUnfoldrState #-}

920sourceUnfoldrState :: (S.IsStream t, S.MonadAsync m)

931sourceUnfoldrState :: (S.IsStream t, S.MonadAsync m)

921− => Int -> t (StateT Int m) Int

932+ => Int -> Int -> t (StateT Int m) Int

922−sourceUnfoldrState n = S.unfoldrM step n

933+sourceUnfoldrState value n = S.unfoldrM step n

923 where

934 where

924 step cnt =

935 step cnt =

925 if cnt > n + value

936 if cnt > n + value

@@ -930,13 +941,13 @@ sourceUnfoldrState n = S.unfoldrM step n

930 return (Just (s, cnt + 1))

941 return (Just (s, cnt + 1))

931

942

932{-# INLINE evalStateT #-}

943{-# INLINE evalStateT #-}

933−evalStateT :: S.MonadAsync m => Int -> Stream m Int

944+evalStateT :: S.MonadAsync m => Int -> Int -> Stream m Int

934−evalStateT n = Internal.evalStateT 0 (sourceUnfoldrState n)

945+evalStateT value n = Internal.evalStateT 0 (sourceUnfoldrState value n)

935

946

936{-# INLINE withState #-}

947{-# INLINE withState #-}

937−withState :: S.MonadAsync m => Int -> Stream m Int

948+withState :: S.MonadAsync m => Int -> Int -> Stream m Int

938−withState n =

949+withState value n =

939− Internal.evalStateT (0 :: Int) (Internal.liftInner (sourceUnfoldrM n))

950+ Internal.evalStateT (0 :: Int) (Internal.liftInner (sourceUnfoldrM value n))

940

951

941-------------------------------------------------------------------------------

952-------------------------------------------------------------------------------

942-- Concurrent application/fold

953-- Concurrent application/fold

streamly.cabal+9−45

@@ -584,6 +584,15 @@ test-suite parallel-loops

584-- Benchmarks

585-------------------------------------------------------------------------------

586

587+-- NOTE :

588+-- For linear, linear-async and linear-rate if you want to pass the number

589+-- of stream elements for benchmarking then you can pass it as the first

590+-- argument after `--`, as a gauge argument. If you don't give the argument,

591+-- the number of stream elements default to 100000.

592+-- Examples:

593+-- $ cabal run linear -- 1000000 [additional gauge options here...]

594+-- $ cabal run linear -- [additional gauge options here...]

595+

587benchmark linear

596benchmark linear

588 import: bench-options

597 import: bench-options

589 type: exitcode-stdio-1.0

598 type: exitcode-stdio-1.0

@@ -603,26 +612,6 @@ benchmark linear

603 build-depends: template-haskell >= 2.14 && < 2.16

612 build-depends: template-haskell >= 2.14 && < 2.16

604 , inspection-testing >= 0.4 && < 0.5

613 , inspection-testing >= 0.4 && < 0.5

605

614

606−benchmark linear-long

607− import: bench-options-threaded

608− type: exitcode-stdio-1.0

609− cpp-options: -DLONG_BENCHMARKS

610− hs-source-dirs: benchmark

611− main-is: Linear.hs

612− other-modules: Streamly.Benchmark.Prelude

613− build-depends:

614− streamly

615− , base >= 4.8 && < 5

616− , deepseq >= 1.4.1 && < 1.5

617− , random >= 1.0 && < 2.0

618− , gauge >= 0.2.4 && < 0.3

619− if impl(ghc < 8.0)

620− build-depends:

621− transformers >= 0.4 && < 0.6

622− if flag(inspection)

623− build-depends: template-haskell >= 2.14 && < 2.16

624− , inspection-testing >= 0.4 && < 0.5

625−

626benchmark nested

615benchmark nested

627 import: bench-options

616 import: bench-options

628 type: exitcode-stdio-1.0

617 type: exitcode-stdio-1.0

@@ -729,7 +718,6 @@ benchmark fileio

729

718

730benchmark linear-async

719benchmark linear-async

731 import: bench-options-threaded

720 import: bench-options-threaded

732− cpp-options: -DLINEAR_ASYNC

733 type: exitcode-stdio-1.0

721 type: exitcode-stdio-1.0

734 hs-source-dirs: benchmark

722 hs-source-dirs: benchmark

735 main-is: LinearAsync.hs

723 main-is: LinearAsync.hs

@@ -747,30 +735,6 @@ benchmark linear-async

747 build-depends: template-haskell >= 2.14 && < 2.16

735 build-depends: template-haskell >= 2.14 && < 2.16

748 , inspection-testing >= 0.4 && < 0.5

736 , inspection-testing >= 0.4 && < 0.5

749

737

750−benchmark linear-async-long

751− import: bench-options-threaded

752− cpp-options: -DLONG_BENCHMARKS

753− type: exitcode-stdio-1.0

754− hs-source-dirs: benchmark

755− main-is: LinearAsync.hs

756− other-modules: Streamly.Benchmark.Prelude

757− if flag(dev)

758− buildable: True

759− build-depends:

760− streamly

761− , base >= 4.8 && < 5

762− , deepseq >= 1.4.1 && < 1.5

763− , random >= 1.0 && < 2.0

764− , gauge >= 0.2.4 && < 0.3

765− if impl(ghc < 8.0)

766− build-depends:

767− transformers >= 0.4 && < 0.6

768− if flag(inspection)

769− build-depends: template-haskell >= 2.14 && < 2.16

770− , inspection-testing >= 0.4 && < 0.5

771− else

772− buildable: False

773−

774benchmark nested-concurrent

738benchmark nested-concurrent

775 import: bench-options-threaded

739 import: bench-options-threaded

776 type: exitcode-stdio-1.0

740 type: exitcode-stdio-1.0