Skip to content

Commit 9c174b7

Browse files
adithyaovadithyaov
committed
Use the newer APIs
1 parent b9f8d03 commit 9c174b7

8 files changed

Lines changed: 46 additions & 46 deletions

File tree

‎Benchmarks/Drinkery.hs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ scan, map, mapM,
9191
dropOne, dropAll, dropWhileTrue, dropWhileFalse
9292
:: Monad m => Int -> Source m () Int -> m ()
9393

94-
scan n = composeN n $ S.scan (+) 0
94+
scan n = composeN n $ S.scanl (+) 0
9595
map n = composeN n $ S.map (+1)
9696
mapM n = composeN n $ S.traverse return
9797
filterEven n = composeN n $ S.filter even
@@ -123,15 +123,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
123123
filterTake, filterScan, filterMap
124124
:: Monad m => Int -> Source m () Int -> m ()
125125

126-
scanMap n = composeN n $ S.map (subtract 1) S.++$ S.scan (+) 0
126+
scanMap n = composeN n $ S.map (subtract 1) S.++$ S.scanl (+) 0
127127
dropMap n = composeN n $ S.map (subtract 1) S.++$ S.drop 1
128-
dropScan n = composeN n $ S.scan (+) 0 S.++$ S.drop 1
128+
dropScan n = composeN n $ S.scanl (+) 0 S.++$ S.drop 1
129129
takeDrop n = composeN n $ S.drop 1 S.++$ S.take maxValue
130-
takeScan n = composeN n $ S.scan (+) 0 S.++$ S.take maxValue
130+
takeScan n = composeN n $ S.scanl (+) 0 S.++$ S.take maxValue
131131
takeMap n = composeN n $ S.map (subtract 1) S.++$ S.take maxValue
132132
filterDrop n = composeN n $ S.drop 1 S.++$ S.filter (<= maxValue)
133133
filterTake n = composeN n $ S.take maxValue S.++$ S.filter (<= maxValue)
134-
filterScan n = composeN n $ S.scan (+) 0 S.++$ S.filter (<= maxBound)
134+
filterScan n = composeN n $ S.scanl (+) 0 S.++$ S.filter (<= maxBound)
135135
filterMap n = composeN n $ S.map (subtract 1) S.++$ S.filter (<= maxValue)
136136

137137
-------------------------------------------------------------------------------

‎Benchmarks/Machines.hs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ scan, map, mapM,
109109
dropOne, dropAll, dropWhileTrue, dropWhileFalse
110110
:: Monad m => Int -> S.MachineT m k Int -> m ()
111111

112-
scan n = composeN n $ S.scan (+) 0
112+
scan n = composeN n $ S.scanl (+) 0
113113
map n = composeN n $ S.mapping (+1)
114114
mapM n = composeN n $ S.autoM return
115115
filterEven n = composeN n $ S.filtered even
@@ -141,15 +141,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
141141
filterTake, filterScan, filterMap
142142
:: Monad m => Int -> S.MachineT m k Int -> m ()
143143

144-
scanMap n = composeN n $ S.mapping (subtract 1) S.~> S.scan (+) 0
144+
scanMap n = composeN n $ S.mapping (subtract 1) S.~> S.scanl (+) 0
145145
dropMap n = composeN n $ S.mapping (subtract 1) S.~> S.dropping 1
146-
dropScan n = composeN n $ S.scan (+) 0 S.~> S.dropping 1
146+
dropScan n = composeN n $ S.scanl (+) 0 S.~> S.dropping 1
147147
takeDrop n = composeN n $ S.dropping 1 S.~> S.taking maxValue
148-
takeScan n = composeN n $ S.scan (+) 0 S.~> S.taking maxValue
148+
takeScan n = composeN n $ S.scanl (+) 0 S.~> S.taking maxValue
149149
takeMap n = composeN n $ S.mapping (subtract 1) S.~> S.taking maxValue
150150
filterDrop n = composeN n $ S.dropping 1 S.~> S.filtered (<= maxValue)
151151
filterTake n = composeN n $ S.taking maxValue S.~> S.filtered (<= maxValue)
152-
filterScan n = composeN n $ S.scan (+) 0 S.~> S.filtered (<= maxBound)
152+
filterScan n = composeN n $ S.scanl (+) 0 S.~> S.filtered (<= maxBound)
153153
filterMap n = composeN n $ S.mapping (subtract 1) S.~> S.filtered (<= maxValue)
154154

155155
-------------------------------------------------------------------------------

‎Benchmarks/Pipes.hs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ scan, map, mapM,
109109
dropOne, dropAll, dropWhileTrue, dropWhileFalse
110110
:: Monad m => Int -> Source m () Int -> m ()
111111

