git.iko.soy/streamly
on master help sign in
rename interleave=>coserial, aparallel=>coparallel
3f638d9Harendra Kumar
benchmark/Main.hs+17−17
compare with master
unifiedsplit
@@ -41,38 +41,38 @@ main = do
41 [ bench "function style all serial" $ nfIO streamly_function_style
41 [ bench "function style all serial" $ nfIO streamly_function_style
42
42
43 , bgroup "serial bind"
43 , bgroup "serial bind"
44− [ bench "serial" $ nfIO (as (A.append))
44+ [ bench "serial" $ nfIO (as (A.serial))
45− , bench "fair serial" $ nfIO (as (A.interleave))
45+ , bench "fair serial" $ nfIO (as (A.coserial))
46− , bench "left parallel" $ nfIO (as (A.aparallel))
46+ , bench "left parallel" $ nfIO (as (A.coparallel))
47 , bench "fair parallel" $ nfIO (as (A.parallel))
47 , bench "fair parallel" $ nfIO (as (A.parallel))
48 ]
48 ]
49
49
50 , bgroup "interleaved bind"
50 , bgroup "interleaved bind"
51− [ bench "serial" $ nfIO (ai (A.append))
51+ [ bench "serial" $ nfIO (ai (A.serial))
52− , bench "fair serial" $ nfIO (ai (A.interleave))
52+ , bench "fair serial" $ nfIO (ai (A.coserial))
53− , bench "left parallel" $ nfIO (ai (A.aparallel))
53+ , bench "left parallel" $ nfIO (ai (A.coparallel))
54 , bench "fair parallel" $ nfIO (ai (A.parallel))
54 , bench "fair parallel" $ nfIO (ai (A.parallel))
55 ]
55 ]
56
56
57 , bgroup "async bind"
57 , bgroup "async bind"
58− [ bench "serial" $ nfIO (aa (A.append))
58+ [ bench "serial" $ nfIO (aa (A.serial))
59− , bench "fair serial" $ nfIO (aa (A.interleave))
59+ , bench "fair serial" $ nfIO (aa (A.coserial))
60− , bench "left parallel" $ nfIO (aa (A.aparallel))
60+ , bench "left parallel" $ nfIO (aa (A.coparallel))
61 , bench "fair parallel" $ nfIO (aa (A.parallel))
61 , bench "fair parallel" $ nfIO (aa (A.parallel))
62 ]
62 ]
63
63
64 , bgroup "parallel bind"
64 , bgroup "parallel bind"
65− [ bench "serial" $ nfIO (ap (A.append))
65+ [ bench "serial" $ nfIO (ap (A.serial))
66− , bench "fair serial" $ nfIO (ap (A.interleave))
66+ , bench "fair serial" $ nfIO (ap (A.coserial))
67− , bench "left parallel" $ nfIO (ap (A.aparallel))
67+ , bench "left parallel" $ nfIO (ap (A.coparallel))
68 , bench "fair parallel" $ nfIO (ap (A.parallel))
68 , bench "fair parallel" $ nfIO (ap (A.parallel))
69 ]
69 ]
70
70
71 -- Benchmark smallest possible actions composed together
71 -- Benchmark smallest possible actions composed together
72 , bgroup "serial bind nil"
72 , bgroup "serial bind nil"
73− [ bench "serial" $ nfIO (streamly_nil (A.append))
73+ [ bench "serial" $ nfIO (streamly_nil (A.serial))
74− , bench "fair serial" $ nfIO (streamly_nil (A.interleave))
74+ , bench "fair serial" $ nfIO (streamly_nil (A.coserial))
75− , bench "left parallel" $ nfIO (streamly_nil (A.aparallel))
75+ , bench "left parallel" $ nfIO (streamly_nil (A.coparallel))
76 , bench "fair parallel" $ nfIO (streamly_nil (A.parallel))
76 , bench "fair parallel" $ nfIO (streamly_nil (A.parallel))
77 ]
77 ]
78 ]
78 ]
@@ -143,13 +143,13 @@ streamly_serial = streamly_basic (A.toList . A.serially)
143streamly_interleaved
143streamly_interleaved
144 :: (A.InterleavedT IO Int -> A.InterleavedT IO Int -> A.InterleavedT IO Int)
144 :: (A.InterleavedT IO Int -> A.InterleavedT IO Int -> A.InterleavedT IO Int)
145 -> IO Int
145 -> IO Int
146−streamly_interleaved = streamly_basic (A.toList . A.interleaving)
146+streamly_interleaved = streamly_basic (A.toList . A.coserially)
147
147
148{-# INLINE streamly_async #-}
148{-# INLINE streamly_async #-}
149streamly_async
149streamly_async
150 :: (A.AParallelT IO Int -> A.AParallelT IO Int -> A.AParallelT IO Int)
150 :: (A.AParallelT IO Int -> A.AParallelT IO Int -> A.AParallelT IO Int)
151 -> IO Int
151 -> IO Int
152−streamly_async = streamly_basic (A.toList . A.aparallely)
152+streamly_async = streamly_basic (A.toList . A.coparallely)
153
153
154{-# INLINE streamly_parallel #-}
154{-# INLINE streamly_parallel #-}
155streamly_parallel
155streamly_parallel
examples/loops.hs+4−4
@@ -24,9 +24,9 @@ main = do
24 x <- loopHeadA 0
24 x <- loopHeadA 0
25 liftIO $ print (x :: Int)
25 liftIO $ print (x :: Int)
26
26
27− putStrLn $ "\ninterleave:\n"
27+ putStrLn $ "\ncoserial:\n"
28 runStream $ do
28 runStream $ do
29− x <- (return 0 <> return 1) `interleave` (return 100 <> return 101)
29+ x <- (return 0 <> return 1) `coserial` (return 100 <> return 101)
30 liftIO $ print (x :: Int)
30 liftIO $ print (x :: Int)
31
31
32 putStrLn $ "\nParallel interleave:\n"
32 putStrLn $ "\nParallel interleave:\n"
@@ -71,12 +71,12 @@ main = do
71 loopTailA :: Int -> SerialT IO Int
71 loopTailA :: Int -> SerialT IO Int
72 loopTailA x = do
72 loopTailA x = do
73 liftIO $ putStrLn "LoopTailA..."
73 liftIO $ putStrLn "LoopTailA..."
74− return x `aparallel` (if x < 3 then loopTailA (x + 1) else empty)
74+ return x `coparallel` (if x < 3 then loopTailA (x + 1) else empty)
75
75
76 loopHeadA :: Int -> SerialT IO Int
76 loopHeadA :: Int -> SerialT IO Int
77 loopHeadA x = do
77 loopHeadA x = do
78 liftIO $ putStrLn "LoopHeadA..."
78 liftIO $ putStrLn "LoopHeadA..."
79− (if x < 3 then loopHeadA (x + 1) else empty) `aparallel` return x
79+ (if x < 3 then loopHeadA (x + 1) else empty) `coparallel` return x
80
80
81-------------------------------------------------------------------------------
81-------------------------------------------------------------------------------
82-- Parallel (fairly scheduled, multi-threaded) stream generator loops
82-- Parallel (fairly scheduled, multi-threaded) stream generator loops
src/Streamly.hs+6−6
@@ -32,9 +32,9 @@ module Streamly
32
32
33 -- * Polymorphic Sum Operations
33 -- * Polymorphic Sum Operations
34 -- $sum
34 -- $sum
35− , append
35+ , serial
36− , interleave
36+ , coserial
37− , aparallel
37+ , coparallel
38 , parallel
38 , parallel
39
39
40 -- * Transformation
40 -- * Transformation
@@ -43,8 +43,8 @@ module Streamly
43 -- * Stream Type Adapters
43 -- * Stream Type Adapters
44 -- $adapters
44 -- $adapters
45 , serially
45 , serially
46− , interleaving
46+ , coserially
47− , aparallely
47+ , coparallely
48 , parallely
48 , parallely
49 , zipping
49 , zipping
50 , zippingAsync
50 , zippingAsync
@@ -193,7 +193,7 @@ import Control.Monad.Trans.Class (MonadTrans (..))
193-- To adapt from one monomorphic type (e.g. 'ParallelT') to another monomorphic
193-- To adapt from one monomorphic type (e.g. 'ParallelT') to another monomorphic
194-- type (e.g. 'SerialT') use the 'adapt' combinator. To give a polymorphic code
194-- type (e.g. 'SerialT') use the 'adapt' combinator. To give a polymorphic code
195-- a specific interpretation or to adapt a specific type to a polymorphic type
195-- a specific interpretation or to adapt a specific type to a polymorphic type
196−-- use the type specific combinators e.g. 'parallely' or 'interleaving'. You
196+-- use the type specific combinators e.g. 'parallely' or 'coserially'. You
197-- cannot adapt polymorphic code to polymorphic code, as it would not know
197-- cannot adapt polymorphic code to polymorphic code, as it would not know
198-- which specific type you are converting from or to. If you see a an
198-- which specific type you are converting from or to. If you see a an
199-- @ambiguous type variable@ error then most likely you are using 'adapt'
199-- @ambiguous type variable@ error then most likely you are using 'adapt'
src/Streamly/Core.hs+12−12
@@ -29,9 +29,9 @@ module Streamly.Core
29 , nil
29 , nil
30
30
31 -- * Semigroup Style Composition
31 -- * Semigroup Style Composition
32− , append
32+ , serial
33− , interleave
33+ , coserial
34− , aparallel
34+ , coparallel
35 , parallel
35 , parallel
36
36
37 -- * Alternative
37 -- * Alternative
@@ -242,8 +242,8 @@ nil = Stream $ \_ stp _ -> stp
242
242
243-- | Concatenates two streams sequentially i.e. the first stream is
243-- | Concatenates two streams sequentially i.e. the first stream is
244-- exhausted completely before yielding any element from the second stream.
244-- exhausted completely before yielding any element from the second stream.
245−append :: Stream m a -> Stream m a -> Stream m a
245+serial :: Stream m a -> Stream m a -> Stream m a
246−append m1 m2 = go m1
246+serial m1 m2 = go m1
247 where
247 where
248 go (Stream m) = Stream $ \_ stp yld ->
248 go (Stream m) = Stream $ \_ stp yld ->
249 let stop = (runStream m2) Nothing stp yld
249 let stop = (runStream m2) Nothing stp yld
@@ -252,7 +252,7 @@ append m1 m2 = go m1
252 in m Nothing stop yield
252 in m Nothing stop yield
253
253
254instance Semigroup (Stream m a) where
254instance Semigroup (Stream m a) where
255− (<>) = append
255+ (<>) = serial
256
256
257------------------------------------------------------------------------------
257------------------------------------------------------------------------------
258-- Monoid
258-- Monoid
@@ -266,11 +266,11 @@ instance Monoid (Stream m a) where
266-- Interleave
266-- Interleave
267------------------------------------------------------------------------------
267------------------------------------------------------------------------------
268
268
269−interleave :: Stream m a -> Stream m a -> Stream m a
269+coserial :: Stream m a -> Stream m a -> Stream m a
270−interleave m1 m2 = Stream $ \_ stp yld -> do
270+coserial m1 m2 = Stream $ \_ stp yld -> do
271 let stop = (runStream m2) Nothing stp yld
271 let stop = (runStream m2) Nothing stp yld
272 yield a Nothing = yld a (Just m2)
272 yield a Nothing = yld a (Just m2)
273− yield a (Just r) = yld a (Just (interleave m2 r))
273+ yield a (Just r) = yld a (Just (coserial m2 r))
274 (runStream m1) Nothing stop yield
274 (runStream m1) Nothing stop yield
275
275
276------------------------------------------------------------------------------
276------------------------------------------------------------------------------
@@ -608,9 +608,9 @@ joinStreamVar2 style m1 m2 = Stream $ \st stp yld ->
608-- Semigroup and Monoid style compositions for parallel actions
608-- Semigroup and Monoid style compositions for parallel actions
609------------------------------------------------------------------------------
609------------------------------------------------------------------------------
610
610
611−{-# INLINE aparallel #-}
611+{-# INLINE coparallel #-}
612−aparallel :: MonadAsync m => Stream m a -> Stream m a -> Stream m a
612+coparallel :: MonadAsync m => Stream m a -> Stream m a -> Stream m a
613−aparallel = joinStreamVar2 (SVarStyle Disjunction LIFO)
613+coparallel = joinStreamVar2 (SVarStyle Disjunction LIFO)
614
614
615{-# INLINE parallel #-}
615{-# INLINE parallel #-}
616parallel :: MonadAsync m => Stream m a -> Stream m a -> Stream m a
616parallel :: MonadAsync m => Stream m a -> Stream m a -> Stream m a
src/Streamly/Examples/ListDirRecursive.hs+3−3
@@ -3,15 +3,15 @@ module Streamly.Examples.ListDirRecursive where
3import Control.Monad.IO.Class (liftIO)
3import Control.Monad.IO.Class (liftIO)
4import Path.IO (listDir, getCurrentDir)
4import Path.IO (listDir, getCurrentDir)
5import System.IO (stdout, hSetBuffering, BufferMode(LineBuffering))
5import System.IO (stdout, hSetBuffering, BufferMode(LineBuffering))
6−import Streamly (runStream, aparallely)
6+import Streamly (runStream, coparallely)
7
7
8-- | This example demonstrates that there is little difference between regular
8-- | This example demonstrates that there is little difference between regular
9-- IO code and concurrent streamly code. You can just remove
9-- IO code and concurrent streamly code. You can just remove
10−-- 'runStream . aparallely' and this becomes your regular IO code.
10+-- 'runStream . coparallely' and this becomes your regular IO code.
11listDirRecursive :: IO ()
11listDirRecursive :: IO ()
12listDirRecursive = do
12listDirRecursive = do
13 hSetBuffering stdout LineBuffering
13 hSetBuffering stdout LineBuffering
14− runStream . aparallely $ getCurrentDir >>= readdir
14+ runStream . coparallely $ getCurrentDir >>= readdir
15 where readdir d = do
15 where readdir d = do
16 (ds, fs) <- liftIO $ listDir d
16 (ds, fs) <- liftIO $ listDir d
17 liftIO $ mapM_ putStrLn $ map show fs ++ map show ds
17 liftIO $ mapM_ putStrLn $ map show fs ++ map show ds
src/Streamly/Streams.hs+36−36
@@ -48,9 +48,9 @@ module Streamly.Streams
48 , async
48 , async
49
49
50 -- * Merging Streams
50 -- * Merging Streams
51− , append
51+ , serial
52− , interleave
52+ , coserial
53− , aparallel
53+ , coparallel
54 , parallel
54 , parallel
55 , (<=>) --deprecated
55 , (<=>) --deprecated
56 , (<|) --deprecated
56 , (<|) --deprecated
@@ -68,8 +68,8 @@ module Streamly.Streams
68
68
69 -- * Type Adapters
69 -- * Type Adapters
70 , serially
70 , serially
71− , interleaving
71+ , coserially
72− , aparallely
72+ , coparallely
73 , asyncly -- deprecated
73 , asyncly -- deprecated
74 , parallely
74 , parallely
75 , zipping
75 , zipping
@@ -336,9 +336,9 @@ type StreamT = SerialT
336-- | Polymorphic version of the 'Semigroup' operation '<>' of 'SerialT'.
336-- | Polymorphic version of the 'Semigroup' operation '<>' of 'SerialT'.
337-- Appends two streams sequentially, yielding all elements from the first
337-- Appends two streams sequentially, yielding all elements from the first
338-- stream, and then all elements from the second stream.
338-- stream, and then all elements from the second stream.
339−{-# INLINE append #-}
339+{-# INLINE serial #-}
340−append :: IsStream t => t m a -> t m a -> t m a
340+serial :: IsStream t => t m a -> t m a -> t m a
341−append m1 m2 = fromStream $ S.append (toStream m1) (toStream m2)
341+serial m1 m2 = fromStream $ S.serial (toStream m1) (toStream m2)
342
342
343------------------------------------------------------------------------------
343------------------------------------------------------------------------------
344-- Monad
344-- Monad
@@ -469,20 +469,20 @@ instance IsStream InterleavedT where
469
469
470-- | Polymorphic version of the 'Semigroup' operation '<>' of 'InterleavedT'.
470-- | Polymorphic version of the 'Semigroup' operation '<>' of 'InterleavedT'.
471-- Interleaves two streams, yielding one element from each stream alternately.
471-- Interleaves two streams, yielding one element from each stream alternately.
472−{-# INLINE interleave #-}
472+{-# INLINE coserial #-}
473−interleave :: IsStream t => t m a -> t m a -> t m a
473+coserial :: IsStream t => t m a -> t m a -> t m a
474−interleave m1 m2 = fromStream $ S.interleave (toStream m1) (toStream m2)
474+coserial m1 m2 = fromStream $ S.coserial (toStream m1) (toStream m2)
475
475
476instance Semigroup (InterleavedT m a) where
476instance Semigroup (InterleavedT m a) where
477− (<>) = interleave
477+ (<>) = coserial
478
478
479infixr 5 <=>
479infixr 5 <=>
480
480
481−-- | Same as 'interleave'.
481+-- | Same as 'coserial'.
482−{-# Deprecated (<=>) "Please use '<>' of InterleavedT or 'interleave' instead." #-}
482+{-# DEPRECATED (<=>) "Please use 'coserial' instead." #-}
483{-# INLINE (<=>) #-}
483{-# INLINE (<=>) #-}
484(<=>) :: IsStream t => t m a -> t m a -> t m a
484(<=>) :: IsStream t => t m a -> t m a -> t m a
485−(<=>) = interleave
485+(<=>) = coserial
486
486
487------------------------------------------------------------------------------
487------------------------------------------------------------------------------
488-- Monad
488-- Monad
@@ -570,7 +570,7 @@ instance (Monad m, Floating a) => Floating (InterleavedT m a) where
570-- enough for the consumer.
570-- enough for the consumer.
571--
571--
572-- @
572-- @
573−-- main = ('toList' . 'aparallely' $ (fromFoldable [1,2]) \<> (fromFoldable [3,4])) >>= print
573+-- main = ('toList' . 'coparallely' $ (fromFoldable [1,2]) \<> (fromFoldable [3,4])) >>= print
574-- @
574-- @
575-- @
575-- @
576-- [1,2,3,4]
576-- [1,2,3,4]
@@ -585,7 +585,7 @@ instance (Monad m, Floating a) => Floating (InterleavedT m a) where
585-- import "Streamly"
585-- import "Streamly"
586-- import Control.Concurrent
586-- import Control.Concurrent
587--
587--
588−-- main = 'runStream' . 'aparallely' $ do
588+-- main = 'runStream' . 'coparallely' $ do
589-- n <- return 3 \<\> return 2 \<\> return 1
589-- n <- return 3 \<\> return 2 \<\> return 1
590-- liftIO $ do
590-- liftIO $ do
591-- threadDelay (n * 1000000)
591-- threadDelay (n * 1000000)
@@ -629,18 +629,18 @@ instance IsStream AParallelT where
629-- | Polymorphic version of the 'Semigroup' operation '<>' of 'AParallelT', but
629-- | Polymorphic version of the 'Semigroup' operation '<>' of 'AParallelT', but
630-- polymorphic. Merges two streams possibly concurrently, preferring the
630-- polymorphic. Merges two streams possibly concurrently, preferring the
631-- elements from the left one when available.
631-- elements from the left one when available.
632−{-# INLINE aparallel #-}
632+{-# INLINE coparallel #-}
633−aparallel :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
633+coparallel :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
634−aparallel m1 m2 = fromStream $ S.aparallel (toStream m1) (toStream m2)
634+coparallel m1 m2 = fromStream $ S.coparallel (toStream m1) (toStream m2)
635
635
636instance MonadAsync m => Semigroup (AParallelT m a) where
636instance MonadAsync m => Semigroup (AParallelT m a) where
637− (<>) = aparallel
637+ (<>) = coparallel
638
638
639−-- | Same as 'aparallel'.
639+-- | Same as 'coparallel'.
640−{-# DEPRECATED (<|) "Please use 'aparallel' instead." #-}
640+{-# DEPRECATED (<|) "Please use 'coparallel' instead." #-}
641{-# INLINE (<|) #-}
641{-# INLINE (<|) #-}
642(<|) :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
642(<|) :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
643−(<|) = aparallel
643+(<|) = coparallel
644
644
645------------------------------------------------------------------------------
645------------------------------------------------------------------------------
646-- Monad
646-- Monad
@@ -1074,17 +1074,17 @@ serially :: IsStream t => SerialT m a -> t m a
1074serially = adapt
1074serially = adapt
1075
1075
1076-- | Fix the type of a polymorphic stream as 'InterleavedT'.
1076-- | Fix the type of a polymorphic stream as 'InterleavedT'.
1077−interleaving :: IsStream t => InterleavedT m a -> t m a
1077+coserially :: IsStream t => InterleavedT m a -> t m a
1078−interleaving = adapt
1078+coserially = adapt
1079
1079
1080-- | Fix the type of a polymorphic stream as 'AParallelT'.
1080-- | Fix the type of a polymorphic stream as 'AParallelT'.
1081−aparallely :: IsStream t => AParallelT m a -> t m a
1081+coparallely :: IsStream t => AParallelT m a -> t m a
1082−aparallely = adapt
1082+coparallely = adapt
1083
1083
1084−-- | Same as 'aparallely'.
1084+-- | Same as 'coparallely'.
1085−{-# DEPRECATED asyncly "Please use aparallely instead." #-}
1085+{-# DEPRECATED asyncly "Please use coparallely instead." #-}
1086asyncly :: IsStream t => AParallelT m a -> t m a
1086asyncly :: IsStream t => AParallelT m a -> t m a
1087−asyncly = aparallely
1087+asyncly = coparallely
1088
1088
1089-- | Fix the type of a polymorphic stream as 'ParallelT'.
1089-- | Fix the type of a polymorphic stream as 'ParallelT'.
1090parallely :: IsStream t => ParallelT m a -> t m a
1090parallely :: IsStream t => ParallelT m a -> t m a
@@ -1107,15 +1107,15 @@ zippingAsync = adapt
1107runStreamT :: Monad m => SerialT m a -> m ()
1107runStreamT :: Monad m => SerialT m a -> m ()
1108runStreamT = runStream
1108runStreamT = runStream
1109
1109
1110−-- | Same as @runStream . interleaving@.
1110+-- | Same as @runStream . coserially@.
1111{-# DEPRECATED runInterleavedT "Please use 'runStream . interleaving' instead." #-}
1111{-# DEPRECATED runInterleavedT "Please use 'runStream . interleaving' instead." #-}
1112runInterleavedT :: Monad m => InterleavedT m a -> m ()
1112runInterleavedT :: Monad m => InterleavedT m a -> m ()
1113−runInterleavedT = runStream . interleaving
1113+runInterleavedT = runStream . coserially
1114
1114
1115−-- | Same as @runStream . aparallely@.
1115+-- | Same as @runStream . coparallely@.
1116−{-# DEPRECATED runAsyncT "Please use 'runStream . aparallely' instead." #-}
1116+{-# DEPRECATED runAsyncT "Please use 'runStream . coparallely' instead." #-}
1117runAsyncT :: Monad m => AParallelT m a -> m ()
1117runAsyncT :: Monad m => AParallelT m a -> m ()
1118−runAsyncT = runStream . aparallely
1118+runAsyncT = runStream . coparallely
1119
1119
1120-- | Same as @runStream . parallely@.
1120-- | Same as @runStream . parallely@.
1121{-# DEPRECATED runParallelT "Please use 'runStream . parallely' instead." #-}
1121{-# DEPRECATED runParallelT "Please use 'runStream . parallely' instead." #-}
test/Main.hs+38−38
@@ -20,10 +20,10 @@ toListSerial :: SerialT IO a -> IO [a]
20toListSerial = A.toList . serially
20toListSerial = A.toList . serially
21
21
22toListInterleaved :: InterleavedT IO a -> IO [a]
22toListInterleaved :: InterleavedT IO a -> IO [a]
23−toListInterleaved = A.toList . interleaving
23+toListInterleaved = A.toList . coserially
24
24
25toListAsync :: AParallelT IO a -> IO [a]
25toListAsync :: AParallelT IO a -> IO [a]
26−toListAsync = A.toList . aparallely
26+toListAsync = A.toList . coparallely
27
27
28toListParallel :: ParallelT IO a -> IO [a]
28toListParallel :: ParallelT IO a -> IO [a]
29toListParallel = A.toList . parallely
29toListParallel = A.toList . parallely
@@ -88,8 +88,8 @@ main = hspec $ do
88 ---------------------------------------------------------------------------
88 ---------------------------------------------------------------------------
89
89
90 describe "Serial Composition" $ compose serially mempty id
90 describe "Serial Composition" $ compose serially mempty id
91− describe "Interleaved Composition" $ compose interleaving mempty sort
91+ describe "Interleaved Composition" $ compose coserially mempty sort
92− describe "Left biased parallel Composition" $ compose aparallely mempty sort
92+ describe "Left biased parallel Composition" $ compose coparallely mempty sort
93 describe "Fair parallel Composition" $ compose parallely mempty sort
93 describe "Fair parallel Composition" $ compose parallely mempty sort
94 describe "Semigroup Composition for ZipSerial" $ compose zipping mempty id
94 describe "Semigroup Composition for ZipSerial" $ compose zipping mempty id
95 describe "Semigroup Composition for ZipAsync" $ compose zippingAsync mempty id
95 describe "Semigroup Composition for ZipAsync" $ compose zippingAsync mempty id
@@ -98,9 +98,9 @@ main = hspec $ do
98 -- Monoidal Composition ordering checks
98 -- Monoidal Composition ordering checks
99 ---------------------------------------------------------------------------
99 ---------------------------------------------------------------------------
100
100
101− describe "Serial interleaved ordering check" $ interleaveCheck interleaving
101+ describe "Serial interleaved ordering check" $ interleaveCheck coserially
102 describe "Parallel interleaved ordering check" $ interleaveCheck parallely
102 describe "Parallel interleaved ordering check" $ interleaveCheck parallely
103− describe "Left biased parallel time order check" $ parallelCheck aparallely
103+ describe "Left biased parallel time order check" $ parallelCheck coparallely
104 describe "Fair parallel time order check" $ parallelCheck parallely
104 describe "Fair parallel time order check" $ parallelCheck parallely
105
105
106 ---------------------------------------------------------------------------
106 ---------------------------------------------------------------------------
@@ -112,7 +112,7 @@ main = hspec $ do
112
112
113 describe "<> and <=>" $ composeAndComposeSimple
113 describe "<> and <=>" $ composeAndComposeSimple
114 serially
114 serially
115− interleaving
115+ coserially
116 ([ [1 .. 9]
116 ([ [1 .. 9]
117 , [1 .. 9]
117 , [1 .. 9]
118 , [1, 3, 2, 4, 6, 5, 7, 9, 8]
118 , [1, 3, 2, 4, 6, 5, 7, 9, 8]
@@ -120,8 +120,8 @@ main = hspec $ do
120 ])
120 ])
121
121
122 describe "<=> and <=>" $ composeAndComposeSimple
122 describe "<=> and <=>" $ composeAndComposeSimple
123− interleaving
123+ coserially
124− interleaving
124+ coserially
125 ([ [1, 4, 2, 7, 3, 5, 8, 6, 9]
125 ([ [1, 4, 2, 7, 3, 5, 8, 6, 9]
126 , [1, 7, 4, 8, 2, 9, 5, 3, 6]
126 , [1, 7, 4, 8, 2, 9, 5, 3, 6]
127 , [1, 4, 3, 7, 2, 6, 9, 5, 8]
127 , [1, 4, 3, 7, 2, 6, 9, 5, 8]
@@ -129,7 +129,7 @@ main = hspec $ do
129 ])
129 ])
130
130
131 describe "<=> and <>" $ composeAndComposeSimple
131 describe "<=> and <>" $ composeAndComposeSimple
132− interleaving
132+ coserially
133 serially
133 serially
134 ([ [1, 4, 2, 7, 3, 5, 8, 6, 9]
134 ([ [1, 4, 2, 7, 3, 5, 8, 6, 9]
135 , [1, 7, 4, 8, 2, 9, 5, 3, 6]
135 , [1, 7, 4, 8, 2, 9, 5, 3, 6]
@@ -183,7 +183,7 @@ main = hspec $ do
183 ---------------------------------------------------------------------------
183 ---------------------------------------------------------------------------
184
184
185 describe "Serial loops (<>)" $ loops serially id reverse
185 describe "Serial loops (<>)" $ loops serially id reverse
186− describe "Left biased parallel loops (<|)" $ loops aparallely sort sort
186+ describe "Left biased parallel loops (<|)" $ loops coparallely sort sort
187 describe "Fair parallel loops (<|>)" $ loops parallely sort sort
187 describe "Fair parallel loops (<|>)" $ loops parallely sort sort
188
188
189 ---------------------------------------------------------------------------
189 ---------------------------------------------------------------------------
@@ -191,23 +191,23 @@ main = hspec $ do
191 ---------------------------------------------------------------------------
191 ---------------------------------------------------------------------------
192
192
193 describe "Bind and compose1" $ bindAndComposeSimple serially serially
193 describe "Bind and compose1" $ bindAndComposeSimple serially serially
194− describe "Bind and compose2" $ bindAndComposeSimple serially interleaving
194+ describe "Bind and compose2" $ bindAndComposeSimple serially coserially
195− describe "Bind and compose3" $ bindAndComposeSimple serially aparallely
195+ describe "Bind and compose3" $ bindAndComposeSimple serially coparallely
196 describe "Bind and compose4" $ bindAndComposeSimple serially parallely
196 describe "Bind and compose4" $ bindAndComposeSimple serially parallely
197
197
198− describe "Bind and compose1" $ bindAndComposeSimple interleaving serially
198+ describe "Bind and compose1" $ bindAndComposeSimple coserially serially
199− describe "Bind and compose2" $ bindAndComposeSimple interleaving interleaving
199+ describe "Bind and compose2" $ bindAndComposeSimple coserially coserially
200− describe "Bind and compose3" $ bindAndComposeSimple interleaving aparallely
200+ describe "Bind and compose3" $ bindAndComposeSimple coserially coparallely
201− describe "Bind and compose4" $ bindAndComposeSimple interleaving parallely
201+ describe "Bind and compose4" $ bindAndComposeSimple coserially parallely
202
202
203− describe "Bind and compose1" $ bindAndComposeSimple aparallely serially
203+ describe "Bind and compose1" $ bindAndComposeSimple coparallely serially
204− describe "Bind and compose2" $ bindAndComposeSimple aparallely interleaving
204+ describe "Bind and compose2" $ bindAndComposeSimple coparallely coserially
205− describe "Bind and compose3" $ bindAndComposeSimple aparallely aparallely
205+ describe "Bind and compose3" $ bindAndComposeSimple coparallely coparallely
206− describe "Bind and compose4" $ bindAndComposeSimple aparallely parallely
206+ describe "Bind and compose4" $ bindAndComposeSimple coparallely parallely
207
207
208 describe "Bind and compose1" $ bindAndComposeSimple parallely serially
208 describe "Bind and compose1" $ bindAndComposeSimple parallely serially
209− describe "Bind and compose2" $ bindAndComposeSimple parallely interleaving
209+ describe "Bind and compose2" $ bindAndComposeSimple parallely coserially
210− describe "Bind and compose3" $ bindAndComposeSimple parallely aparallely
210+ describe "Bind and compose3" $ bindAndComposeSimple parallely coparallely
211 describe "Bind and compose4" $ bindAndComposeSimple parallely parallely
211 describe "Bind and compose4" $ bindAndComposeSimple parallely parallely
212
212
213 let fldr, fldl :: (IsStream t, Semigroup (t IO Int)) => [t IO Int] -> t IO Int
213 let fldr, fldl :: (IsStream t, Semigroup (t IO Int)) => [t IO Int] -> t IO Int
@@ -217,36 +217,36 @@ main = hspec $ do
217 forM_ [fldr, fldl] $ \k ->
217 forM_ [fldr, fldl] $ \k ->
218 describe "Bind and compose" $ bindAndComposeHierarchy serially serially k
218 describe "Bind and compose" $ bindAndComposeHierarchy serially serially k
219 forM_ [fldr, fldl] $ \k ->
219 forM_ [fldr, fldl] $ \k ->
220− describe "Bind and compose" $ bindAndComposeHierarchy serially interleaving k
220+ describe "Bind and compose" $ bindAndComposeHierarchy serially coserially k
221 forM_ [fldr, fldl] $ \k ->
221 forM_ [fldr, fldl] $ \k ->
222− describe "Bind and compose" $ bindAndComposeHierarchy serially aparallely k
222+ describe "Bind and compose" $ bindAndComposeHierarchy serially coparallely k
223 forM_ [fldr, fldl] $ \k ->
223 forM_ [fldr, fldl] $ \k ->
224 describe "Bind and compose" $ bindAndComposeHierarchy serially parallely k
224 describe "Bind and compose" $ bindAndComposeHierarchy serially parallely k
225
225
226 forM_ [fldr, fldl] $ \k ->
226 forM_ [fldr, fldl] $ \k ->
227− describe "Bind and compose" $ bindAndComposeHierarchy interleaving serially k
227+ describe "Bind and compose" $ bindAndComposeHierarchy coserially serially k
228 forM_ [fldr, fldl] $ \k ->
228 forM_ [fldr, fldl] $ \k ->
229− describe "Bind and compose" $ bindAndComposeHierarchy interleaving interleaving k
229+ describe "Bind and compose" $ bindAndComposeHierarchy coserially coserially k
230 forM_ [fldr, fldl] $ \k ->
230 forM_ [fldr, fldl] $ \k ->
231− describe "Bind and compose" $ bindAndComposeHierarchy interleaving aparallely k
231+ describe "Bind and compose" $ bindAndComposeHierarchy coserially coparallely k
232 forM_ [fldr, fldl] $ \k ->
232 forM_ [fldr, fldl] $ \k ->
233− describe "Bind and compose" $ bindAndComposeHierarchy interleaving parallely k
233+ describe "Bind and compose" $ bindAndComposeHierarchy coserially parallely k
234
234
235 forM_ [fldr, fldl] $ \k ->
235 forM_ [fldr, fldl] $ \k ->
236− describe "Bind and compose" $ bindAndComposeHierarchy aparallely serially k
236+ describe "Bind and compose" $ bindAndComposeHierarchy coparallely serially k
237 forM_ [fldr, fldl] $ \k ->
237 forM_ [fldr, fldl] $ \k ->
238− describe "Bind and compose" $ bindAndComposeHierarchy aparallely interleaving k
238+ describe "Bind and compose" $ bindAndComposeHierarchy coparallely coserially k
239 forM_ [fldr, fldl] $ \k ->
239 forM_ [fldr, fldl] $ \k ->
240− describe "Bind and compose" $ bindAndComposeHierarchy aparallely aparallely k
240+ describe "Bind and compose" $ bindAndComposeHierarchy coparallely coparallely k
241 forM_ [fldr, fldl] $ \k ->
241 forM_ [fldr, fldl] $ \k ->
242− describe "Bind and compose" $ bindAndComposeHierarchy aparallely parallely k
242+ describe "Bind and compose" $ bindAndComposeHierarchy coparallely parallely k
243
243
244 forM_ [fldr, fldl] $ \k ->
244 forM_ [fldr, fldl] $ \k ->
245 describe "Bind and compose" $ bindAndComposeHierarchy parallely serially k
245 describe "Bind and compose" $ bindAndComposeHierarchy parallely serially k
246 forM_ [fldr, fldl] $ \k ->
246 forM_ [fldr, fldl] $ \k ->
247− describe "Bind and compose" $ bindAndComposeHierarchy parallely interleaving k
247+ describe "Bind and compose" $ bindAndComposeHierarchy parallely coserially k
248 forM_ [fldr, fldl] $ \k ->
248 forM_ [fldr, fldl] $ \k ->
249− describe "Bind and compose" $ bindAndComposeHierarchy parallely aparallely k
249+ describe "Bind and compose" $ bindAndComposeHierarchy parallely coparallely k
250 forM_ [fldr, fldl] $ \k ->
250 forM_ [fldr, fldl] $ \k ->
251 describe "Bind and compose" $ bindAndComposeHierarchy parallely parallely k
251 describe "Bind and compose" $ bindAndComposeHierarchy parallely parallely k
252
252
@@ -553,11 +553,11 @@ mixedOps = do
553 x1 <- parallely $ return 1 <> return 2
553 x1 <- parallely $ return 1 <> return 2
554 liftIO $ return ()
554 liftIO $ return ()
555 liftIO $ putStr ""
555 liftIO $ putStr ""
556− y1 <- aparallely $ return 1 <> return 2
556+ y1 <- coparallely $ return 1 <> return 2
557 z1 <- do
557 z1 <- do
558 x11 <- return 1 <> return 2
558 x11 <- return 1 <> return 2
559− y11 <- aparallely $ return 1 <> return 2
559+ y11 <- coparallely $ return 1 <> return 2
560− z11 <- interleaving $ return 1 <> return 2
560+ z11 <- coserially $ return 1 <> return 2
561 liftIO $ return ()
561 liftIO $ return ()
562 liftIO $ putStr ""
562 liftIO $ putStr ""
563 return (x11 + y11 + z11)
563 return (x11 + y11 + z11)
test/Prop.hs+34−34
@@ -316,10 +316,10 @@ main = hspec $ do
316 describe "Functor operations" $ do
316 describe "Functor operations" $ do
317 functorOps A.fromFoldable "serially" serially (==)
317 functorOps A.fromFoldable "serially" serially (==)
318 functorOps folded "serially folded" serially (==)
318 functorOps folded "serially folded" serially (==)
319− functorOps A.fromFoldable "interleaving" interleaving (==)
319+ functorOps A.fromFoldable "coserially" coserially (==)
320− functorOps folded "interleaving folded" interleaving (==)
320+ functorOps folded "coserially folded" coserially (==)
321− functorOps A.fromFoldable "aparallely" aparallely sortEq
321+ functorOps A.fromFoldable "coparallely" coparallely sortEq
322− functorOps folded "aparallely folded" aparallely sortEq
322+ functorOps folded "coparallely folded" coparallely sortEq
323 functorOps A.fromFoldable "parallely" parallely sortEq
323 functorOps A.fromFoldable "parallely" parallely sortEq
324 functorOps folded "parallely folded" parallely sortEq
324 functorOps folded "parallely folded" parallely sortEq
325 functorOps A.fromFoldable "zipping" zipping (==)
325 functorOps A.fromFoldable "zipping" zipping (==)
@@ -329,8 +329,8 @@ main = hspec $ do
329
329
330 describe "Semigroup operations" $ do
330 describe "Semigroup operations" $ do
331 semigroupOps "serially" serially (==)
331 semigroupOps "serially" serially (==)
332− semigroupOps "interleaving" interleaving (==)
332+ semigroupOps "coserially" coserially (==)
333− semigroupOps "aparallely" aparallely sortEq
333+ semigroupOps "coparallely" coparallely sortEq
334 semigroupOps "parallely" parallely sortEq
334 semigroupOps "parallely" parallely sortEq
335 semigroupOps "zipping" zipping (==)
335 semigroupOps "zipping" zipping (==)
336 semigroupOps "zippingAsync" zippingAsync (==)
336 semigroupOps "zippingAsync" zippingAsync (==)
@@ -341,10 +341,10 @@ main = hspec $ do
341 -- XXX applicative with three arguments
341 -- XXX applicative with three arguments
342 prop "serially applicative" $ applicativeOps A.fromFoldable serially (==)
342 prop "serially applicative" $ applicativeOps A.fromFoldable serially (==)
343 prop "serially applicative folded" $ applicativeOps folded serially (==)
343 prop "serially applicative folded" $ applicativeOps folded serially (==)
344− prop "interleaving applicative" $ applicativeOps A.fromFoldable interleaving sortEq
344+ prop "coserially applicative" $ applicativeOps A.fromFoldable coserially sortEq
345− prop "interleaving applicative folded" $ applicativeOps folded interleaving sortEq
345+ prop "coserially applicative folded" $ applicativeOps folded coserially sortEq
346− prop "aparallely applicative" $ applicativeOps A.fromFoldable aparallely sortEq
346+ prop "coparallely applicative" $ applicativeOps A.fromFoldable coparallely sortEq
347− prop "aparallely applicative folded" $ applicativeOps folded aparallely sortEq
347+ prop "coparallely applicative folded" $ applicativeOps folded coparallely sortEq
348 prop "parallely applicative folded" $ applicativeOps folded parallely sortEq
348 prop "parallely applicative folded" $ applicativeOps folded parallely sortEq
349
349
350 describe "Zip operations" $ do
350 describe "Zip operations" $ do
@@ -353,80 +353,80 @@ main = hspec $ do
353 -- prop "zippingAsync applicative" $ zipApplicative zippingAsync (==)
353 -- prop "zippingAsync applicative" $ zipApplicative zippingAsync (==)
354 prop "zip monadic serially" $ zipMonadic A.fromFoldable serially (==)
354 prop "zip monadic serially" $ zipMonadic A.fromFoldable serially (==)
355 prop "zip monadic serially folded" $ zipMonadic folded serially (==)
355 prop "zip monadic serially folded" $ zipMonadic folded serially (==)
356− prop "zip monadic interleaving" $ zipMonadic A.fromFoldable interleaving (==)
356+ prop "zip monadic coserially" $ zipMonadic A.fromFoldable coserially (==)
357− prop "zip monadic interleaving folded" $ zipMonadic folded interleaving (==)
357+ prop "zip monadic coserially folded" $ zipMonadic folded coserially (==)
358− prop "zip monadic aparallely" $ zipMonadic A.fromFoldable aparallely (==)
358+ prop "zip monadic coparallely" $ zipMonadic A.fromFoldable coparallely (==)
359− prop "zip monadic aparallely folded" $ zipMonadic folded aparallely (==)
359+ prop "zip monadic coparallely folded" $ zipMonadic folded coparallely (==)
360 prop "zip monadic parallely" $ zipMonadic A.fromFoldable parallely (==)
360 prop "zip monadic parallely" $ zipMonadic A.fromFoldable parallely (==)
361 prop "zip monadic parallely folded" $ zipMonadic folded parallely (==)
361 prop "zip monadic parallely folded" $ zipMonadic folded parallely (==)
362
362
363 describe "Monad operations" $ do
363 describe "Monad operations" $ do
364 prop "serially monad then" $ monadThen A.fromFoldable serially (==)
364 prop "serially monad then" $ monadThen A.fromFoldable serially (==)
365− prop "interleaving monad then" $ monadThen A.fromFoldable interleaving sortEq
365+ prop "coserially monad then" $ monadThen A.fromFoldable coserially sortEq
366− prop "aparallely monad then" $ monadThen A.fromFoldable aparallely sortEq
366+ prop "coparallely monad then" $ monadThen A.fromFoldable coparallely sortEq
367 prop "parallely monad then" $ monadThen A.fromFoldable parallely sortEq
367 prop "parallely monad then" $ monadThen A.fromFoldable parallely sortEq
368
368
369 prop "serially monad then folded" $ monadThen folded serially (==)
369 prop "serially monad then folded" $ monadThen folded serially (==)
370− prop "interleaving monad then folded" $ monadThen folded interleaving sortEq
370+ prop "coserially monad then folded" $ monadThen folded coserially sortEq
371− prop "aparallely monad then folded" $ monadThen folded aparallely sortEq
371+ prop "coparallely monad then folded" $ monadThen folded coparallely sortEq
372 prop "parallely monad then folded" $ monadThen folded parallely sortEq
372 prop "parallely monad then folded" $ monadThen folded parallely sortEq
373
373
374 prop "serially monad bind" $ monadBind A.fromFoldable serially (==)
374 prop "serially monad bind" $ monadBind A.fromFoldable serially (==)
375− prop "interleaving monad bind" $ monadBind A.fromFoldable interleaving sortEq
375+ prop "coserially monad bind" $ monadBind A.fromFoldable coserially sortEq
376− prop "aparallely monad bind" $ monadBind A.fromFoldable aparallely sortEq
376+ prop "coparallely monad bind" $ monadBind A.fromFoldable coparallely sortEq
377 prop "parallely monad bind" $ monadBind A.fromFoldable parallely sortEq
377 prop "parallely monad bind" $ monadBind A.fromFoldable parallely sortEq
378
378
379 describe "Stream transform operations" $ do
379 describe "Stream transform operations" $ do
380 transformOps A.fromFoldable "serially" serially (==)
380 transformOps A.fromFoldable "serially" serially (==)
381− transformOps A.fromFoldable "interleaving" interleaving (==)
381+ transformOps A.fromFoldable "coserially" coserially (==)
382 transformOps A.fromFoldable "zipping" zipping (==)
382 transformOps A.fromFoldable "zipping" zipping (==)
383 transformOps A.fromFoldable "zippingAsync" zippingAsync (==)
383 transformOps A.fromFoldable "zippingAsync" zippingAsync (==)
384− transformOps A.fromFoldable "aparallely" aparallely sortEq
384+ transformOps A.fromFoldable "coparallely" coparallely sortEq
385 transformOps A.fromFoldable "parallely" parallely sortEq
385 transformOps A.fromFoldable "parallely" parallely sortEq
386
386
387 transformOps folded "serially folded" serially (==)
387 transformOps folded "serially folded" serially (==)
388− transformOps folded "interleaving folded" interleaving (==)
388+ transformOps folded "coserially folded" coserially (==)
389 transformOps folded "zipping folded" zipping (==)
389 transformOps folded "zipping folded" zipping (==)
390 transformOps folded "zippingAsync folded" zippingAsync (==)
390 transformOps folded "zippingAsync folded" zippingAsync (==)
391− transformOps folded "aparallely folded" aparallely sortEq
391+ transformOps folded "coparallely folded" coparallely sortEq
392 transformOps folded "parallely folded" parallely sortEq
392 transformOps folded "parallely folded" parallely sortEq
393
393
394 transformOpsWord8 A.fromFoldable "serially" serially
394 transformOpsWord8 A.fromFoldable "serially" serially
395− transformOpsWord8 A.fromFoldable "interleaving" interleaving
395+ transformOpsWord8 A.fromFoldable "coserially" coserially
396 transformOpsWord8 A.fromFoldable "zipping" zipping
396 transformOpsWord8 A.fromFoldable "zipping" zipping
397 transformOpsWord8 A.fromFoldable "zippingAsync" zippingAsync
397 transformOpsWord8 A.fromFoldable "zippingAsync" zippingAsync
398− transformOpsWord8 A.fromFoldable "aparallely" aparallely
398+ transformOpsWord8 A.fromFoldable "coparallely" coparallely
399 transformOpsWord8 A.fromFoldable "parallely" parallely
399 transformOpsWord8 A.fromFoldable "parallely" parallely
400
400
401 transformOpsWord8 folded "serially folded" serially
401 transformOpsWord8 folded "serially folded" serially
402− transformOpsWord8 folded "interleaving folded" interleaving
402+ transformOpsWord8 folded "coserially folded" coserially
403 transformOpsWord8 folded "zipping folded" zipping
403 transformOpsWord8 folded "zipping folded" zipping
404 transformOpsWord8 folded "zippingAsync folded" zippingAsync
404 transformOpsWord8 folded "zippingAsync folded" zippingAsync
405− transformOpsWord8 folded "aparallely folded" aparallely
405+ transformOpsWord8 folded "coparallely folded" coparallely
406 transformOpsWord8 folded "parallely folded" parallely
406 transformOpsWord8 folded "parallely folded" parallely
407
407
408 describe "Stream elimination operations" $ do
408 describe "Stream elimination operations" $ do
409 eliminationOps A.fromFoldable "serially" serially
409 eliminationOps A.fromFoldable "serially" serially
410− eliminationOps A.fromFoldable "interleaving" interleaving
410+ eliminationOps A.fromFoldable "coserially" coserially
411 eliminationOps A.fromFoldable "zipping" zipping
411 eliminationOps A.fromFoldable "zipping" zipping
412 eliminationOps A.fromFoldable "zippingAsync" zippingAsync
412 eliminationOps A.fromFoldable "zippingAsync" zippingAsync
413− eliminationOps A.fromFoldable "aparallely" aparallely
413+ eliminationOps A.fromFoldable "coparallely" coparallely
414 eliminationOps A.fromFoldable "parallely" parallely
414 eliminationOps A.fromFoldable "parallely" parallely
415
415
416 eliminationOps folded "serially folded" serially
416 eliminationOps folded "serially folded" serially
417− eliminationOps folded "interleaving folded" interleaving
417+ eliminationOps folded "coserially folded" coserially
418 eliminationOps folded "zipping folded" zipping
418 eliminationOps folded "zipping folded" zipping
419 eliminationOps folded "zippingAsync folded" zippingAsync
419 eliminationOps folded "zippingAsync folded" zippingAsync
420− eliminationOps folded "aparallely folded" aparallely
420+ eliminationOps folded "coparallely folded" coparallely
421 eliminationOps folded "parallely folded" parallely
421 eliminationOps folded "parallely folded" parallely
422
422
423 describe "Stream elimination operations" $ do
423 describe "Stream elimination operations" $ do
424 serialEliminationOps A.fromFoldable "serially" serially
424 serialEliminationOps A.fromFoldable "serially" serially
425− serialEliminationOps A.fromFoldable "interleaving" interleaving
425+ serialEliminationOps A.fromFoldable "coserially" coserially
426 serialEliminationOps A.fromFoldable "zipping" zipping
426 serialEliminationOps A.fromFoldable "zipping" zipping
427 serialEliminationOps A.fromFoldable "zippingAsync" zippingAsync
427 serialEliminationOps A.fromFoldable "zippingAsync" zippingAsync
428
428
429 serialEliminationOps folded "serially folded" serially
429 serialEliminationOps folded "serially folded" serially
430− serialEliminationOps folded "interleaving folded" interleaving
430+ serialEliminationOps folded "coserially folded" coserially
431 serialEliminationOps folded "zipping folded" zipping
431 serialEliminationOps folded "zipping folded" zipping
432 serialEliminationOps folded "zippingAsync folded" zippingAsync
432 serialEliminationOps folded "zippingAsync folded" zippingAsync