git.iko.soy/streamly
on master help sign in
Fix nomenclature in tests
commitb03a7b60f9279e06deedc6838f61c36fca96d130 authorHarendra Kumar <harendra.kumar@gmail.com> dateSun 13 May 2018, 10:42 (8 years ago) parentc8b32f2
5 files changed+282−282
compare with master
unifiedsplit
test/Main.hs+134−134 test/Prop.hs+134−134 test/loops.hs+9−9 test/nested-loops.hs+2−2 test/parallel-loops.hs+3−3
test/Main.hs+134−134
@@ -20,27 +20,27 @@ import qualified Streamly.Prelude as A
2020singleton :: IsStream t => a -> t m a
2121singleton a = a .: nil
2222
23−toListSerial :: StreamT IO a -> IO [a]
24−toListSerial = A.toList . asStream
23+toListSerial :: SerialT IO a -> IO [a]
24+toListSerial = A.toList . serially
2525
26−toListInterleaved :: CostreamT IO a -> IO [a]
27−toListInterleaved = A.toList . asCostream
26+toListInterleaved :: WSerialT IO a -> IO [a]
27+toListInterleaved = A.toList . wSerially
2828
29−toListAsync :: ParAheadT IO a -> IO [a]
30−toListAsync = A.toList . asParAhead
29+toListAsync :: AsyncT IO a -> IO [a]
30+toListAsync = A.toList . asyncly
3131
32−toListParallel :: CoparAheadT IO a -> IO [a]
33−toListParallel = A.toList . asCoparAhead
32+toListParallel :: WAsyncT IO a -> IO [a]
33+toListParallel = A.toList . wAsyncly
3434
3535main :: IO ()
3636main = hspec $ do
3737 describe "Runners" $ do
3838 -- XXX move these to property tests
3939 -- XXX use an IORef to store and check the side effects
40− it "simple asStream" $
41− (runStream . asStream) (return (0 :: Int)) `shouldReturn` ()
42− it "simple asStream with IO" $
43− (runStream . asStream) (A.once $ putStrLn "hello") `shouldReturn` ()
40+ it "simple serially" $
41+ (runStream . serially) (return (0 :: Int)) `shouldReturn` ()
42+ it "simple serially with IO" $
43+ (runStream . serially) (A.once $ putStrLn "hello") `shouldReturn` ()
4444
4545 describe "Empty" $ do
4646 it "Monoid - mempty" $
@@ -96,31 +96,31 @@ main = hspec $ do
9696 -- for Monoid that is using the right version of semigroup. Instance
9797 -- deriving can cause us to pick wrong instances sometimes.
9898
99− describe "Serial interleaved (<>) ordering check" $ interleaveCheck asCostream (<>)
100− describe "Serial interleaved mappend ordering check" $ interleaveCheck asCostream mappend
99+ describe "Serial interleaved (<>) ordering check" $ interleaveCheck wSerially (<>)
100+ describe "Serial interleaved mappend ordering check" $ interleaveCheck wSerially mappend
101101
102− describe "Parallel interleaved (<>) ordering check" $ interleaveCheck asCoparAhead (<>)
103− describe "Parallel interleaved mappend ordering check" $ interleaveCheck asCoparAhead mappend
102+ describe "Parallel interleaved (<>) ordering check" $ interleaveCheck wAsyncly (<>)
103+ describe "Parallel interleaved mappend ordering check" $ interleaveCheck wAsyncly mappend
104104
105− -- describe "Parallel (<>) ordering check" $ interleaveCheck asParallel (<>)
106− -- describe "Parallel mappend ordering check" $ interleaveCheck asParallel mappend
105+ -- describe "Parallel (<>) ordering check" $ interleaveCheck parallely (<>)
106+ -- describe "Parallel mappend ordering check" $ interleaveCheck parallely mappend
107107
108− describe "ParAhead (<>) time order check" $ parallelCheck asParAhead (<>)
109− describe "ParAhead mappend time order check" $ parallelCheck asParAhead mappend
110− describe "CoparAhead (<>) time order check" $ parallelCheck asCoparAhead (<>)
111− describe "CoparAhead mappend time order check" $ parallelCheck asCoparAhead mappend
108+ describe "ParAhead (<>) time order check" $ parallelCheck asyncly (<>)
109+ describe "ParAhead mappend time order check" $ parallelCheck asyncly mappend
110+ describe "CoparAhead (<>) time order check" $ parallelCheck wAsyncly (<>)
111+ describe "CoparAhead mappend time order check" $ parallelCheck wAsyncly mappend
112112
113113 ---------------------------------------------------------------------------
114114 -- Monoidal Compositions, multiset equality checks
115115 ---------------------------------------------------------------------------
116116
117− describe "Serial Composition" $ compose asStream mempty id
118− describe "Interleaved Composition" $ compose asCostream mempty sort
119− describe "ParAhead Composition" $ compose asParAhead mempty sort
120− describe "CoparAhead Composition" $ compose asCoparAhead mempty sort
121− describe "Parallel Composition" $ compose asParallel mempty sort
122− describe "Semigroup Composition for ZipSerial" $ compose asZipStream mempty id
123− describe "Semigroup Composition for ZipAsync" $ compose asZipParallel mempty id
117+ describe "Serial Composition" $ compose serially mempty id
118+ describe "Interleaved Composition" $ compose wSerially mempty sort
119+ describe "ParAhead Composition" $ compose asyncly mempty sort
120+ describe "CoparAhead Composition" $ compose wAsyncly mempty sort
121+ describe "Parallel Composition" $ compose parallely mempty sort
122+ describe "Semigroup Composition for ZipSerial" $ compose zipSerially mempty id
123+ describe "Semigroup Composition for ZipAsync" $ compose zipAsyncly mempty id
124124 -- XXX need to check alternative compositions as well
125125
126126 ---------------------------------------------------------------------------
@@ -128,11 +128,11 @@ main = hspec $ do
128128 ---------------------------------------------------------------------------
129129
130130 -- TBD need more such combinations to be tested.
131− describe "<> and <>" $ composeAndComposeSimple asStream asStream (cycle [[1 .. 9]])
131+ describe "<> and <>" $ composeAndComposeSimple serially serially (cycle [[1 .. 9]])
132132
133133 describe "<> and <=>" $ composeAndComposeSimple
134− asStream
135− asCostream
134+ serially
135+ wSerially
136136 ([ [1 .. 9]
137137 , [1 .. 9]
138138 , [1, 3, 2, 4, 6, 5, 7, 9, 8]
@@ -140,8 +140,8 @@ main = hspec $ do
140140 ])
141141
142142 describe "<=> and <=>" $ composeAndComposeSimple
143− asCostream
144− asCostream
143+ wSerially
144+ wSerially
145145 ([ [1, 4, 2, 7, 3, 5, 8, 6, 9]
146146 , [1, 7, 4, 8, 2, 9, 5, 3, 6]
147147 , [1, 4, 3, 7, 2, 6, 9, 5, 8]
@@ -149,8 +149,8 @@ main = hspec $ do
149149 ])
150150
151151 describe "<=> and <>" $ composeAndComposeSimple
152− asCostream
153− asStream
152+ wSerially
153+ serially
154154 ([ [1, 4, 2, 7, 3, 5, 8, 6, 9]
155155 , [1, 7, 4, 8, 2, 9, 5, 3, 6]
156156 , [1, 4, 2, 7, 3, 5, 8, 6, 9]
@@ -159,8 +159,8 @@ main = hspec $ do
159159
160160 describe "Nested parallel and serial compositions" $ do
161161 let t = timed
162− p = asCoparAhead
163− s = asStream
162+ p = wAsyncly
163+ s = serially
164164 {-
165165 -- This is not correct, the result can also be [4,4,8,0,8,0,2,2]
166166 -- because of parallelism of [8,0] and [8,0].
@@ -172,7 +172,7 @@ main = hspec $ do
172172 `shouldReturn` ([4,4,8,8,0,0,2,2])
173173 -}
174174 it "Nest <|>, <>, <|> (2)" $
175− (A.toList . asCoparAhead) (
175+ (A.toList . wAsyncly) (
176176 s (p (t 4 <> t 8) <> p (t 1 <> t 2))
177177 <> s (p (t 4 <> t 8) <> p (t 1 <> t 2)))
178178 `shouldReturn` ([4,4,8,8,1,1,2,2])
@@ -193,7 +193,7 @@ main = hspec $ do
193193 `shouldReturn` ([4,4,1,1,8,2,9,2])
194194 -}
195195 it "Nest <|>, <|>, <|>" $
196− (A.toList . asCoparAhead) (
196+ (A.toList . wAsyncly) (
197197 ((t 4 <> t 8) <> (t 0 <> t 2))
198198 <> ((t 4 <> t 8) <> (t 0 <> t 2)))
199199 `shouldReturn` ([0,0,2,2,4,4,8,8])
@@ -202,103 +202,103 @@ main = hspec $ do
202202 -- Monoidal composition recursion loops
203203 ---------------------------------------------------------------------------
204204
205− describe "Serial loops" $ loops asStream id reverse
206− describe "ParAhead parallel loops" $ loops asParAhead sort sort
207− describe "coparAhead loops" $ loops asCoparAhead sort sort
208− describe "parallel loops" $ loops asParallel sort sort
205+ describe "Serial loops" $ loops serially id reverse
206+ describe "ParAhead parallel loops" $ loops asyncly sort sort
207+ describe "coparAhead loops" $ loops wAsyncly sort sort
208+ describe "parallel loops" $ loops parallely sort sort
209209
210210 ---------------------------------------------------------------------------
211211 -- Bind and monoidal composition combinations
212212 ---------------------------------------------------------------------------
213213
214− describe "Bind and compose Stream 1" $ bindAndComposeSimple asStream asStream
215− describe "Bind and compose Stream 2" $ bindAndComposeSimple asStream asCostream
216− describe "Bind and compose Stream 3" $ bindAndComposeSimple asStream asParAhead
217− describe "Bind and compose Stream 4" $ bindAndComposeSimple asStream asCoparAhead
218− describe "Bind and compose Stream 5" $ bindAndComposeSimple asStream asParallel
219−
220− describe "Bind and compose Costream 1" $ bindAndComposeSimple asCostream asStream
221− describe "Bind and compose Costream 2" $ bindAndComposeSimple asCostream asCostream
222− describe "Bind and compose Costream 3" $ bindAndComposeSimple asCostream asParAhead
223− describe "Bind and compose Costream 4" $ bindAndComposeSimple asCostream asCoparAhead
224− describe "Bind and compose Costream 5" $ bindAndComposeSimple asCostream asParallel
225−
226− describe "Bind and compose ParAhead 1" $ bindAndComposeSimple asParAhead asStream
227− describe "Bind and compose ParAhead 2" $ bindAndComposeSimple asParAhead asCostream
228− describe "Bind and compose ParAhead 3" $ bindAndComposeSimple asParAhead asParAhead
229− describe "Bind and compose ParAhead 4" $ bindAndComposeSimple asParAhead asCoparAhead
230− describe "Bind and compose ParAhead 5" $ bindAndComposeSimple asParAhead asParallel
231−
232− describe "Bind and compose CoparAhead 1" $ bindAndComposeSimple asCoparAhead asStream
233− describe "Bind and compose CoparAhead 2" $ bindAndComposeSimple asCoparAhead asCostream
234− describe "Bind and compose CoparAhead 3" $ bindAndComposeSimple asCoparAhead asParAhead
235− describe "Bind and compose CoparAhead 4" $ bindAndComposeSimple asCoparAhead asCoparAhead
236− describe "Bind and compose CoparAhead 5" $ bindAndComposeSimple asCoparAhead asParallel
237−
238− describe "Bind and compose Parallel 1" $ bindAndComposeSimple asParallel asStream
239− describe "Bind and compose Parallel 2" $ bindAndComposeSimple asParallel asCostream
240− describe "Bind and compose Parallel 3" $ bindAndComposeSimple asParallel asParAhead
241− describe "Bind and compose Parallel 4" $ bindAndComposeSimple asParallel asCoparAhead
242− describe "Bind and compose Parallel 5" $ bindAndComposeSimple asParallel asParallel
214+ describe "Bind and compose Stream 1" $ bindAndComposeSimple serially serially
215+ describe "Bind and compose Stream 2" $ bindAndComposeSimple serially wSerially
216+ describe "Bind and compose Stream 3" $ bindAndComposeSimple serially asyncly
217+ describe "Bind and compose Stream 4" $ bindAndComposeSimple serially wAsyncly
218+ describe "Bind and compose Stream 5" $ bindAndComposeSimple serially parallely
219+
220+ describe "Bind and compose Costream 1" $ bindAndComposeSimple wSerially serially
221+ describe "Bind and compose Costream 2" $ bindAndComposeSimple wSerially wSerially
222+ describe "Bind and compose Costream 3" $ bindAndComposeSimple wSerially asyncly
223+ describe "Bind and compose Costream 4" $ bindAndComposeSimple wSerially wAsyncly
224+ describe "Bind and compose Costream 5" $ bindAndComposeSimple wSerially parallely
225+
226+ describe "Bind and compose ParAhead 1" $ bindAndComposeSimple asyncly serially
227+ describe "Bind and compose ParAhead 2" $ bindAndComposeSimple asyncly wSerially
228+ describe "Bind and compose ParAhead 3" $ bindAndComposeSimple asyncly asyncly
229+ describe "Bind and compose ParAhead 4" $ bindAndComposeSimple asyncly wAsyncly
230+ describe "Bind and compose ParAhead 5" $ bindAndComposeSimple asyncly parallely
231+
232+ describe "Bind and compose CoparAhead 1" $ bindAndComposeSimple wAsyncly serially
233+ describe "Bind and compose CoparAhead 2" $ bindAndComposeSimple wAsyncly wSerially
234+ describe "Bind and compose CoparAhead 3" $ bindAndComposeSimple wAsyncly asyncly
235+ describe "Bind and compose CoparAhead 4" $ bindAndComposeSimple wAsyncly wAsyncly
236+ describe "Bind and compose CoparAhead 5" $ bindAndComposeSimple wAsyncly parallely
237+
238+ describe "Bind and compose Parallel 1" $ bindAndComposeSimple parallely serially
239+ describe "Bind and compose Parallel 2" $ bindAndComposeSimple parallely wSerially
240+ describe "Bind and compose Parallel 3" $ bindAndComposeSimple parallely asyncly
241+ describe "Bind and compose Parallel 4" $ bindAndComposeSimple parallely wAsyncly
242+ describe "Bind and compose Parallel 5" $ bindAndComposeSimple parallely parallely
243243
244244 let fldr, fldl :: (IsStream t, Semigroup (t IO Int)) => [t IO Int] -> t IO Int
245245 fldr = foldr (<>) nil
246246 fldl = foldl (<>) nil
247247
248248 forM_ [fldr, fldl] $ \k ->
249− describe "Bind and compose" $ bindAndComposeHierarchy asStream asStream k
249+ describe "Bind and compose" $ bindAndComposeHierarchy serially serially k
250250 forM_ [fldr, fldl] $ \k ->
251− describe "Bind and compose" $ bindAndComposeHierarchy asStream asCostream k
251+ describe "Bind and compose" $ bindAndComposeHierarchy serially wSerially k
252252 forM_ [fldr, fldl] $ \k ->
253− describe "Bind and compose" $ bindAndComposeHierarchy asStream asParAhead k
253+ describe "Bind and compose" $ bindAndComposeHierarchy serially asyncly k
254254 forM_ [fldr, fldl] $ \k ->
255− describe "Bind and compose" $ bindAndComposeHierarchy asStream asCoparAhead k
255+ describe "Bind and compose" $ bindAndComposeHierarchy serially wAsyncly k
256256 forM_ [fldr, fldl] $ \k ->
257− describe "Bind and compose" $ bindAndComposeHierarchy asStream asParallel k
257+ describe "Bind and compose" $ bindAndComposeHierarchy serially parallely k
258258
259259 forM_ [fldr, fldl] $ \k ->
260− describe "Bind and compose" $ bindAndComposeHierarchy asCostream asStream k
260+ describe "Bind and compose" $ bindAndComposeHierarchy wSerially serially k
261261 forM_ [fldr, fldl] $ \k ->
262− describe "Bind and compose" $ bindAndComposeHierarchy asCostream asCostream k
262+ describe "Bind and compose" $ bindAndComposeHierarchy wSerially wSerially k
263263 forM_ [fldr, fldl] $ \k ->
264− describe "Bind and compose" $ bindAndComposeHierarchy asCostream asParAhead k
264+ describe "Bind and compose" $ bindAndComposeHierarchy wSerially asyncly k
265265 forM_ [fldr, fldl] $ \k ->
266− describe "Bind and compose" $ bindAndComposeHierarchy asCostream asCoparAhead k
266+ describe "Bind and compose" $ bindAndComposeHierarchy wSerially wAsyncly k
267267 forM_ [fldr, fldl] $ \k ->
268− describe "Bind and compose" $ bindAndComposeHierarchy asCostream asParallel k
268+ describe "Bind and compose" $ bindAndComposeHierarchy wSerially parallely k
269269
270270 forM_ [fldr, fldl] $ \k ->
271− describe "Bind and compose" $ bindAndComposeHierarchy asParAhead asStream k
271+ describe "Bind and compose" $ bindAndComposeHierarchy asyncly serially k
272272 forM_ [fldr, fldl] $ \k ->
273− describe "Bind and compose" $ bindAndComposeHierarchy asParAhead asCostream k
273+ describe "Bind and compose" $ bindAndComposeHierarchy asyncly wSerially k
274274 forM_ [fldr, fldl] $ \k ->
275− describe "Bind and compose" $ bindAndComposeHierarchy asParAhead asParAhead k
275+ describe "Bind and compose" $ bindAndComposeHierarchy asyncly asyncly k
276276 forM_ [fldr, fldl] $ \k ->
277− describe "Bind and compose" $ bindAndComposeHierarchy asParAhead asCoparAhead k
277+ describe "Bind and compose" $ bindAndComposeHierarchy asyncly wAsyncly k
278278 forM_ [fldr, fldl] $ \k ->
279− describe "Bind and compose" $ bindAndComposeHierarchy asParAhead asParallel k
279+ describe "Bind and compose" $ bindAndComposeHierarchy asyncly parallely k
280280
281281 forM_ [fldr, fldl] $ \k ->
282− describe "Bind and compose" $ bindAndComposeHierarchy asCoparAhead asStream k
282+ describe "Bind and compose" $ bindAndComposeHierarchy wAsyncly serially k
283283 forM_ [fldr, fldl] $ \k ->
284− describe "Bind and compose" $ bindAndComposeHierarchy asCoparAhead asCostream k
284+ describe "Bind and compose" $ bindAndComposeHierarchy wAsyncly wSerially k
285285 forM_ [fldr, fldl] $ \k ->
286− describe "Bind and compose" $ bindAndComposeHierarchy asCoparAhead asParAhead k
286+ describe "Bind and compose" $ bindAndComposeHierarchy wAsyncly asyncly k
287287 forM_ [fldr, fldl] $ \k ->
288− describe "Bind and compose" $ bindAndComposeHierarchy asCoparAhead asCoparAhead k
288+ describe "Bind and compose" $ bindAndComposeHierarchy wAsyncly wAsyncly k
289289 forM_ [fldr, fldl] $ \k ->
290− describe "Bind and compose" $ bindAndComposeHierarchy asCoparAhead asParallel k
290+ describe "Bind and compose" $ bindAndComposeHierarchy wAsyncly parallely k
291291
292292 forM_ [fldr, fldl] $ \k ->
293− describe "Bind and compose" $ bindAndComposeHierarchy asParallel asStream k
293+ describe "Bind and compose" $ bindAndComposeHierarchy parallely serially k
294294 forM_ [fldr, fldl] $ \k ->
295− describe "Bind and compose" $ bindAndComposeHierarchy asParallel asCostream k
295+ describe "Bind and compose" $ bindAndComposeHierarchy parallely wSerially k
296296 forM_ [fldr, fldl] $ \k ->
297− describe "Bind and compose" $ bindAndComposeHierarchy asParallel asParAhead k
297+ describe "Bind and compose" $ bindAndComposeHierarchy parallely asyncly k
298298 forM_ [fldr, fldl] $ \k ->
299− describe "Bind and compose" $ bindAndComposeHierarchy asParallel asCoparAhead k
299+ describe "Bind and compose" $ bindAndComposeHierarchy parallely wAsyncly k
300300 forM_ [fldr, fldl] $ \k ->
301− describe "Bind and compose" $ bindAndComposeHierarchy asParallel asParallel k
301+ describe "Bind and compose" $ bindAndComposeHierarchy parallely parallely k
302302
303303 -- Nest two lists using different styles of product compositions
304304 it "Nests two streams using monadic serial composition" nestTwoSerial
@@ -322,20 +322,20 @@ main = hspec $ do
322322 describe "Simple MonadError and MonadThrow" simpleMonadError
323323
324324 {-
325− describe "Composed MonadError asStream" $ composeWithMonadError asStream
326− describe "Composed MonadError asCostream" $ composeWithMonadError asCostream
327− describe "Composed MonadError asParAhead" $ composeWithMonadError asParAhead
328− describe "Composed MonadError asCoparAhead" $ composeWithMonadError asCoparAhead
325+ describe "Composed MonadError serially" $ composeWithMonadError serially
326+ describe "Composed MonadError wSerially" $ composeWithMonadError wSerially
327+ describe "Composed MonadError asyncly" $ composeWithMonadError asyncly
328+ describe "Composed MonadError wAsyncly" $ composeWithMonadError wAsyncly
329329 -}
330330
331− describe "Composed MonadThrow asStream" $ composeWithMonadThrow asStream
332− describe "Composed MonadThrow asCostream" $ composeWithMonadThrow asCostream
333− describe "Composed MonadThrow asParAhead" $ composeWithMonadThrow asParAhead
334− describe "Composed MonadThrow asCoparAhead" $ composeWithMonadThrow asCoparAhead
335− describe "Composed MonadThrow asParallel" $ composeWithMonadThrow asParallel
331+ describe "Composed MonadThrow serially" $ composeWithMonadThrow serially
332+ describe "Composed MonadThrow wSerially" $ composeWithMonadThrow wSerially
333+ describe "Composed MonadThrow asyncly" $ composeWithMonadThrow asyncly
334+ describe "Composed MonadThrow wAsyncly" $ composeWithMonadThrow wAsyncly
335+ describe "Composed MonadThrow parallely" $ composeWithMonadThrow parallely
336336
337337 it "Crosses thread limit (2000 threads)" $
338− runStream (asParAhead $ fold $
338+ runStream (asyncly $ fold $
339339 replicate 2000 $ A.once $ threadDelay 1000000)
340340 `shouldReturn` ()
341341
@@ -368,7 +368,7 @@ composeWithMonadThrow
368368 , Semigroup (t IO Int)
369369 , MonadThrow (t IO)
370370 )
371− => (t IO Int -> StreamT IO Int) -> Spec
371+ => (t IO Int -> SerialT IO Int) -> Spec
372372composeWithMonadThrow t = do
373373 it "Compose throwM, nil" $
374374 (try $ tl (throwM (ExampleException "E") <> A.nil))
@@ -376,16 +376,16 @@ composeWithMonadThrow t = do
376376 it "Compose nil, throwM" $
377377 (try $ tl (A.nil <> throwM (ExampleException "E")))
378378 `shouldReturn` (Left (ExampleException "E") :: Either ExampleException [Int])
379− oneLevelNestedSum "asStream" asStream
380− oneLevelNestedSum "asCostream" asCostream
381− oneLevelNestedSum "asParAhead" asParAhead
382− oneLevelNestedSum "asCoparAhead" asCoparAhead
379+ oneLevelNestedSum "serially" serially
380+ oneLevelNestedSum "wSerially" wSerially
381+ oneLevelNestedSum "asyncly" asyncly
382+ oneLevelNestedSum "wAsyncly" wAsyncly
383383 -- XXX add two level nesting
384384
385− oneLevelNestedProduct "asStream" asStream
386− oneLevelNestedProduct "asCostream" asCostream
387− oneLevelNestedProduct "asParAhead" asParAhead
388− oneLevelNestedProduct "asCoparAhead" asCoparAhead
385+ oneLevelNestedProduct "serially" serially
386+ oneLevelNestedProduct "wSerially" wSerially
387+ oneLevelNestedProduct "asyncly" asyncly
388+ oneLevelNestedProduct "wAsyncly" wAsyncly
389389
390390 where
391391 tl = A.toList . t
@@ -414,7 +414,7 @@ _composeWithMonadError
414414 , Semigroup (t (ExceptT String IO) Int)
415415 , MonadError String (t (ExceptT String IO))
416416 )
417− => (t (ExceptT String IO) Int -> StreamT (ExceptT String IO) Int) -> Spec
417+ => (t (ExceptT String IO) Int -> SerialT (ExceptT String IO) Int) -> Spec
418418_composeWithMonadError t = do
419419 let tl = A.toList . t
420420 it "Compose throwError, nil" $
@@ -478,7 +478,7 @@ nestTwoCoparAhead :: Expectation
478478nestTwoCoparAhead =
479479 let s1 = foldMapWith (<>) return [1..4]
480480 s2 = foldMapWith (<>) return [5..8]
481− in ((A.toList . asCoparAhead) (do
481+ in ((A.toList . wAsyncly) (do
482482 x <- s1
483483 y <- s2
484484 return (x + y)
@@ -489,7 +489,7 @@ nestTwoParallel :: Expectation
489489nestTwoParallel =
490490 let s1 = foldMapWith (<>) return [1..4]
491491 s2 = foldMapWith (<>) return [5..8]
492− in ((A.toList . asParallel) (do
492+ in ((A.toList . parallely) (do
493493 x <- s1
494494 y <- s2
495495 return (x + y)
@@ -500,21 +500,21 @@ nestTwoCoparAheadApp :: Expectation
500500nestTwoCoparAheadApp =
501501 let s1 = foldMapWith (<>) return [1..4]
502502 s2 = foldMapWith (<>) return [5..8]
503− in ((A.toList . asCoparAhead) ((+) <$> s1 <*> s2) >>= return . sort)
503+ in ((A.toList . wAsyncly) ((+) <$> s1 <*> s2) >>= return . sort)
504504 `shouldReturn` sort ([6,7,7,8,8,8,9,9,9,9,10,10,10,11,11,12] :: [Int])
505505
506506nestTwoParallelApp :: Expectation
507507nestTwoParallelApp =
508508 let s1 = foldMapWith (<>) return [1..4]
509509 s2 = foldMapWith (<>) return [5..8]
510− in ((A.toList . asParallel) ((+) <$> s1 <*> s2) >>= return . sort)
510+ in ((A.toList . parallely) ((+) <$> s1 <*> s2) >>= return . sort)
511511 `shouldReturn` sort ([6,7,7,8,8,8,9,9,9,9,10,10,10,11,11,12] :: [Int])
512512
513513timed :: (IsStream t, Monad (t IO)) => Int -> t IO Int
514514timed x = A.once (threadDelay (x * 100000)) >> return x
515515
516516interleaveCheck :: IsStream t
517− => (t IO Int -> StreamT IO Int)
517+ => (t IO Int -> SerialT IO Int)
518518 -> (t IO Int -> t IO Int -> t IO Int)
519519 -> Spec
520520interleaveCheck t f =
@@ -523,7 +523,7 @@ interleaveCheck t f =
523523 `shouldReturn` ([0, 100, 1, 101])
524524
525525parallelCheck :: (IsStream t, Monad (t IO))
526− => (t IO Int -> StreamT IO Int)
526+ => (t IO Int -> SerialT IO Int)
527527 -> (t IO Int -> t IO Int -> t IO Int)
528528 -> Spec
529529parallelCheck t f = do
@@ -538,7 +538,7 @@ parallelCheck t f = do
538538 where event n = (A.once $ threadDelay (n * 100000)) >> (return n)
539539
540540compose :: (IsStream t, Semigroup (t IO Int))
541− => (t IO Int -> StreamT IO Int) -> t IO Int -> ([Int] -> [Int]) -> Spec
541+ => (t IO Int -> SerialT IO Int) -> t IO Int -> ([Int] -> [Int]) -> Spec
542542compose t z srt = do
543543 -- XXX these should get covered by the property tests
544544 it "Compose mempty, mempty" $
@@ -577,7 +577,7 @@ composeAndComposeSimple
577577 , Semigroup (t2 IO Int)
578578#endif
579579 )
580− => (t1 IO Int -> StreamT IO Int)
580+ => (t1 IO Int -> SerialT IO Int)
581581 -> (t2 IO Int -> t2 IO Int)
582582 -> [[Int]] -> Spec
583583composeAndComposeSimple t1 t2 answer = do
@@ -625,7 +625,7 @@ loops t tsrt hsrt = do
625625
626626bindAndComposeSimple
627627 :: ( IsStream t1, IsStream t2, Semigroup (t2 IO Int), Monad (t2 IO))
628− => (t1 IO Int -> StreamT IO Int)
628+ => (t1 IO Int -> SerialT IO Int)
629629 -> (t2 IO Int -> t2 IO Int)
630630 -> Spec
631631bindAndComposeSimple t1 t2 = do
@@ -642,7 +642,7 @@ bindAndComposeSimple t1 t2 = do
642642bindAndComposeHierarchy
643643 :: ( IsStream t1, Monad (t1 IO)
644644 , IsStream t2, Monad (t2 IO))
645− => (t1 IO Int -> StreamT IO Int)
645+ => (t1 IO Int -> SerialT IO Int)
646646 -> (t2 IO Int -> t2 IO Int)
647647 -> ([t2 IO Int] -> t2 IO Int)
648648 -> Spec
@@ -659,7 +659,7 @@ bindAndComposeHierarchy t1 t2 g = do
659659
660660 where
661661
662− -- bindComposeNested :: ACoparAheadT IO Int
662+ -- bindComposeNested :: WAsyncT IO Int
663663 bindComposeNested =
664664 let c1 = tripleCompose (return 1) (return 2) (return 3)
665665 c2 = tripleCompose (return 4) (return 5) (return 6)
@@ -686,21 +686,21 @@ mixedOps = do
686686 ] :: [Int])
687687 where
688688
689− composeMixed :: StreamT IO Int
689+ composeMixed :: SerialT IO Int
690690 composeMixed = do
691691 A.once $ return ()
692692 A.once $ putStr ""
693693 x <- return 1
694694 y <- return 2
695695 z <- do
696− x1 <- asCoparAhead $ return 1 <> return 2
696+ x1 <- wAsyncly $ return 1 <> return 2
697697 A.once $ return ()
698698 A.once $ putStr ""
699− y1 <- asParAhead $ return 1 <> return 2
699+ y1 <- asyncly $ return 1 <> return 2
700700 z1 <- do
701701 x11 <- return 1 <> return 2
702− y11 <- asParAhead $ return 1 <> return 2
703− z11 <- asCostream $ return 1 <> return 2
702+ y11 <- asyncly $ return 1 <> return 2
703+ z11 <- wSerially $ return 1 <> return 2
704704 A.once $ return ()
705705 A.once $ putStr ""
706706 return (x11 + y11 + z11)
test/Prop.hs+134−134
@@ -36,7 +36,7 @@ equals eq stream list = do
3636
3737constructWithReplicateM
3838 :: IsStream t
39− => (t IO Int -> StreamT IO Int)
39+ => (t IO Int -> SerialT IO Int)
4040 -> Word8
4141 -> Property
4242constructWithReplicateM op len =
@@ -50,7 +50,7 @@ transformFromList
5050 :: ([Int] -> t IO Int)
5151 -> ([Int] -> [Int] -> Bool)
5252 -> ([Int] -> [Int])
53− -> (t IO Int -> StreamT IO Int)
53+ -> (t IO Int -> SerialT IO Int)
5454 -> [Int]
5555 -> Property
5656transformFromList constr eq listOp op a =
@@ -61,7 +61,7 @@ transformFromList constr eq listOp op a =
6161
6262foldFromList
6363 :: ([Int] -> t IO Int)
64− -> (t IO Int -> StreamT IO Int)
64+ -> (t IO Int -> SerialT IO Int)
6565 -> ([Int] -> [Int] -> Bool)
6666 -> [Int]
6767 -> Property
@@ -82,8 +82,8 @@ eliminateOp constr listOp op a =
8282
8383elemOp
8484 :: ([Word8] -> t IO Word8)
85− -> (t IO Word8 -> StreamT IO Word8)
86− -> (Word8 -> StreamT IO Word8 -> IO Bool)
85+ -> (t IO Word8 -> SerialT IO Word8)
86+ -> (Word8 -> SerialT IO Word8 -> IO Bool)
8787 -> (Word8 -> [Word8] -> Bool)
8888 -> (Word8, [Word8])
8989 -> Property
@@ -97,7 +97,7 @@ functorOps
9797 :: Functor (t IO)
9898 => ([Int] -> t IO Int)
9999 -> String
100− -> (t IO Int -> StreamT IO Int)
100+ -> (t IO Int -> SerialT IO Int)
101101 -> ([Int] -> [Int] -> Bool)
102102 -> Spec
103103functorOps constr desc t eq = do
@@ -108,7 +108,7 @@ transformOps
108108 :: IsStream t
109109 => ([Int] -> t IO Int)
110110 -> String
111− -> (t IO Int -> StreamT IO Int)
111+ -> (t IO Int -> SerialT IO Int)
112112 -> ([Int] -> [Int] -> Bool)
113113 -> Spec
114114transformOps constr desc t eq = do
@@ -159,7 +159,7 @@ wrapMaybe f =
159159eliminationOps
160160 :: ([Int] -> t IO Int)
161161 -> String
162− -> (t IO Int -> StreamT IO Int)
162+ -> (t IO Int -> SerialT IO Int)
163163 -> Spec
164164eliminationOps constr desc t = do
165165 -- Elimination
@@ -180,7 +180,7 @@ eliminationOps constr desc t = do
180180serialEliminationOps
181181 :: ([Int] -> t IO Int)
182182 -> String
183− -> (t IO Int -> StreamT IO Int)
183+ -> (t IO Int -> SerialT IO Int)
184184 -> Spec
185185serialEliminationOps constr desc t = do
186186 prop (desc ++ " head") $ eliminateOp constr (wrapMaybe head) $ A.head . t
@@ -194,7 +194,7 @@ serialEliminationOps constr desc t = do
194194transformOpsWord8
195195 :: ([Word8] -> t IO Word8)
196196 -> String
197− -> (t IO Word8 -> StreamT IO Word8)
197+ -> (t IO Word8 -> SerialT IO Word8)
198198 -> Spec
199199transformOpsWord8 constr desc t = do
200200 prop (desc ++ " elem") $ elemOp constr t A.elem elem
@@ -209,7 +209,7 @@ semigroupOps
209209#endif
210210 , Monoid (t IO Int))
211211 => String
212− -> (t IO Int -> StreamT IO Int)
212+ -> (t IO Int -> SerialT IO Int)
213213 -> ([Int] -> [Int] -> Bool)
214214 -> Spec
215215semigroupOps desc t eq = do
@@ -219,7 +219,7 @@ semigroupOps desc t eq = do
219219applicativeOps
220220 :: Applicative (t IO)
221221 => ([Int] -> t IO Int)
222− -> (t IO (Int, Int) -> StreamT IO (Int, Int))
222+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))
223223 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)
224224 -> ([Int], [Int])
225225 -> Property
@@ -231,7 +231,7 @@ applicativeOps constr t eq (a, b) = monadicIO $ do
231231zipApplicative
232232 :: (IsStream t, Applicative (t IO))
233233 => ([Int] -> t IO Int)
234− -> (t IO (Int, Int) -> StreamT IO (Int, Int))
234+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))
235235 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)
236236 -> ([Int], [Int])
237237 -> Property
@@ -247,7 +247,7 @@ zipApplicative constr t eq (a, b) = monadicIO $ do
247247zipMonadic
248248 :: (IsStream t, Monad (t IO))
249249 => ([Int] -> t IO Int)
250− -> (t IO (Int, Int) -> StreamT IO (Int, Int))
250+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))
251251 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)
252252 -> ([Int], [Int])
253253 -> Property
@@ -260,7 +260,7 @@ zipMonadic constr t eq (a, b) =
260260 stream2 <-
261261 run
262262 ((A.toList . t)
263− (A.zipParallelWithM (\x y -> return (x, y)) (constr a) (constr b)))
263+ (A.zipAsyncWithM (\x y -> return (x, y)) (constr a) (constr b)))
264264 let list = getZipList $ (,) <$> ZipList a <*> ZipList b
265265 equals eq stream1 list
266266 equals eq stream2 list
@@ -268,7 +268,7 @@ zipMonadic constr t eq (a, b) =
268268monadThen
269269 :: Monad (t IO)
270270 => ([Int] -> t IO Int)
271− -> (t IO Int -> StreamT IO Int)
271+ -> (t IO Int -> SerialT IO Int)
272272 -> ([Int] -> [Int] -> Bool)
273273 -> ([Int], [Int])
274274 -> Property
@@ -280,7 +280,7 @@ monadThen constr t eq (a, b) = monadicIO $ do
280280monadBind
281281 :: Monad (t IO)
282282 => ([Int] -> t IO Int)
283− -> (t IO Int -> StreamT IO Int)
283+ -> (t IO Int -> SerialT IO Int)
284284 -> ([Int] -> [Int] -> Bool)
285285 -> ([Int], [Int])
286286 -> Property
@@ -297,151 +297,151 @@ main :: IO ()
297297main = hspec $ do
298298 describe "Construction" $ do
299299 -- XXX test for all types of streams
300− prop "asStream replicateM" $ constructWithReplicateM asStream
300+ prop "serially replicateM" $ constructWithReplicateM serially
301301 it "iterate" $
302− (A.toList . asStream . (A.take 100) $ (A.iterate (+ 1) (0 :: Int)))
302+ (A.toList . serially . (A.take 100) $ (A.iterate (+ 1) (0 :: Int)))
303303 `shouldReturn` (take 100 $ iterate (+ 1) 0)
304304
305305 it "iterateM" $ do
306306 let addM = (\ y -> return (y + 1))
307− A.toList . asStream . (A.take 100) $ A.iterateM addM (0 :: Int)
307+ A.toList . serially . (A.take 100) $ A.iterateM addM (0 :: Int)
308308 `shouldReturn` (take 100 $ iterate (+ 1) 0)
309309
310310 let folded :: IsStream t => [a] -> t IO a
311− folded = asStream . (\xs ->
311+ folded = serially . (\xs ->
312312 case xs of
313313 [x] -> return x -- singleton stream case
314314 _ -> foldMapWith (<>) return xs
315315 )
316316 describe "Functor operations" $ do
317− functorOps A.fromFoldable "asStream" asStream (==)
318− functorOps folded "asStream folded" asStream (==)
319− functorOps A.fromFoldable "asCostream" asCostream (==)
320− functorOps folded "asCostream folded" asCostream (==)
321− functorOps A.fromFoldable "asParAhead" asParAhead sortEq
322− functorOps folded "asParAhead folded" asParAhead sortEq
323− functorOps A.fromFoldable "asCoparAhead" asCoparAhead sortEq
324− functorOps folded "asCoparAhead folded" asCoparAhead sortEq
325− functorOps A.fromFoldable "asParallel" asParallel sortEq
326− functorOps folded "asParallel folded" asParallel sortEq
327− functorOps A.fromFoldable "asZipStream" asZipStream (==)
328− functorOps folded "asZipStream folded" asZipStream (==)
329− functorOps A.fromFoldable "asZipParallel" asZipParallel (==)
330− functorOps folded "asZipParallel folded" asZipParallel (==)
317+ functorOps A.fromFoldable "serially" serially (==)
318+ functorOps folded "serially folded" serially (==)
319+ functorOps A.fromFoldable "wSerially" wSerially (==)
320+ functorOps folded "wSerially folded" wSerially (==)
321+ functorOps A.fromFoldable "asyncly" asyncly sortEq
322+ functorOps folded "asyncly folded" asyncly sortEq
323+ functorOps A.fromFoldable "wAsyncly" wAsyncly sortEq
324+ functorOps folded "wAsyncly folded" wAsyncly sortEq
325+ functorOps A.fromFoldable "parallely" parallely sortEq
326+ functorOps folded "parallely folded" parallely sortEq
327+ functorOps A.fromFoldable "zipSerially" zipSerially (==)
328+ functorOps folded "zipSerially folded" zipSerially (==)
329+ functorOps A.fromFoldable "zipAsyncly" zipAsyncly (==)
330+ functorOps folded "zipAsyncly folded" zipAsyncly (==)
331331
332332 describe "Semigroup operations" $ do
333− semigroupOps "asStream" asStream (==)
334− semigroupOps "asCostream" asCostream (==)
335− semigroupOps "asParAhead" asParAhead sortEq
336− semigroupOps "asCoparAhead" asCoparAhead sortEq
337− semigroupOps "asParallel" asParallel sortEq
338− semigroupOps "asZipStream" asZipStream (==)
339− semigroupOps "asZipParallel" asZipParallel (==)
333+ semigroupOps "serially" serially (==)
334+ semigroupOps "wSerially" wSerially (==)
335+ semigroupOps "asyncly" asyncly sortEq
336+ semigroupOps "wAsyncly" wAsyncly sortEq
337+ semigroupOps "parallely" parallely sortEq
338+ semigroupOps "zipSerially" zipSerially (==)
339+ semigroupOps "zipAsyncly" zipAsyncly (==)
340340
341341 describe "Applicative operations" $ do
342342 -- The tests using sorted equality are weaker tests
343343 -- We need to have stronger unit tests for all those
344344 -- XXX applicative with three arguments
345− prop "asStream applicative" $ applicativeOps A.fromFoldable asStream (==)
346− prop "asStream applicative folded" $ applicativeOps folded asStream (==)
347− prop "asCostream applicative" $ applicativeOps A.fromFoldable asCostream sortEq
348− prop "asCostream applicative folded" $ applicativeOps folded asCostream sortEq
349− prop "asParAhead applicative" $ applicativeOps A.fromFoldable asParAhead sortEq
350− prop "asParAhead applicative folded" $ applicativeOps folded asParAhead sortEq
351− prop "asCoparAhead applicative folded" $ applicativeOps folded asCoparAhead sortEq
352− prop "asParallel applicative folded" $ applicativeOps folded asParallel sortEq
345+ prop "serially applicative" $ applicativeOps A.fromFoldable serially (==)
346+ prop "serially applicative folded" $ applicativeOps folded serially (==)
347+ prop "wSerially applicative" $ applicativeOps A.fromFoldable wSerially sortEq
348+ prop "wSerially applicative folded" $ applicativeOps folded wSerially sortEq
349+ prop "asyncly applicative" $ applicativeOps A.fromFoldable asyncly sortEq
350+ prop "asyncly applicative folded" $ applicativeOps folded asyncly sortEq
351+ prop "wAsyncly applicative folded" $ applicativeOps folded wAsyncly sortEq
352+ prop "parallely applicative folded" $ applicativeOps folded parallely sortEq
353353
354354 describe "Zip operations" $ do
355− prop "asZipStream applicative" $ zipApplicative A.fromFoldable asZipStream (==)
355+ prop "zipSerially applicative" $ zipApplicative A.fromFoldable zipSerially (==)
356356 -- XXX this hangs
357− -- prop "asZipParallel applicative" $ zipApplicative asZipParallel (==)
358− prop "zip monadic asStream" $ zipMonadic A.fromFoldable asStream (==)
359− prop "zip monadic asStream folded" $ zipMonadic folded asStream (==)
360− prop "zip monadic asCostream" $ zipMonadic A.fromFoldable asCostream (==)
361− prop "zip monadic asCostream folded" $ zipMonadic folded asCostream (==)
362− prop "zip monadic asParAhead" $ zipMonadic A.fromFoldable asParAhead (==)
363− prop "zip monadic asParAhead folded" $ zipMonadic folded asParAhead (==)
364− prop "zip monadic asCoparAhead" $ zipMonadic A.fromFoldable asCoparAhead (==)
365− prop "zip monadic asCoparAhead folded" $ zipMonadic folded asCoparAhead (==)
366− prop "zip monadic asParallel" $ zipMonadic A.fromFoldable asParallel (==)
367− prop "zip monadic asParallel folded" $ zipMonadic folded asParallel (==)
357+ -- prop "zipAsyncly applicative" $ zipApplicative zipAsyncly (==)
358+ prop "zip monadic serially" $ zipMonadic A.fromFoldable serially (==)
359+ prop "zip monadic serially folded" $ zipMonadic folded serially (==)
360+ prop "zip monadic wSerially" $ zipMonadic A.fromFoldable wSerially (==)
361+ prop "zip monadic wSerially folded" $ zipMonadic folded wSerially (==)
362+ prop "zip monadic asyncly" $ zipMonadic A.fromFoldable asyncly (==)
363+ prop "zip monadic asyncly folded" $ zipMonadic folded asyncly (==)
364+ prop "zip monadic wAsyncly" $ zipMonadic A.fromFoldable wAsyncly (==)
365+ prop "zip monadic wAsyncly folded" $ zipMonadic folded wAsyncly (==)
366+ prop "zip monadic parallely" $ zipMonadic A.fromFoldable parallely (==)
367+ prop "zip monadic parallely folded" $ zipMonadic folded parallely (==)
368368
369369 describe "Monad operations" $ do
370− prop "asStream monad then" $ monadThen A.fromFoldable asStream (==)
371− prop "asCostream monad then" $ monadThen A.fromFoldable asCostream sortEq
372− prop "asParAhead monad then" $ monadThen A.fromFoldable asParAhead sortEq
373− prop "asCoparAhead monad then" $ monadThen A.fromFoldable asCoparAhead sortEq
374− prop "asParallel monad then" $ monadThen A.fromFoldable asParallel sortEq
375−
376− prop "asStream monad then folded" $ monadThen folded asStream (==)
377− prop "asCostream monad then folded" $ monadThen folded asCostream sortEq
378− prop "asParAhead monad then folded" $ monadThen folded asParAhead sortEq
379− prop "asCoparAhead monad then folded" $ monadThen folded asCoparAhead sortEq
380− prop "asParallel monad then folded" $ monadThen folded asParallel sortEq
381−
382− prop "asStream monad bind" $ monadBind A.fromFoldable asStream (==)
383− prop "asCostream monad bind" $ monadBind A.fromFoldable asCostream sortEq
384− prop "asParAhead monad bind" $ monadBind A.fromFoldable asParAhead sortEq
385− prop "asCoparAhead monad bind" $ monadBind A.fromFoldable asCoparAhead sortEq
386− prop "asParallel monad bind" $ monadBind A.fromFoldable asParallel sortEq
370+ prop "serially monad then" $ monadThen A.fromFoldable serially (==)
371+ prop "wSerially monad then" $ monadThen A.fromFoldable wSerially sortEq
372+ prop "asyncly monad then" $ monadThen A.fromFoldable asyncly sortEq
373+ prop "wAsyncly monad then" $ monadThen A.fromFoldable wAsyncly sortEq
374+ prop "parallely monad then" $ monadThen A.fromFoldable parallely sortEq
375+
376+ prop "serially monad then folded" $ monadThen folded serially (==)
377+ prop "wSerially monad then folded" $ monadThen folded wSerially sortEq
378+ prop "asyncly monad then folded" $ monadThen folded asyncly sortEq
379+ prop "wAsyncly monad then folded" $ monadThen folded wAsyncly sortEq
380+ prop "parallely monad then folded" $ monadThen folded parallely sortEq
381+
382+ prop "serially monad bind" $ monadBind A.fromFoldable serially (==)
383+ prop "wSerially monad bind" $ monadBind A.fromFoldable wSerially sortEq
384+ prop "asyncly monad bind" $ monadBind A.fromFoldable asyncly sortEq
385+ prop "wAsyncly monad bind" $ monadBind A.fromFoldable wAsyncly sortEq
386+ prop "parallely monad bind" $ monadBind A.fromFoldable parallely sortEq
387387
388388 describe "Stream transform operations" $ do
389− transformOps A.fromFoldable "asStream" asStream (==)
390− transformOps A.fromFoldable "asCostream" asCostream (==)
391− transformOps A.fromFoldable "asZipStream" asZipStream (==)
392− transformOps A.fromFoldable "asZipParallel" asZipParallel (==)
393− transformOps A.fromFoldable "asParAhead" asParAhead sortEq
394− transformOps A.fromFoldable "asCoparAhead" asCoparAhead sortEq
395− transformOps A.fromFoldable "asParallel" asParallel sortEq
396−
397− transformOps folded "asStream folded" asStream (==)
398− transformOps folded "asCostream folded" asCostream (==)
399− transformOps folded "asZipStream folded" asZipStream (==)
400− transformOps folded "asZipParallel folded" asZipParallel (==)
401− transformOps folded "asParAhead folded" asParAhead sortEq
402− transformOps folded "asCoparAhead folded" asCoparAhead sortEq
403− transformOps folded "asParallel folded" asParallel sortEq
404−
405− transformOpsWord8 A.fromFoldable "asStream" asStream
406− transformOpsWord8 A.fromFoldable "asCostream" asCostream
407− transformOpsWord8 A.fromFoldable "asZipStream" asZipStream
408− transformOpsWord8 A.fromFoldable "asZipParallel" asZipParallel
409− transformOpsWord8 A.fromFoldable "asParAhead" asParAhead
410− transformOpsWord8 A.fromFoldable "asCoparAhead" asCoparAhead
411− transformOpsWord8 A.fromFoldable "asParallel" asParallel
412−
413− transformOpsWord8 folded "asStream folded" asStream
414− transformOpsWord8 folded "asCostream folded" asCostream
415− transformOpsWord8 folded "asZipStream folded" asZipStream
416− transformOpsWord8 folded "asZipParallel folded" asZipParallel
417− transformOpsWord8 folded "asParAhead folded" asParAhead
418− transformOpsWord8 folded "asCoparAhead folded" asCoparAhead
419− transformOpsWord8 folded "asParallel folded" asParallel
389+ transformOps A.fromFoldable "serially" serially (==)
390+ transformOps A.fromFoldable "wSerially" wSerially (==)
391+ transformOps A.fromFoldable "zipSerially" zipSerially (==)
392+ transformOps A.fromFoldable "zipAsyncly" zipAsyncly (==)
393+ transformOps A.fromFoldable "asyncly" asyncly sortEq
394+ transformOps A.fromFoldable "wAsyncly" wAsyncly sortEq
395+ transformOps A.fromFoldable "parallely" parallely sortEq
396+
397+ transformOps folded "serially folded" serially (==)
398+ transformOps folded "wSerially folded" wSerially (==)
399+ transformOps folded "zipSerially folded" zipSerially (==)
400+ transformOps folded "zipAsyncly folded" zipAsyncly (==)
401+ transformOps folded "asyncly folded" asyncly sortEq
402+ transformOps folded "wAsyncly folded" wAsyncly sortEq
403+ transformOps folded "parallely folded" parallely sortEq
404+
405+ transformOpsWord8 A.fromFoldable "serially" serially
406+ transformOpsWord8 A.fromFoldable "wSerially" wSerially
407+ transformOpsWord8 A.fromFoldable "zipSerially" zipSerially
408+ transformOpsWord8 A.fromFoldable "zipAsyncly" zipAsyncly
409+ transformOpsWord8 A.fromFoldable "asyncly" asyncly
410+ transformOpsWord8 A.fromFoldable "wAsyncly" wAsyncly
411+ transformOpsWord8 A.fromFoldable "parallely" parallely
412+
413+ transformOpsWord8 folded "serially folded" serially
414+ transformOpsWord8 folded "wSerially folded" wSerially
415+ transformOpsWord8 folded "zipSerially folded" zipSerially
416+ transformOpsWord8 folded "zipAsyncly folded" zipAsyncly
417+ transformOpsWord8 folded "asyncly folded" asyncly
418+ transformOpsWord8 folded "wAsyncly folded" wAsyncly
419+ transformOpsWord8 folded "parallely folded" parallely
420420
421421 describe "Stream elimination operations" $ do
422− eliminationOps A.fromFoldable "asStream" asStream
423− eliminationOps A.fromFoldable "asCostream" asCostream
424− eliminationOps A.fromFoldable "asZipStream" asZipStream
425− eliminationOps A.fromFoldable "asZipParallel" asZipParallel
426− eliminationOps A.fromFoldable "asParAhead" asParAhead
427− eliminationOps A.fromFoldable "asCoparAhead" asCoparAhead
428− eliminationOps A.fromFoldable "asParallel" asParallel
429−
430− eliminationOps folded "asStream folded" asStream
431− eliminationOps folded "asCostream folded" asCostream
432− eliminationOps folded "asZipStream folded" asZipStream
433− eliminationOps folded "asZipParallel folded" asZipParallel
434− eliminationOps folded "asParAhead folded" asParAhead
435− eliminationOps folded "asCoparAhead folded" asCoparAhead
436− eliminationOps folded "asParallel folded" asParallel
422+ eliminationOps A.fromFoldable "serially" serially
423+ eliminationOps A.fromFoldable "wSerially" wSerially
424+ eliminationOps A.fromFoldable "zipSerially" zipSerially
425+ eliminationOps A.fromFoldable "zipAsyncly" zipAsyncly
426+ eliminationOps A.fromFoldable "asyncly" asyncly
427+ eliminationOps A.fromFoldable "wAsyncly" wAsyncly
428+ eliminationOps A.fromFoldable "parallely" parallely
429+
430+ eliminationOps folded "serially folded" serially
431+ eliminationOps folded "wSerially folded" wSerially
432+ eliminationOps folded "zipSerially folded" zipSerially
433+ eliminationOps folded "zipAsyncly folded" zipAsyncly
434+ eliminationOps folded "asyncly folded" asyncly
435+ eliminationOps folded "wAsyncly folded" wAsyncly
436+ eliminationOps folded "parallely folded" parallely
437437
438438 describe "Stream elimination operations" $ do
439− serialEliminationOps A.fromFoldable "asStream" asStream
440− serialEliminationOps A.fromFoldable "asCostream" asCostream
441− serialEliminationOps A.fromFoldable "asZipStream" asZipStream
442− serialEliminationOps A.fromFoldable "asZipParallel" asZipParallel
443−
444− serialEliminationOps folded "asStream folded" asStream
445− serialEliminationOps folded "asCostream folded" asCostream
446− serialEliminationOps folded "asZipStream folded" asZipStream
447− serialEliminationOps folded "asZipParallel folded" asZipParallel
439+ serialEliminationOps A.fromFoldable "serially" serially
440+ serialEliminationOps A.fromFoldable "wSerially" wSerially
441+ serialEliminationOps A.fromFoldable "zipSerially" zipSerially
442+ serialEliminationOps A.fromFoldable "zipAsyncly" zipAsyncly
443+
444+ serialEliminationOps folded "serially folded" serially
445+ serialEliminationOps folded "wSerially folded" wSerially
446+ serialEliminationOps folded "zipSerially folded" zipSerially
447+ serialEliminationOps folded "zipAsyncly folded" zipAsyncly
test/loops.hs+9−9
@@ -25,14 +25,14 @@ main = do
2525 x <- loopHeadA 0
2626 once $ print (x :: Int)
2727
28− putStrLn $ "\ncosplice:\n"
28+ putStrLn $ "\nwSerial:\n"
2929 runStream $ do
30− x <- (return 0 <> return 1) `cosplice` (return 100 <> return 101)
30+ x <- (return 0 <> return 1) `wSerial` (return 100 <> return 101)
3131 once $ print (x :: Int)
3232
3333 putStrLn $ "\nParallel interleave:\n"
3434 runStream $ do
35− x <- (return 0 <> return 1) `coparAhead` (return 100 <> return 101)
35+ x <- (return 0 <> return 1) `wAsync` (return 100 <> return 101)
3636 once $ print (x :: Int)
3737
3838 where
@@ -43,7 +43,7 @@ main = do
4343
4444 -- Generates a value and then loops. Can be used to generate an infinite
4545 -- stream. Interleaves the generator and the consumer.
46− loopTail :: Int -> Stream Int
46+ loopTail :: Int -> Serial Int
4747 loopTail x = do
4848 once $ putStrLn "LoopTail..."
4949 return x <> (if x < 3 then loopTail (x + 1) else nil)
@@ -51,7 +51,7 @@ main = do
5151 -- Loops and then generates a value. The consumer can run only after the
5252 -- loop has finished. An infinite generator will not let the consumer run
5353 -- at all.
54− loopHead :: Int -> Stream Int
54+ loopHead :: Int -> Serial Int
5555 loopHead x = do
5656 once $ putStrLn "LoopHead..."
5757 (if x < 3 then loopHead (x + 1) else nil) <> return x
@@ -60,15 +60,15 @@ main = do
6060-- Concurrent (multi-threaded) adaptive demand-based stream generator loops
6161-------------------------------------------------------------------------------
6262
63− loopTailA :: Int -> Stream Int
63+ loopTailA :: Int -> Serial Int
6464 loopTailA x = do
6565 once $ putStrLn "LoopTailA..."
66− return x `parAhead` (if x < 3 then loopTailA (x + 1) else nil)
66+ return x `async` (if x < 3 then loopTailA (x + 1) else nil)
6767
68− loopHeadA :: Int -> Stream Int
68+ loopHeadA :: Int -> Serial Int
6969 loopHeadA x = do
7070 once $ putStrLn "LoopHeadA..."
71− (if x < 3 then loopHeadA (x + 1) else nil) `parAhead` return x
71+ (if x < 3 then loopHeadA (x + 1) else nil) `async` return x
7272
7373-------------------------------------------------------------------------------
7474-- Parallel (fairly scheduled, multi-threaded) stream generator loops
test/nested-loops.hs+2−2
@@ -16,9 +16,9 @@ main = runStream $ do
1616
1717 -- we can just use
1818 -- parallely $ mconcat $ replicate n $ once (...)
19− loop :: String -> Int -> StreamT IO String
19+ loop :: String -> Int -> SerialT IO String
2020 loop name n = do
2121 rnd <- once (randomIO :: IO Int)
2222 let result = (name ++ show rnd)
2323 repeat = if n > 1 then loop name (n - 1) else nil
24− in (return result) `coparAhead` repeat
24+ in (return result) `wAsync` repeat
test/parallel-loops.hs+3−3
@@ -7,7 +7,7 @@ import qualified Streamly.Prelude as S
77main = do
88 hSetBuffering stdout LineBuffering
99 runStream $ do
10− x <- S.take 10 $ loop "A" `coparAhead` loop "B"
10+ x <- S.take 10 $ loop "A" `parallel` loop "B"
1111 S.once $ myThreadId >>= putStr . show
1212 >> putStr " got "
1313 >> print x
@@ -16,11 +16,11 @@ main = do
1616
1717 -- we can just use
1818 -- parallely $ cycle1 $ once (...)
19− loop :: String -> Stream (String, Int)
19+ loop :: String -> Serial (String, Int)
2020 loop name = do
2121 S.once $ threadDelay 1000000
2222 rnd <- S.once (randomIO :: IO Int)
2323 S.once $ myThreadId >>= putStr . show
2424 >> putStr " yielding "
2525 >> print rnd
26− return (name, rnd) `coparAhead` loop name
26+ return (name, rnd) `parallel` loop name