112-
scan n = composeN n $ S.scan (+) 0 id
112+
scan n = composeN n $ S.scanl (+) 0 id
113113
map n = composeN n $ S.map (+1)
114114
mapM n = composeN n $ S.mapM return
115115
filterEven n = composeN n $ S.filter even
@@ -141,15 +141,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
141141
filterTake, filterScan, filterMap
142142
:: Monad m => Int -> Source m () Int -> m ()
143143

144-
scanMap n = composeN n $ S.map (subtract 1) S.>-> S.scan (+) 0 id
144+
scanMap n = composeN n $ S.map (subtract 1) S.>-> S.scanl (+) 0 id
145145
dropMap n = composeN n $ S.map (subtract 1) S.>-> S.drop 1
146-
dropScan n = composeN n $ S.scan (+) 0 id S.>-> S.drop 1
146+
dropScan n = composeN n $ S.scanl (+) 0 id S.>-> S.drop 1
147147
takeDrop n = composeN n $ S.drop 1 S.>-> S.take maxValue
148-
takeScan n = composeN n $ S.scan (+) 0 id S.>-> S.take maxValue
148+
takeScan n = composeN n $ S.scanl (+) 0 id S.>-> S.take maxValue
149149
takeMap n = composeN n $ S.map (subtract 1) S.>-> S.take maxValue
150150
filterDrop n = composeN n $ S.drop 1 S.>-> S.filter (<= maxValue)
151151
filterTake n = composeN n $ S.take maxValue S.>-> S.filter (<= maxValue)
152-
filterScan n = composeN n $ S.scan (+) 0 id S.>-> S.filter (<= maxBound)
152+
filterScan n = composeN n $ S.scanl (+) 0 id S.>-> S.filter (<= maxBound)
153153
filterMap n = composeN n $ S.map (subtract 1) S.>-> S.filter (<= maxValue)
154154

155155
-------------------------------------------------------------------------------

‎Benchmarks/SimpleConduit.hs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ last = eliminate $ S.last
6060
transform :: Monad m => (Stream m Int -> Stream m a) -> Int -> m ()
6161
transform f = runStream . f . source
6262

63-
scan = transform $ S.scan (+) 0 id
63+
scan = transform $ S.scanl (+) 0 id
6464
map = transform $ fmap (+1)
6565
mapM = transform $ S.mapM return
6666
filterEven = transform $ S.filter even

‎Benchmarks/Streaming.hs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ scan, map, mapM,
116116
dropOne, dropAll, dropWhileTrue, dropWhileFalse
117117
:: Monad m => Int -> Stream m Int -> m ()
118118

119-
scan n = composeN n $ S.scan (+) 0 id
119+
scan n = composeN n $ S.scanl (+) 0 id
120120
map n = composeN n $ S.map (+1)
121121
mapM n = composeN n $ S.mapM return
122122
filterEven n = composeN n $ S.filter even
@@ -148,15 +148,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
148148
filterTake, filterScan, filterMap
149149
:: Monad m => Int -> Stream m Int -> m ()
150150

151-
scanMap n = composeN n $ S.map (subtract 1) . S.scan (+) 0 id
151+
scanMap n = composeN n $ S.map (subtract 1) . S.scanl (+) 0 id
152152
dropMap n = composeN n $ S.map (subtract 1) . S.drop 1
153-
dropScan n = composeN n $ S.scan (+) 0 id . S.drop 1
153+
dropScan n = composeN n $ S.scanl (+) 0 id . S.drop 1
154154
takeDrop n = composeN n $ S.drop 1 . S.take maxValue
155-
takeScan n = composeN n $ S.scan (+) 0 id . S.take maxValue
155+
takeScan n = composeN n $ S.scanl (+) 0 id . S.take maxValue
156156
takeMap n = composeN n $ S.map (subtract 1) . S.take maxValue
157157
filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)
158158
filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)
159-
filterScan n = composeN n $ S.scan (+) 0 id . S.filter (<= maxBound)
159+
filterScan n = composeN n $ S.scanl (+) 0 id . S.filter (<= maxBound)
160160
filterMap n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)
161161

162162
-------------------------------------------------------------------------------

‎Benchmarks/Streamly.hs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@ scan, map,
152152

153153
mapM :: Monad m => Int -> Stream m Element -> m ()
154154

