@@ -153,7 +153,7 @@ checkCleanup :: IsStream t
153153 -> IO ()
154154checkCleanup d t op = do
155155 r <- newIORef (-1 :: Int)
156− runStream . serially $ do
156+ S.runStream . serially $ do
157157 _ <- t $ op $ delay r 0 S.|: delay r 1 S.|: delay r 2 S.|: S.nil
158158 return ()
159159 performMajorGC
@@ -193,9 +193,9 @@ parallelTests = H.parallel $ do
193193 -- XXX move these to property tests
194194 -- XXX use an IORef to store and check the side effects
195195 it "simple serially" $
196− (runStream . serially) (return (0 :: Int)) `shouldReturn` ()
196+ (S.runStream . serially) (return (0 :: Int)) `shouldReturn` ()
197197 it "simple serially with IO" $
198− (runStream . serially) (S.yieldM $ putStrLn "hello") `shouldReturn` ()
198+ (S.runStream . serially) (S.yieldM $ putStrLn "hello") `shouldReturn` ()
199199
200200 describe "Empty" $ -- do
201201 it "Monoid - mempty" $
@@ -541,12 +541,12 @@ parallelTests = H.parallel $ do
541541 ---------------------------------------------------------------------------
542542
543543 it "asyncly crosses thread limit (2000 threads)" $
544− runStream (asyncly $ fold $
544+ S.runStream (asyncly $ fold $
545545 replicate 2000 $ S.yieldM $ threadDelay 1000000)
546546 `shouldReturn` ()
547547
548548 it "aheadly crosses thread limit (4000 threads)" $
549− runStream (aheadly $ fold $
549+ S.runStream (aheadly $ fold $
550550 replicate 4000 $ S.yieldM $ threadDelay 1000000)
551551 `shouldReturn` ()
552552
@@ -596,7 +596,7 @@ monadicStateSnapshot
596596 , MonadState Int (t (StateT Int IO))
597597 )
598598 => (t (StateT Int IO) () -> SerialT (StateT Int IO) ()) -> IO ()
599−monadicStateSnapshot t = void $ runStateT (runStream $ t stateComp) 0
599+monadicStateSnapshot t = void $ runStateT (S.runStream $ t stateComp) 0
600600
601601stateCompOp
602602 :: ( AsyncT (StateT Int IO) ()
@@ -619,7 +619,7 @@ monadicStateSnapshotOp
619619 -> AsyncT (StateT Int IO) ()
620620 )
621621 -> IO ()
622−monadicStateSnapshotOp op = void $ runStateT (runStream $ stateCompOp op) 0
622+monadicStateSnapshotOp op = void $ runStateT (S.runStream $ stateCompOp op) 0
623623
624624takeCombined :: (Monad m, Semigroup (t m Int), Show a, Eq a, IsStream t)
625625 => Int -> (t m Int -> SerialT IO a) -> IO ()
@@ -669,7 +669,7 @@ checkScanxStrictness :: IO ()
669669checkScanxStrictness = do
670670 let s = return (1 :: Int) `S.consM` error "failure"
671671 catch
672− (runStream (
672+ (S.runStream (
673673 S.scanx (\_ a ->
674674 if a == 1
675675 then error "success"
@@ -687,7 +687,7 @@ checkScanl'Strictness :: IO ()
687687checkScanl'Strictness = do
688688 let s = return (1 :: Int) `S.consM` error "failure"
689689 catch
690− (runStream
690+ (S.runStream
691691 (S.scanl'
692692 (\_ a ->
693693 if a == 1
@@ -722,13 +722,13 @@ checkScanlMStrictness :: (IORef Int -> SerialT IO Int -> SerialT IO ()) -> IO ()
722722checkScanlMStrictness f = do
723723 ref <- newIORef 0
724724 let s = return 1 `S.consM` error "x"
725− catch (runStream $ f ref s) (\(_ :: ErrorCall) -> return ())
725+ catch (S.runStream $ f ref s) (\(_ :: ErrorCall) -> return ())
726726 readIORef ref `shouldReturn` 1
727727
728728takeInfinite :: IsStream t => (t IO Int -> SerialT IO Int) -> Spec
729729takeInfinite t =
730730 it "take 1" $
731− runStream (t $ S.take 1 $ S.repeatM (print "hello" >> return (1::Int)))
731+ S.runStream (t $ S.take 1 $ S.repeatM (print "hello" >> return (1::Int)))
732732 `shouldReturn` ()
733733
734734-- XXX need to test that we have promptly cleaned up everything after the error
@@ -743,16 +743,16 @@ simpleMonadError :: Spec
743743simpleMonadError = do
744744{-
745745 it "simple runExceptT" $ do
746− (runExceptT $ runStream $ return ())
746+ (runExceptT $ S.runStream $ return ())
747747 `shouldReturn` (Right () :: Either String ())
748748 it "simple runExceptT with error" $ do
749− (runExceptT $ runStream $ throwError "E") `shouldReturn` Left "E"
749+ (runExceptT $ S.runStream $ throwError "E") `shouldReturn` Left "E"
750750 -}
751751 it "simple try" $
752− try (runStream $ return ())
752+ try (S.runStream $ return ())
753753 `shouldReturn` (Right () :: Either ExampleException ())
754754 it "simple try with throw error" $
755− try (runStream $ throwM $ ExampleException "E")
755+ try (S.runStream $ throwM $ ExampleException "E")
756756 `shouldReturn` (Left (ExampleException "E") :: Either ExampleException ())
757757
758758composeWithMonadThrow
@@ -790,8 +790,8 @@ composeWithMonadThrow t = do
790790
791791 oneLevelNestedProduct desc t1 =
792792 it ("One level nested product" <> desc) $ do
793− let s1 = t $ foldMapWith (<>) return [1..4]
794− s2 = t1 $ foldMapWith (<>) return [5..8]
793+ let s1 = t $ S.foldMapWith (<>) return [1..4]
794+ s2 = t1 $ S.foldMapWith (<>) return [5..8]
795795 try $ tl (do
796796 x <- adapt s1
797797 y <- s2
@@ -816,8 +816,8 @@ _composeWithMonadError t = do
816816
817817nestTwoSerial :: Expectation
818818nestTwoSerial =
819− let s1 = foldMapWith (<>) return [1..4]
820− s2 = foldMapWith (<>) return [5..8]
819+ let s1 = S.foldMapWith (<>) return [1..4]
820+ s2 = S.foldMapWith (<>) return [5..8]
821821 in toListSerial (do
822822 x <- s1
823823 y <- s2
@@ -826,8 +826,8 @@ nestTwoSerial =
826826
827827nestTwoAhead :: Expectation
828828nestTwoAhead =
829− let s1 = foldMapWith (<>) return [1..4]
830− s2 = foldMapWith (<>) return [5..8]
829+ let s1 = S.foldMapWith (<>) return [1..4]
830+ s2 = S.foldMapWith (<>) return [5..8]
831831 in (S.toList . aheadly) (do
832832 x <- s1
833833 y <- s2
@@ -836,22 +836,22 @@ nestTwoAhead =
836836
837837nestTwoSerialApp :: Expectation
838838nestTwoSerialApp =
839− let s1 = foldMapWith (<>) return [1..4]
840− s2 = foldMapWith (<>) return [5..8]
839+ let s1 = S.foldMapWith (<>) return [1..4]
840+ s2 = S.foldMapWith (<>) return [5..8]
841841 in toListSerial ((+) <$> s1 <*> s2)
842842 `shouldReturn` ([6,7,8,9,7,8,9,10,8,9,10,11,9,10,11,12] :: [Int])
843843
844844nestTwoAheadApp :: Expectation
845845nestTwoAheadApp =
846− let s1 = foldMapWith (<>) return [1..4]
847− s2 = foldMapWith (<>) return [5..8]
846+ let s1 = S.foldMapWith (<>) return [1..4]
847+ s2 = S.foldMapWith (<>) return [5..8]
848848 in (S.toList . aheadly) ((+) <$> s1 <*> s2)
849849 `shouldReturn` ([6,7,8,9,7,8,9,10,8,9,10,11,9,10,11,12] :: [Int])
850850
851851nestTwoInterleaved :: Expectation
852852nestTwoInterleaved =
853− let s1 = foldMapWith (<>) return [1..4]
854− s2 = foldMapWith (<>) return [5..8]
853+ let s1 = S.foldMapWith (<>) return [1..4]
854+ s2 = S.foldMapWith (<>) return [5..8]
855855 in toListInterleaved (do
856856 x <- s1
857857 y <- s2
@@ -860,15 +860,15 @@ nestTwoInterleaved =
860860
861861nestTwoInterleavedApp :: Expectation
862862nestTwoInterleavedApp =
863− let s1 = foldMapWith (<>) return [1..4]
864− s2 = foldMapWith (<>) return [5..8]
863+ let s1 = S.foldMapWith (<>) return [1..4]
864+ s2 = S.foldMapWith (<>) return [5..8]
865865 in toListInterleaved ((+) <$> s1 <*> s2)
866866 `shouldReturn` ([6,7,7,8,8,8,9,9,9,9,10,10,10,11,11,12] :: [Int])
867867
868868nestTwoAsync :: Expectation
869869nestTwoAsync =
870− let s1 = foldMapWith (<>) return [1..4]
871− s2 = foldMapWith (<>) return [5..8]
870+ let s1 = S.foldMapWith (<>) return [1..4]
871+ s2 = S.foldMapWith (<>) return [5..8]
872872 in sort <$> toListAsync (do
873873 x <- s1
874874 y <- s2
@@ -877,15 +877,15 @@ nestTwoAsync =
877877
878878nestTwoAsyncApp :: Expectation
879879nestTwoAsyncApp =
880− let s1 = foldMapWith (<>) return [1..4]
881− s2 = foldMapWith (<>) return [5..8]
880+ let s1 = S.foldMapWith (<>) return [1..4]
881+ s2 = S.foldMapWith (<>) return [5..8]
882882 in sort <$> toListAsync ((+) <$> s1 <*> s2)
883883 `shouldReturn` sort ([6,7,8,9,7,8,9,10,8,9,10,11,9,10,11,12] :: [Int])
884884
885885nestTwoWAsync :: Expectation
886886nestTwoWAsync =
887− let s1 = foldMapWith (<>) return [1..4]
888− s2 = foldMapWith (<>) return [5..8]
887+ let s1 = S.foldMapWith (<>) return [1..4]
888+ s2 = S.foldMapWith (<>) return [5..8]
889889 in sort <$> (S.toList . wAsyncly) (do
890890 x <- s1
891891 y <- s2
@@ -894,8 +894,8 @@ nestTwoWAsync =
894894
895895nestTwoParallel :: Expectation
896896nestTwoParallel =
897− let s1 = foldMapWith (<>) return [1..4]
898− s2 = foldMapWith (<>) return [5..8]
897+ let s1 = S.foldMapWith (<>) return [1..4]
898+ s2 = S.foldMapWith (<>) return [5..8]
899899 in sort <$> (S.toList . parallely) (do
900900 x <- s1
901901 y <- s2
@@ -904,15 +904,15 @@ nestTwoParallel =
904904
905905nestTwoWAsyncApp :: Expectation
906906nestTwoWAsyncApp =
907− let s1 = foldMapWith (<>) return [1..4]
908− s2 = foldMapWith (<>) return [5..8]
907+ let s1 = S.foldMapWith (<>) return [1..4]
908+ s2 = S.foldMapWith (<>) return [5..8]
909909 in sort <$> (S.toList . wAsyncly) ((+) <$> s1 <*> s2)
910910 `shouldReturn` sort ([6,7,7,8,8,8,9,9,9,9,10,10,10,11,11,12] :: [Int])
911911
912912nestTwoParallelApp :: Expectation
913913nestTwoParallelApp =
914− let s1 = foldMapWith (<>) return [1..4]
915− s2 = foldMapWith (<>) return [5..8]
914+ let s1 = S.foldMapWith (<>) return [1..4]
915+ s2 = S.foldMapWith (<>) return [5..8]
916916 in sort <$> (S.toList . parallely) ((+) <$> s1 <*> s2)
917917 `shouldReturn` sort ([6,7,7,8,8,8,9,9,9,9,10,10,10,11,11,12] :: [Int])
918918
@@ -954,7 +954,7 @@ compose t z srt = do
954954 srt <$> tl (singleton 0 <> singleton 1)
955955 `shouldReturn` [0, 1]
956956 it "Compose many" $
957− srt <$> tl (forEachWith (<>) [1..100] singleton)
957+ srt <$> tl (S.forEachWith (<>) [1..100] singleton)
958958 `shouldReturn` [1..100]
959959
960960 -- These are not covered by the property tests
@@ -984,7 +984,7 @@ composeAndComposeSimple
984984 -> (t2 IO Int -> t2 IO Int)
985985 -> [[Int]] -> Spec
986986composeAndComposeSimple t1 t2 answer = do
987− let rfold = adapt . t2 . foldMapWith (<>) return
987+ let rfold = adapt . t2 . S.foldMapWith (<>) return
988988 it "Compose right associated outer expr, right folded inner" $
989989 (S.toList . t1) (rfold [1,2,3] <> (rfold [4,5,6] <> rfold [7,8,9]))
990990 `shouldReturn` head answer
@@ -1035,7 +1035,7 @@ bindAndComposeSimple t1 t2 = do
10351035 -- XXX need a bind in the body of forEachWith instead of a simple return
10361036 it "Compose many (right fold) with bind" $
10371037 (sort <$> (S.toList . t1)
1038− (adapt . t2 $ forEachWith (<>) [1..10 :: Int] return))
1038+ (adapt . t2 $ S.forEachWith (<>) [1..10 :: Int] return))
10391039 `shouldReturn` [1..10]
10401040
10411041 it "Compose many (left fold) with bind" $