155-
scan n = composeN n $ S.scan (Fold.foldl' (+) 0)
155+
scan n = composeN n $ S.scanl (Fold.foldl' (+) 0)
156156
map n = composeN n $ fmap (+1)
157157
mapM n = composeN n $ S.mapM return
158158
filterEven n = composeN n $ S.filter even
@@ -193,7 +193,7 @@ iterateMapM, iterateScan, iterateFilterEven, iterateTakeAll, iterateDropOne,
193193

194194
-- Scan increases the size of the stream by 1, drop 1 to not blow up the size
195195
-- due to many iterations.
196-
iterateScan n = K.toStream $ iterateSource (K.fromStream . S.drop 1 . S.scan (Fold.foldl' (+) 0) . K.toStream) maxIters n
196+
iterateScan n = K.toStream $ iterateSource (K.fromStream . S.drop 1 . S.scanl (Fold.foldl' (+) 0) . K.toStream) maxIters n
197197
-- iterateScan n = K.toStream $ iterateSource (K.drop 1 . K.scanl' (+) 0) maxIters n
198198

199199
-- iterateMapM n = K.toStream $ iterateSource (K.fromStream . S.mapM return . K.toStream) maxIters n
@@ -233,15 +233,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
233233
filterTake, filterScan, filterMap
234234
:: Monad m => Int -> Stream m Element -> m ()
235235

236-
scanMap n = composeN n $ fmap (subtract 1) . S.scan (Fold.foldl' (+) 0)
236+
scanMap n = composeN n $ fmap (subtract 1) . S.scanl (Fold.foldl' (+) 0)
237237
dropMap n = composeN n $ fmap (subtract 1) . S.drop 1
238-
dropScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.drop 1
238+
dropScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.drop 1
239239
takeDrop n = composeN n $ S.drop 1 . S.take nElements
240-
takeScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.take nElements
240+
takeScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.take nElements
241241
takeMap n = composeN n $ fmap (subtract 1) . S.take nElements
242242
filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxElem)
243243
filterTake n = composeN n $ S.take maxValue . S.filter (<= maxElem)
244-
filterScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.filter (<= maxElem)
244+
filterScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.filter (<= maxElem)
245245
filterMap n = composeN n $ fmap (subtract 1) . S.filter (<= maxElem)
246246

247247
-------------------------------------------------------------------------------

‎Benchmarks/StreamlyArray.hs‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ type Stream = A.Array
3737

3838
{-# INLINE source #-}
3939
source :: MonadIO m => Int -> m (Stream Int)
40-
source n = S.fold (A.writeN value) (S.unfoldr step n)
40+
source n = S.fold (A.createOf value) (S.unfoldr step n)
4141
where
4242
step cnt =
4343
if cnt > n + value
@@ -46,7 +46,7 @@ source n = S.fold (A.writeN value) (S.unfoldr step n)
4646

4747
{-# INLINE sourceN #-}
4848
sourceN :: MonadIO m => Int -> Int -> m (Stream Int)
49-
sourceN count begin = S.fold (A.writeN value) (S.unfoldr step begin)
49+
sourceN count begin = S.fold (A.createOf value) (S.unfoldr step begin)
5050
where
5151
step i =
5252
if i > begin + count
@@ -107,10 +107,10 @@ composeN
107107
-> m (Stream Int)
108108
composeN n f x =
109109
case n of
110-
1 -> S.fold A.write $ f $ S.unfold A.reader x
111-
2 -> S.fold A.write $ f . f $ S.unfold A.reader x
112-
3 -> S.fold A.write $ f . f . f $ S.unfold A.reader x
113-
4 -> S.fold A.write $ f . f . f . f $ S.unfold A.reader x
110+
1 -> S.fold A.create $ f $ S.unfold A.reader x
111+
2 -> S.fold A.create $ f . f $ S.unfold A.reader x
112+
3 -> S.fold A.create $ f . f . f $ S.unfold A.reader x
113+
4 -> S.fold A.create $ f . f . f . f $ S.unfold A.reader x
114114
_ -> undefined
115115

116116
{-# INLINE scan #-}
@@ -132,7 +132,7 @@ scan, map, mapM,
132132
dropOne, dropAll, dropWhileTrue, dropWhileFalse
133133
:: MonadIO m => Int -> Stream Int -> m (Stream Int)
134134

135-
scan n = composeN n $ S.scan (Fold.foldl' (+) 0)
135+
scan n = composeN n $ S.scanl (Fold.foldl' (+) 0)
136136
map n = composeN n $ fmap (+1)
137137
mapM n = composeN n $ S.mapM (\x -> P.return $ x + 1)
138138
filterEven n = composeN n $ S.filter even
@@ -158,7 +158,7 @@ maxIters = 100000
158158
iterateSource :: MonadIO m
159159
=> (S.Stream m Int -> S.Stream m Int) -> Int -> Int -> m (Stream Int)
160160
iterateSource g i n =
161-
sourceN iterStreamLen n P.>>= \a -> S.fold A.write (f i $ S.unfold A.reader a)
161+
sourceN iterStreamLen n P.>>= \a -> S.fold A.create (f i $ S.unfold A.reader a)
162162
where
163163
f (0 :: Int) m = g m
164164
f x m = g (f (x P.- 1) m)
@@ -176,7 +176,7 @@ iterateMapM, iterateScan, iterateFilterEven, iterateTakeAll, iterateDropOne,
176176

177177
-- Scan increases the size of the stream by 1, drop 1 to not blow up the size
178178
-- due to many iterations.
179-
iterateScan n = iterateSource (S.drop 1 . S.scan (Fold.foldl' (+) 0)) (maxIters `div` 100) n
179+
iterateScan n = iterateSource (S.drop 1 . S.scanl (Fold.foldl' (+) 0)) (maxIters `div` 100) n
180180
iterateMapM n = iterateSource (S.mapM P.return) maxIters n
181181
iterateFilterEven n = iterateSource (S.filter even) maxIters n
182182
iterateTakeAll n = iterateSource (S.take maxValue) maxIters n
@@ -202,15 +202,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
202202
filterTake, filterScan, filterMap
203203
:: MonadIO m => Int -> Stream Int -> m (Stream Int)
204204

205-
scanMap n = composeN n $ fmap (subtract 1) . S.scan (Fold.foldl' (+) 0)
205+
scanMap n = composeN n $ fmap (subtract 1) . S.scanl (Fold.foldl' (+) 0)
206206
dropMap n = composeN n $ fmap (subtract 1) . S.drop 1
207-
dropScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.drop 1
207+
dropScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.drop 1
208208
takeDrop n = composeN n $ S.drop 1 . S.take maxValue
209-
takeScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.take maxValue
209+
takeScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.take maxValue
210210
takeMap n = composeN n $ fmap (subtract 1) . S.take maxValue
211211
filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)
212212
filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)
213-
filterScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.filter (<= maxBound)
213+
filterScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.filter (<= maxBound)
214214
filterMap n = composeN n $ fmap (subtract 1) . S.filter (<= maxValue)
215215

216216
-------------------------------------------------------------------------------

‎Benchmarks/StreamlyPure.hs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -136,7 +136,7 @@ scan, map, mapM,
136136
dropOne, dropAll, dropWhileTrue, dropWhileFalse
137137
:: Int -> Stream Int -> ()
138138

139-
scan n = composeN n $ S.scan (Fold.foldl' (+) 0)
139+
scan n = composeN n $ S.scanl (Fold.foldl' (+) 0)
140140
map n = composeN n $ fmap (+1)
141141
mapM = map
142142
filterEven n = composeN n $ S.filter even
@@ -176,7 +176,7 @@ iterateMapM, iterateScan, iterateFilterEven, iterateTakeAll, iterateDropOne,
176176

177177
-- Scan increases the size of the stream by 1, drop 1 to not blow up the size
178178
-- due to many iterations.
179-
iterateScan n = K.toStream $ iterateSource (K.fromStream . S.drop 1 . S.scan (Fold.foldl' (+) 0) . K.toStream) (maxIters `P.div` 100) n
179+
iterateScan n = K.toStream $ iterateSource (K.fromStream . S.drop 1 . S.scanl (Fold.foldl' (+) 0) . K.toStream) (maxIters `P.div` 100) n
180180
-- iterateScan n = K.toStream $ iterateSource (K.scanl' (+) 0) (maxIters `div` 100) n
181181

182182
-- iterateMapM n = K.toStream $ iterateSource (K.fromStream . S.mapM return . K.toStream) maxIters n
@@ -216,15 +216,15 @@ scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
216216
filterTake, filterScan, filterMap
217217
:: Int -> Stream Int -> ()
218218

219-
scanMap n = composeN n $ fmap (subtract 1) . S.scan (Fold.foldl' (+) 0)
219+
scanMap n = composeN n $ fmap (subtract 1) . S.scanl (Fold.foldl' (+) 0)
220220
dropMap n = composeN n $ fmap (subtract 1) . S.drop 1
221-
dropScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.drop 1
221+
dropScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.drop 1
222222
takeDrop n = composeN n $ S.drop 1 . S.take maxValue
223-
takeScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.take maxValue
223+
takeScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.take maxValue
224224
takeMap n = composeN n $ fmap (subtract 1) . S.take maxValue
225225
filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)
226226
filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)
227-
filterScan n = composeN n $ S.scan (Fold.foldl' (+) 0) . S.filter (<= maxBound)
227+
filterScan n = composeN n $ S.scanl (Fold.foldl' (+) 0) . S.filter (<= maxBound)
228228
filterMap n = composeN n $ fmap (subtract 1) . S.filter (<= maxValue)
229229

230230
-------------------------------------------------------------------------------

0 commit comments

Comments
 (0)