a404317 · streamly · git.iko.soy

git.iko.soy/streamly

Replace SerialT with Stream for remaining modules (#1777)

* Replace SerialT to Stream for remaining modules * Reduce the usage of IsStream in benchmarks And some other refactoring. Co-authored-by: Harendra Kumar <harendra@composewell.com>

commita40431740c61c8e171835f0077b7f6bbc8549faf authorRanjeet Ranjan <ranjeetr@composewell.com> dateSat 20 Aug 2022, 11:13 (4 years ago) parent7dde623

42 files changed+753−799

compare with master

unifiedsplit

benchmark/NanoBenchmarks.hs+1−4

@@ -6,7 +6,7 @@

66{-# LANGUAGE FlexibleContexts #-}

77{-# LANGUAGE ScopedTypeVariables #-}

9−import Streamly.Prelude (SerialT)

9+import Streamly.Internal.Data.Stream (Stream)

1010import Streamly.Internal.Data.SVar (MonadAsync)

1111

1212import qualified Streamly.Data.Array.Unboxed as A

@@ -25,9 +25,6 @@ import System.Random

2525maxValue :: Int

2626maxValue = 100000

2727

28−-- type Stream = K.Stream

29−type Stream = SerialT

30−

3128{-# INLINE sourceUnfoldrM #-}

3229sourceUnfoldrM :: MonadAsync m => Stream m Int

3330sourceUnfoldrM = S.unfoldrM step 0

benchmark/Streamly/Benchmark/Data/Array/Common.hs+1−4

@@ -1,5 +1,3 @@

1−

2−

31-------------------------------------------------------------------------------

42-- Benchmark helpers

53-------------------------------------------------------------------------------

@@ -68,7 +66,7 @@ scanl' , scanl1', map

6866

6967{-# INLINE onArray #-}

7068onArray

71− :: MonadIO m => Int -> (S.SerialT m Int -> S.SerialT m Int)

69+ :: MonadIO m => Int -> (Stream.Stream m Int -> Stream.Stream m Int)

7270 -> Stream Int

7371 -> m (Stream Int)

7472onArray value f arr = S.fold (A.writeN value) $ f $ S.unfold A.read arr

@@ -102,7 +100,6 @@ showInstance = P.show

102100pureFoldl' :: MonadIO m => Stream Int -> m Int

103101pureFoldl' = S.foldl' (+) 0 . S.unfold A.read

104102

105−

106103-------------------------------------------------------------------------------

107104-- Elimination

108105-------------------------------------------------------------------------------

benchmark/Streamly/Benchmark/Data/Array/CommonImports.hs+3−5

@@ -1,17 +1,15 @@

11{-# LANGUAGE FlexibleContexts #-}

33import Control.DeepSeq (NFData(..))

4+import Control.Monad.IO.Class (MonadIO)

5+import Data.Functor ((<&>))

46import System.Random (randomRIO)

68import qualified Streamly.Prelude as S

9+import qualified Streamly.Internal.Data.Stream as Stream

710

811import Gauge

912import Streamly.Benchmark.Common hiding (benchPureSrc)

1013import qualified Streamly.Benchmark.Prelude as P

1114

12−

13−import Control.Monad.IO.Class (MonadIO)

14−

1515import Prelude as P hiding (map)

16−

17−import Data.Functor ((<&>))

benchmark/Streamly/Benchmark/Data/Array/Stream/Foreign.hs+11−10

@@ -29,23 +29,24 @@ import Control.Monad.Catch (MonadCatch, try, SomeException)

2929import Data.Functor.Identity (runIdentity)

3030import Data.Maybe (isJust)

3131import Data.Word (Word8)

32+import Streamly.Internal.Data.Stream (Stream)

3233import System.IO (Handle)

3334import System.Random (randomRIO)

3435import Prelude hiding ()

3536

36−import qualified Streamly.Prelude as Stream

3737import qualified Streamly.Internal.Data.Array.Unboxed as Array

3838import qualified Streamly.Internal.Data.Array.Stream.Foreign as ArrayStream

3939import qualified Streamly.Internal.Data.Fold as Fold

4040import qualified Streamly.Internal.Data.Parser as Parser

41−import qualified Streamly.Internal.Data.Stream.IsStream as Stream (arraysOf)

41+import qualified Streamly.Internal.Data.Stream as S

42+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

4243import qualified Streamly.Internal.FileSystem.Handle as Handle

4344import qualified Streamly.Internal.Unicode.Stream as Unicode

4445

4546import Gauge hiding (env)

46−import Streamly.Prelude (SerialT, MonadAsync, IsStream)

4747import Streamly.Benchmark.Common

4848import Streamly.Benchmark.Common.Handle

49+import Control.Monad.IO.Class (MonadIO)

4950

5051#ifdef INSPECTION

5152import Streamly.Internal.Data.Unboxed (Unboxed)

@@ -60,8 +61,8 @@ import Test.Inspection

6061-- XXX these can be moved to the common module

6162

6263{-# INLINE sourceUnfoldrM #-}

63−sourceUnfoldrM :: (IsStream t, MonadAsync m) => Int -> Int -> t m Int

64−sourceUnfoldrM value n = Stream.unfoldrM step n

64+sourceUnfoldrM :: MonadIO m => Int -> Int -> Stream m Int

65+sourceUnfoldrM value n = S.unfoldrM step n

6566 where

6667 step cnt =

6768 if cnt > n + value

@@ -71,7 +72,7 @@ sourceUnfoldrM value n = Stream.unfoldrM step n

7172{-# INLINE benchIO #-}

7273benchIO

7374 :: NFData b

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

75+ => String -> (Int -> Stream IO a) -> (Stream IO a -> IO b) -> Benchmark

7576benchIO name src sink =

7677 bench name $ nfIO $ randomRIO (1,1) >>= sink . src

7778

@@ -227,21 +228,21 @@ drainWhile p = Parser.takeWhile p Fold.drain

227228-------------------------------------------------------------------------------

228229

229230{-# INLINE fold #-}

230−fold :: SerialT IO (Array.Array Int) -> IO ()

231+fold :: Stream IO (Array.Array Int) -> IO ()

231232fold s = void $ ArrayStream.foldBreak Fold.drain s

232233

233234{-# INLINE parse #-}

234−parse :: Int -> SerialT IO (Array.Array Int) -> IO ()

235+parse :: Int -> Stream IO (Array.Array Int) -> IO ()

235236parse value s = void $ ArrayStream.parseBreak (drainWhile (< value)) s

236237

237238{-# INLINE foldBreak #-}

238−foldBreak :: SerialT IO (Array.Array Int) -> IO ()

239+foldBreak :: Stream IO (Array.Array Int) -> IO ()

239240foldBreak s = do

240241 (r, s1) <- ArrayStream.foldBreak Fold.one s

241242 when (isJust r) $ foldBreak s1

242243

243244{-# INLINE parseBreak #-}

244−parseBreak :: SerialT IO (Array.Array Int) -> IO ()

245+parseBreak :: Stream IO (Array.Array Int) -> IO ()

245246parseBreak s = do

246247 r <- try $ ArrayStream.parseBreak Parser.one s

247248 case r of

benchmark/Streamly/Benchmark/Data/Array/Unboxed/Mut.hs+19−15

@@ -20,7 +20,6 @@

2020import Control.DeepSeq (NFData(..))

2121import Control.Monad.IO.Class (MonadIO)

2222import Data.Functor ((<&>))

23−import Streamly.Prelude (MonadAsync, SerialT, IsStream)

2423import System.Random (randomRIO)

2524import Prelude

2625 ( IO

@@ -36,14 +35,16 @@ import Prelude

3635 , (||)

3736 , concat

3837 , const

38+ , fmap

3939 , id

4040 , undefined

4141 )

4242

4343import qualified Streamly.Internal.Data.Array.Unboxed as Array

4444import qualified Streamly.Internal.Data.Array.Unboxed.Mut as MArray

45−import qualified Streamly.Internal.Data.Stream.Type as Stream

46−import qualified Streamly.Prelude as Stream

45+import qualified Streamly.Internal.Data.Fold as Fold

46+import qualified Streamly.Internal.Data.Stream as Stream

47+import qualified Streamly.Prelude as IsStream (scanl1')

4748

4849import Gauge

4950import Streamly.Benchmark.Common hiding (benchPureSrc)

@@ -77,6 +78,9 @@ benchIOSink value name = benchIO' name (sourceIntFromTo value)

7778benchIOSrc :: String -> (Int -> IO (Stream a)) -> Benchmark

7879benchIOSrc name src = benchIO name src id

7980

81+drain :: Monad m => Stream.Stream m a -> m ()

82+drain = Stream.fold Fold.drain

83+

8084-------------------------------------------------------------------------------

8185-- Bench Ops

8286-------------------------------------------------------------------------------

@@ -113,7 +117,7 @@ sourceIntFromToFromStream value n =

113117 Stream.fold MArray.write $ Stream.enumerateFromTo n (n + value)

114118

115119{-# INLINE sourceUnfoldrM #-}

116−sourceUnfoldrM :: (IsStream t, MonadAsync m) => Int -> Int -> t m Int

120+sourceUnfoldrM :: Monad m => Int -> Int -> Stream.Stream m Int

117121sourceUnfoldrM value n = Stream.unfoldrM step n

118122 where

119123 step cnt =

@@ -138,19 +142,19 @@ composeN n f x =

138142

139143{-# INLINE scanl' #-}

140144scanl' :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

141−scanl' value n = composeN n $ onArray value $ Stream.scanl' (+) 0

145+scanl' value n = composeN n $ onArray value $ Stream.scan (Fold.foldl' (+) 0)

142146

143147{-# INLINE scanl1' #-}

144148scanl1' :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

145−scanl1' value n = composeN n $ onArray value $ Stream.scanl1' (+)

149+scanl1' value n = composeN n $ onArray value $ IsStream.scanl1' (+)

146150

147151{-# INLINE map #-}

148152map :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

149−map value n = composeN n $ onArray value $ Stream.map (+ 1)

153+map value n = composeN n $ onArray value $ fmap (+ 1)

150154

151155{-# INLINE onArray #-}

152156onArray

153− :: MonadIO m => Int -> (Stream.SerialT m Int -> Stream.SerialT m Int)

157+ :: MonadIO m => Int -> (Stream.Stream m Int -> Stream.Stream m Int)

154158 -> Stream Int

155159 -> m (Stream Int)

156160onArray value f arr =

@@ -162,24 +166,24 @@ onArray value f arr =

162166

163167{-# INLINE unfoldReadDrain #-}

164168unfoldReadDrain :: MonadIO m => Stream Int -> m ()

165−unfoldReadDrain = Stream.drain . Stream.unfold MArray.read

169+unfoldReadDrain = drain . Stream.unfold MArray.read

166170

167171{-# INLINE unfoldReadRevDrain #-}

168172unfoldReadRevDrain :: MonadIO m => Stream Int -> m ()

169−unfoldReadRevDrain = Stream.drain . Stream.unfold MArray.readRev

173+unfoldReadRevDrain = drain . Stream.unfold MArray.readRev

170174

171175{-# INLINE toStreamDRevDrain #-}

172176toStreamDRevDrain :: MonadIO m => Stream Int -> m ()

173177toStreamDRevDrain =

174− Stream.drain . Stream.fromStreamD . MArray.toStreamDRev

178+ drain . Stream.fromStreamD . MArray.toStreamDRev

175179

176180{-# INLINE toStreamDDrain #-}

177181toStreamDDrain :: MonadIO m => Stream Int -> m ()

178−toStreamDDrain = Stream.drain . Stream.fromStreamD . MArray.toStreamD

182+toStreamDDrain = drain . Stream.fromStreamD . MArray.toStreamD

179183

180184{-# INLINE unfoldFold #-}

181185unfoldFold :: MonadIO m => Stream Int -> m Int

182−unfoldFold = Stream.foldl' (+) 0 . Stream.unfold MArray.read

186+unfoldFold = Stream.fold (Fold.foldl' (+) 0) . Stream.unfold MArray.read

183187

184188-------------------------------------------------------------------------------

185189-- Bench groups

@@ -273,8 +277,8 @@ main = do

273277 where

274278

275279 alloc value = do

276− marr <- MArray.fromStream (sourceUnfoldrM value 0 :: SerialT IO Int)

277− indices <- Array.fromStream (sourceUnfoldrM value 0 :: SerialT IO Int)

280+ marr <- MArray.fromStream (sourceUnfoldrM value 0 :: Stream.Stream IO Int)

281+ indices <- Array.fromStream (sourceUnfoldrM value 0 :: Stream.Stream IO Int)

278282 return (marr, indices)

279283

280284 allBenchmarks array value =

benchmark/Streamly/Benchmark/Data/Fold.hs+124−125

@@ -23,15 +23,14 @@ import Data.IntMap.Strict (IntMap)

2323import Data.Monoid (Last(..), Sum(..))

2424import System.Random (randomRIO)

2525

26−import Streamly.Prelude (SerialT)

26+import Streamly.Internal.Data.Stream (Stream)

2727import Streamly.Internal.Data.Fold (Fold(..))

2828import Streamly.Internal.Data.IsMap.HashMap ()

2929

3030import qualified Streamly.Internal.Data.Fold as FL

3131import qualified Streamly.Internal.Data.Unfold as Unfold

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

33−import qualified Streamly.Internal.Data.Stream.IsStream as IP

34−import qualified Streamly.Prelude as S

33+import qualified Streamly.Internal.Data.Stream as Stream

3534

3635import Gauge

3736import Streamly.Benchmark.Common

@@ -41,8 +40,8 @@ import Prelude hiding (all, any, take, unzip, sequence_, filter)

4140-- completely optimized out by the compiler in some cases.

4241

4342{-# INLINE sourceUnfoldrM #-}

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

45−sourceUnfoldrM value n = S.unfoldrM step n

43+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

44+sourceUnfoldrM value n = Stream.unfoldrM step n

4645 where

4746 step cnt =

4847 if cnt > n + value

@@ -50,14 +49,14 @@ sourceUnfoldrM value n = S.unfoldrM step n

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

5150

5251{-# INLINE source #-}

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

52+source :: Monad m => Int -> Int -> Stream m Int

5453source = sourceUnfoldrM

5554

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

5756{-# INLINE benchIOSink #-}

5857benchIOSink

59− :: (S.IsStream t, NFData b)

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

58+ :: NFData b

59+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

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

6261

6362-------------------------------------------------------------------------------

@@ -65,16 +64,16 @@ benchIOSink value name f = bench name $ nfIO $ randomRIO (1,1) >>= f . source va

6564-------------------------------------------------------------------------------

6665

6766{-# INLINE any #-}

68−any :: (Monad m, Ord a) => a -> SerialT m a -> m Bool

69−any value = IP.fold (FL.any (> value))

67+any :: (Monad m, Ord a) => a -> Stream m a -> m Bool

68+any value = Stream.fold (FL.any (> value))

7069

7170{-# INLINE all #-}

72−all :: (Monad m, Ord a) => a -> SerialT m a -> m Bool

73−all value = IP.fold (FL.all (<= value))

71+all :: (Monad m, Ord a) => a -> Stream m a -> m Bool

72+all value = Stream.fold (FL.all (<= value))

7473

7574{-# INLINE take #-}

76−take :: Monad m => Int -> SerialT m a -> m ()

77−take value = IP.fold (FL.take value FL.drain)

75+take :: Monad m => Int -> Stream m a -> m ()

76+take value = Stream.fold (FL.take value FL.drain)

7877

7978{-# INLINE sequence_ #-}

8079sequence_ :: Monad m => Int -> Fold m a ()

@@ -91,17 +90,17 @@ sequence_ value =

9190-------------------------------------------------------------------------------

9291

9392{-# INLINE filter #-}

94−filter :: Monad m => Int -> SerialT m Int -> m ()

95−filter _ = IP.fold (FL.filter even FL.drain)

93+filter :: Monad m => Int -> Stream m Int -> m ()

94+filter _ = Stream.fold (FL.filter even FL.drain)

9695

9796{-# INLINE foldFilter #-}

98−foldFilter :: Monad m => Int -> SerialT m Int -> m ()

99−foldFilter _ = IP.fold (FL.foldFilter (FL.satisfy even) FL.drain)

97+foldFilter :: Monad m => Int -> Stream m Int -> m ()

98+foldFilter _ = Stream.fold (FL.foldFilter (FL.satisfy even) FL.drain)

10099

101100{-# INLINE foldFilter2 #-}

102−foldFilter2 :: Monad m => Int -> SerialT m Int -> m ()

101+foldFilter2 :: Monad m => Int -> Stream m Int -> m ()

103102foldFilter2 _ =

104− IP.fold

103+ Stream.fold

105104 $ FL.foldFilter (FL.satisfy even)

106105 $ FL.foldFilter (FL.satisfy odd) FL.drain

107106

@@ -110,43 +109,43 @@ foldFilter2 _ =

110109-------------------------------------------------------------------------------

111110

112111{-# INLINE takeEndBy_ #-}

113−takeEndBy_ :: Monad m => Int -> SerialT m Int -> m ()

114−takeEndBy_ value = IP.fold (FL.takeEndBy_ (>= value) FL.drain)

112+takeEndBy_ :: Monad m => Int -> Stream m Int -> m ()

113+takeEndBy_ value = Stream.fold (FL.takeEndBy_ (>= value) FL.drain)

115114

116115{-# INLINE many #-}

117−many :: Monad m => SerialT m Int -> m ()

118−many = IP.fold (FL.many (FL.take 1 FL.drain) FL.drain)

116+many :: Monad m => Stream m Int -> m ()

117+many = Stream.fold (FL.many (FL.take 1 FL.drain) FL.drain)

119118

120119{-# INLINE splitAllAny #-}

121−splitAllAny :: Monad m => Int -> SerialT m Int -> m (Bool, Bool)

120+splitAllAny :: Monad m => Int -> Stream m Int -> m (Bool, Bool)

122121splitAllAny value =

123− IP.fold

122+ Stream.fold

124123 (FL.serialWith (,)

125124 (FL.all (<= (value `div` 2)))

126125 (FL.any (> value))

127126 )

128127

129128{-# INLINE serial_ #-}

130−serial_ :: Monad m => Int -> SerialT m Int -> m Bool

129+serial_ :: Monad m => Int -> Stream m Int -> m Bool

131130serial_ value =

132− IP.fold

131+ Stream.fold

133132 (FL.serial_

134133 (FL.all (<= (value `div` 2)))

135134 (FL.any (> value))

136135 )

137136

138137{-# INLINE shortest #-}

139−shortest :: Monad m => SerialT m Int -> m (Either Int Int)

140−shortest = IP.fold (FL.shortest FL.sum FL.length)

138+shortest :: Monad m => Stream m Int -> m (Either Int Int)

139+shortest = Stream.fold (FL.shortest FL.sum FL.length)

141140

142141{-# INLINE longest #-}

143−longest :: Monad m => SerialT m Int -> m (Either Int Int)

144−longest = IP.fold (FL.longest FL.sum FL.length)

142+longest :: Monad m => Stream m Int -> m (Either Int Int)

143+longest = Stream.fold (FL.longest FL.sum FL.length)

145144

146145{-# INLINE foldBreak #-}

147−foldBreak :: Monad m => SerialT m Int -> m ()

146+foldBreak :: Monad m => Stream m Int -> m ()

148147foldBreak s = do

149− (r, s1) <- IP.foldBreak (FL.take 1 FL.length) s

148+ (r, s1) <- Stream.foldBreak (FL.take 1 FL.length) s

150149 when (r /= 0) $ foldBreak s1

151150

152151-------------------------------------------------------------------------------

@@ -154,12 +153,12 @@ foldBreak s = do

154153-------------------------------------------------------------------------------

155154

156155{-# INLINE teeSumLength #-}

157−teeSumLength :: Monad m => SerialT m Int -> m (Int, Int)

158−teeSumLength = IP.fold (FL.teeWith (,) FL.sum FL.length)

156+teeSumLength :: Monad m => Stream m Int -> m (Int, Int)

157+teeSumLength = Stream.fold (FL.teeWith (,) FL.sum FL.length)

159158

160159{-# INLINE teeAllAny #-}

161−teeAllAny :: (Monad m, Ord a) => a -> SerialT m a -> m (Bool, Bool)

162−teeAllAny value = IP.fold (FL.teeWith (,) all_ any_)

160+teeAllAny :: (Monad m, Ord a) => a -> Stream m a -> m (Bool, Bool)

161+teeAllAny value = Stream.fold (FL.teeWith (,) all_ any_)

163162

164163 where

165164

@@ -167,16 +166,16 @@ teeAllAny value = IP.fold (FL.teeWith (,) all_ any_)

167166 any_ = FL.any (> value)

168167

169168{-# INLINE teeWithFst #-}

170−teeWithFst :: Monad m => SerialT m Int -> m (Int, Int)

171−teeWithFst = IP.fold (FL.teeWithFst (,) FL.sum FL.length)

169+teeWithFst :: Monad m => Stream m Int -> m (Int, Int)

170+teeWithFst = Stream.fold (FL.teeWithFst (,) FL.sum FL.length)

172171

173172{-# INLINE teeWithMin #-}

174−teeWithMin :: Monad m => SerialT m Int -> m (Int, Int)

175−teeWithMin = IP.fold (FL.teeWithMin (,) FL.sum FL.length)

173+teeWithMin :: Monad m => Stream m Int -> m (Int, Int)

174+teeWithMin = Stream.fold (FL.teeWithMin (,) FL.sum FL.length)

176175

177176{-# INLINE distribute #-}

178−distribute :: Monad m => SerialT m Int -> m [Int]

179−distribute = IP.fold (FL.distribute [FL.sum, FL.length])

177+distribute :: Monad m => Stream m Int -> m [Int]

178+distribute = Stream.fold (FL.distribute [FL.sum, FL.length])

180179

181180-------------------------------------------------------------------------------

182181-- Partitioning

@@ -187,88 +186,88 @@ oddEven :: Int -> Either Int Int

187186oddEven x = if odd x then Left x else Right x

188187

189188{-# INLINE partition #-}

190−partition :: Monad m => SerialT m Int -> m (Int, Int)

191−partition = IP.fold $ FL.lmap oddEven (FL.partition FL.sum FL.length)

189+partition :: Monad m => Stream m Int -> m (Int, Int)

190+partition = Stream.fold $ FL.lmap oddEven (FL.partition FL.sum FL.length)

192191

193192{-# INLINE partitionByFstM #-}

194−partitionByFstM :: Monad m => SerialT m Int -> m (Int, Int)

193+partitionByFstM :: Monad m => Stream m Int -> m (Int, Int)

195194partitionByFstM =

196− IP.fold (FL.partitionByFstM (return . oddEven) FL.sum FL.length)

195+ Stream.fold (FL.partitionByFstM (return . oddEven) FL.sum FL.length)

197196

198197{-# INLINE partitionByMinM #-}

199−partitionByMinM :: Monad m => SerialT m Int -> m (Int, Int)

198+partitionByMinM :: Monad m => Stream m Int -> m (Int, Int)

200199partitionByMinM =

201− IP.fold (FL.partitionByMinM (return . oddEven) FL.sum FL.length)

200+ Stream.fold (FL.partitionByMinM (return . oddEven) FL.sum FL.length)

202201

203202{-# INLINE demuxWith #-}

204203demuxWith :: (Monad m, Ord k) =>

205− (a -> k) -> (a -> m (Fold m a b)) -> SerialT m a -> m (Map k b)

206−demuxWith f g = S.fold (FL.demuxWith f g)

204+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (Map k b)

205+demuxWith f g = Stream.fold (FL.demuxWith f g)

207206

208207{-# INLINE demuxWithInt #-}

209208demuxWithInt :: Monad m =>

210− (a -> Int) -> (a -> m (Fold m a b)) -> SerialT m a -> m (IntMap b)

211−demuxWithInt f g = S.fold (FL.demuxWith f g)

209+ (a -> Int) -> (a -> m (Fold m a b)) -> Stream m a -> m (IntMap b)

210+demuxWithInt f g = Stream.fold (FL.demuxWith f g)

212211

213212{-# INLINE demuxWithHash #-}

214213demuxWithHash :: (Monad m, Ord k, Hashable k) =>

215− (a -> k) -> (a -> m (Fold m a b)) -> SerialT m a -> m (HashMap k b)

216−demuxWithHash f g = S.fold (FL.demuxWith f g)

214+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (HashMap k b)

215+demuxWithHash f g = Stream.fold (FL.demuxWith f g)

217216

218217{-# INLINE demuxMutWith #-}

219218demuxMutWith :: (MonadIO m, Ord k) =>

220− (a -> k) -> (a -> m (Fold m a b)) -> SerialT m a -> m (Map k b)

221−demuxMutWith f g = S.fold (FL.demuxMutWith f g)

219+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (Map k b)

220+demuxMutWith f g = Stream.fold (FL.demuxMutWith f g)

222221

223222{-# INLINE demuxMutWithHash #-}

224223demuxMutWithHash :: (MonadIO m, Ord k, Hashable k) =>

225− (a -> k) -> (a -> m (Fold m a b)) -> SerialT m a -> m (HashMap k b)

226−demuxMutWithHash f g = S.fold (FL.demuxMutWith f g)

224+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (HashMap k b)

225+demuxMutWithHash f g = Stream.fold (FL.demuxMutWith f g)

227226

228227{-# INLINE classifyWith #-}

229228classifyWith ::

230− (Monad m, Ord k, Num a) => (a -> k) -> SerialT m a -> m (Map k a)

231−classifyWith f = S.fold (FL.classifyWith f FL.sum)

229+ (Monad m, Ord k, Num a) => (a -> k) -> Stream m a -> m (Map k a)

230+classifyWith f = Stream.fold (FL.classifyWith f FL.sum)

232231

233232{-# INLINE classifyWithInt #-}

234233classifyWithInt ::

235− (MonadIO m, Num a) => (a -> Int) -> SerialT m a -> m (IntMap a)

236−classifyWithInt f = S.fold (FL.classifyWith f FL.sum)

234+ (Monad m, Num a) => (a -> Int) -> Stream m a -> m (IntMap a)

235+classifyWithInt f = Stream.fold (FL.classifyWith f FL.sum)

237236

238237{-# INLINE classifyMutWith #-}

239238classifyMutWith ::

240− (MonadIO m, Ord k, Num a) => (a -> k) -> SerialT m a -> m (Map k a)

241−classifyMutWith f = S.fold (FL.classifyMutWith f FL.sum)

239+ (MonadIO m, Ord k, Num a) => (a -> k) -> Stream m a -> m (Map k a)

240+classifyMutWith f = Stream.fold (FL.classifyMutWith f FL.sum)

242241

243242{-# INLINE classifyMutWithInt #-}

244243classifyMutWithInt ::

245− (MonadIO m, Num a) => (a -> Int) -> SerialT m a -> m (IntMap a)

246−classifyMutWithInt f = S.fold (FL.classifyMutWith f FL.sum)

244+ (MonadIO m, Num a) => (a -> Int) -> Stream m a -> m (IntMap a)

245+classifyMutWithInt f = Stream.fold (FL.classifyMutWith f FL.sum)

247246

248247{-# INLINE classifyMutWithHash #-}

249248classifyMutWithHash :: (MonadIO m, Ord k, Num a, Hashable k) =>

250− (a -> k) -> SerialT m a -> m (HashMap k a)

251−classifyMutWithHash f = S.fold (FL.classifyMutWith f FL.sum)

249+ (a -> k) -> Stream m a -> m (HashMap k a)

250+classifyMutWithHash f = Stream.fold (FL.classifyMutWith f FL.sum)

252251

253252-------------------------------------------------------------------------------

254253-- unzip

255254-------------------------------------------------------------------------------

256255

257256{-# INLINE unzip #-}

258−unzip :: Monad m => SerialT m Int -> m (Int, Int)

259−unzip = IP.fold $ FL.lmap (\a -> (a, a)) (FL.unzip FL.sum FL.length)

257+unzip :: Monad m => Stream m Int -> m (Int, Int)

258+unzip = Stream.fold $ FL.lmap (\a -> (a, a)) (FL.unzip FL.sum FL.length)

260259

261260{-# INLINE unzipWithFstM #-}

262−unzipWithFstM :: Monad m => SerialT m Int -> m (Int, Int)

261+unzipWithFstM :: Monad m => Stream m Int -> m (Int, Int)

263262unzipWithFstM = do

264263 let f = \a -> return (a + 1, a)

265− IP.fold (FL.unzipWithFstM f FL.sum FL.length)

264+ Stream.fold (FL.unzipWithFstM f FL.sum FL.length)

266265

267266{-# INLINE unzipWithMinM #-}

268−unzipWithMinM :: Monad m => SerialT m Int -> m (Int, Int)

267+unzipWithMinM :: Monad m => Stream m Int -> m (Int, Int)

269268unzipWithMinM = do

270269 let f = \a -> return (a + 1, a)

271− IP.fold (FL.unzipWithMinM f FL.sum FL.length)

270+ Stream.fold (FL.unzipWithMinM f FL.sum FL.length)

272271

273272-------------------------------------------------------------------------------

274273-- Nested

@@ -278,8 +277,8 @@ unzipWithMinM = do

278277unfoldMany :: Int -> Benchmarkable

279278unfoldMany val =

280279 nfIO

281− $ IP.fold (FL.unfoldMany (Unfold.replicateM val) FL.drain)

282− $ IP.fromPure (randomRIO (1, 1 :: Int))

280+ $ Stream.fold (FL.unfoldMany (Unfold.replicateM val) FL.drain)

281+ $ Stream.fromPure (randomRIO (1, 1 :: Int))

283282

284283-------------------------------------------------------------------------------

285284-- Benchmarks

@@ -291,103 +290,103 @@ moduleName = "Data.Fold"

291290o_1_space_serial_elimination :: Int -> [Benchmark]

292291o_1_space_serial_elimination value =

293292 [ bgroup "elimination"

294− [ benchIOSink value "drain" (S.fold FL.drain)

295− , benchIOSink value "drainBy" (S.fold (FL.drainBy return))

296− , benchIOSink value "drainN" (S.fold (FL.drainN value))

297− , benchIOSink value "last" (S.fold FL.last)

298− , benchIOSink value "nub" (S.fold FL.nub)

299− , benchIOSink value "length" (S.fold FL.length)

300− , benchIOSink value "top" (S.fold $ FL.top 10)

301− , benchIOSink value "bottom" (S.fold $ FL.bottom 10)

302− , benchIOSink value "sum" (S.fold FL.sum)

303− , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))

304− , benchIOSink value "product" (S.fold FL.product)

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

306− , benchIOSink value "maximum" (S.fold FL.maximum)

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

308− , benchIOSink value "minimum" (S.fold FL.minimum)

293+ [ benchIOSink value "drain" (Stream.fold FL.drain)

294+ , benchIOSink value "drainBy" (Stream.fold (FL.drainBy return))

295+ , benchIOSink value "drainN" (Stream.fold (FL.drainN value))

296+ , benchIOSink value "last" (Stream.fold FL.last)

297+ , benchIOSink value "nub" (Stream.fold FL.nub)

298+ , benchIOSink value "length" (Stream.fold FL.length)

299+ , benchIOSink value "top" (Stream.fold $ FL.top 10)

300+ , benchIOSink value "bottom" (Stream.fold $ FL.bottom 10)

301+ , benchIOSink value "sum" (Stream.fold FL.sum)

302+ , benchIOSink value "sum (foldMap)" (Stream.fold (FL.foldMap Sum))

303+ , benchIOSink value "product" (Stream.fold FL.product)

304+ , benchIOSink value "maximumBy" (Stream.fold (FL.maximumBy compare))

305+ , benchIOSink value "maximum" (Stream.fold FL.maximum)

306+ , benchIOSink value "minimumBy" (Stream.fold (FL.minimumBy compare))

307+ , benchIOSink value "minimum" (Stream.fold FL.minimum)

309308 , benchIOSink

310309 value

311310 "mean"

312− (S.fold FL.mean . S.map (fromIntegral :: Int -> Double))

311+ (Stream.fold FL.mean . fmap (fromIntegral :: Int -> Double))

313312 , benchIOSink

314313 value

315314 "variance"

316− (S.fold FL.variance . S.map (fromIntegral :: Int -> Double))

315+ (Stream.fold FL.variance . fmap (fromIntegral :: Int -> Double))

317316 , benchIOSink

318317 value

319318 "stdDev"

320− (S.fold FL.stdDev . S.map (fromIntegral :: Int -> Double))

319+ (Stream.fold FL.stdDev . fmap (fromIntegral :: Int -> Double))

321320 , benchIOSink

322321 value

323322 "mconcat"

324− (S.fold FL.mconcat . S.map (Last . Just))

323+ (Stream.fold FL.mconcat . fmap (Last . Just))

325324 , benchIOSink

326325 value

327326 "foldMap"

328− (S.fold (FL.foldMap (Last . Just)))

327+ (Stream.fold (FL.foldMap (Last . Just)))

329328 , benchIOSink

330329 value

331330 "foldMapM"

332− (S.fold (FL.foldMapM (return . Last . Just)))

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

334− , benchIOSink value "head" (S.fold FL.head)

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

331+ (Stream.fold (FL.foldMapM (return . Last . Just)))

332+ , benchIOSink value "index" (Stream.fold (FL.index (value + 1)))

333+ , benchIOSink value "head" (Stream.fold FL.head)

334+ , benchIOSink value "find" (Stream.fold (FL.find (== (value + 1))))

336335 , benchIOSink

337336 value

338337 "lookup"

339− (S.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))

338+ (Stream.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))

340339 , benchIOSink

341340 value

342341 "findIndex"

343− (S.fold (FL.findIndex (== (value + 1))))

342+ (Stream.fold (FL.findIndex (== (value + 1))))

344343 , benchIOSink

345344 value

346345 "elemIndex"

347− (S.fold (FL.elemIndex (value + 1)))

348− , benchIOSink value "null" (S.fold FL.null)

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

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

346+ (Stream.fold (FL.elemIndex (value + 1)))

347+ , benchIOSink value "null" (Stream.fold FL.null)

348+ , benchIOSink value "elem" (Stream.fold (FL.elem (value + 1)))

349+ , benchIOSink value "notElem" (Stream.fold (FL.notElem (value + 1)))

351350 , benchIOSink value "all" $ all value

352351 , benchIOSink value "any" $ any value

353352 , benchIOSink value "take" $ take value

354353 , benchIOSink value "takeEndBy_" $ takeEndBy_ value

355− , benchIOSink value "and" (S.fold FL.and . S.map (<= (value + 1)))

356− , benchIOSink value "or" (S.fold FL.or . S.map (> (value + 1)))

354+ , benchIOSink value "and" (Stream.fold FL.and . fmap (<= (value + 1)))

355+ , benchIOSink value "or" (Stream.fold FL.or . fmap (> (value + 1)))

357356 ]

358357 ]

359358

360359o_1_space_serial_transformation :: Int -> [Benchmark]

361360o_1_space_serial_transformation value =

362361 [ bgroup "transformation"

363− [ benchIOSink value "map" (S.fold (FL.lmap (+ 1) FL.drain))

362+ [ benchIOSink value "map" (Stream.fold (FL.lmap (+ 1) FL.drain))

364363 , let f x = if even x then Just x else Nothing

365364 fld = FL.mapMaybe f FL.drain

366− in benchIOSink value "mapMaybe" (S.fold fld)

365+ in benchIOSink value "mapMaybe" (Stream.fold fld)

367366 , benchIOSink

368367 value

369368 "rsequence"

370− (S.fold (FL.rmapM id (return <$> FL.drain)))

371− , benchIOSink value "rmapM" (S.fold (FL.rmapM return FL.drain))

369+ (Stream.fold (FL.rmapM id (return <$> FL.drain)))

370+ , benchIOSink value "rmapM" (Stream.fold (FL.rmapM return FL.drain))

372371 , benchIOSink

373372 value

374373 "pipe-mapM"

375− (S.fold

374+ (Stream.fold

376375 (FL.transform

377376 (Pipe.mapM (\x -> return $ x + 1))

378377 FL.drain))

379378 , benchIOSink

380379 value

381380 "fold-scan"

382− (S.fold $ FL.scan FL.sum FL.drain)

381+ (Stream.fold $ FL.scan FL.sum FL.drain)

383382 , benchIOSink

384383 value

385384 "fold-scanMany"

386− (S.fold $ FL.scanMany (FL.take 2 FL.drain) FL.drain)

385+ (Stream.fold $ FL.scanMany (FL.take 2 FL.drain) FL.drain)

387386 , benchIOSink

388387 value

389388 "fold-postscan"

390− (S.fold $ FL.postscan FL.sum FL.drain)

389+ (Stream.fold $ FL.postscan FL.sum FL.drain)

391390 ]

392391 ]

393392

@@ -421,7 +420,7 @@ o_1_space_serial_composition value =

421420

422421o_n_space_serial :: Int -> [Benchmark]

423422o_n_space_serial value =

424− [ benchIOSink value "sequence_/100" $ S.fold (sequence_ (value `div` 100))

423+ [ benchIOSink value "sequence_/100" $ Stream.fold (sequence_ (value `div` 100))

425424 ]

426425

427426o_n_heap_serial :: Int -> [Benchmark]

@@ -430,14 +429,14 @@ o_n_heap_serial value =

430429 -- Left folds for building a structure are inherently non-streaming

431430 -- as the structure cannot be lazily consumed until fully built.

432431 [

433− benchIOSink value "toList" (S.fold FL.toList)

434− , benchIOSink value "toListRev" (S.fold FL.toListRev)

432+ benchIOSink value "toList" (Stream.fold FL.toList)

433+ , benchIOSink value "toListRev" (Stream.fold FL.toListRev)

435434 , benchIOSink value "toStream"

436− (S.fold FL.toStream

437− :: SerialT IO a -> IO (SerialT Identity a))

435+ (Stream.fold FL.toStream

436+ :: Stream IO a -> IO (Stream Identity a))

438437 , benchIOSink value "toStreamRev"

439− (S.fold FL.toStreamRev

440− :: SerialT IO a -> IO (SerialT Identity a))

438+ (Stream.fold FL.toStreamRev

439+ :: Stream IO a -> IO (Stream Identity a))

441440 ]

442441 , bgroup "key-value"

443442 [

benchmark/Streamly/Benchmark/Data/Fold/Window.hs+3−3

@@ -2,7 +2,7 @@ module Main (main) where

33import Control.DeepSeq (NFData)

44import Streamly.Data.Fold (Fold)

5−import Streamly.Prelude (SerialT)

5+import Streamly.Internal.Data.Stream (Stream)

66import System.Random (randomRIO)

88import qualified Streamly.Data.Fold as Fold

@@ -33,7 +33,7 @@ sourceDescendingInt = sourceDescending

3333

3434{-# INLINE benchWith #-}

3535benchWith :: (Num a, NFData b) =>

36− (Int -> a -> SerialT IO a) -> Int -> String -> Fold IO a b -> Benchmark

36+ (Int -> a -> Stream IO a) -> Int -> String -> Fold IO a b -> Benchmark

3737benchWith src len name f =

3838 bench name

3939 $ nfIO

@@ -49,7 +49,7 @@ benchWithFoldInt = benchWith source

4949

5050{-# INLINE benchScanWith #-}

5151benchScanWith :: Num a =>

52− (Int -> a -> SerialT IO a) -> Int -> String -> Fold IO a b -> Benchmark

52+ (Int -> a -> Stream IO a) -> Int -> String -> Fold IO a b -> Benchmark

5353benchScanWith src len name f =

5454 bench name

5555 $ nfIO

benchmark/Streamly/Benchmark/Data/Parser.hs+116−116

@@ -31,16 +31,16 @@ import qualified Data.Traversable as TR

3131import qualified Data.Foldable as F

3232import qualified Control.Applicative as AP

3333import qualified Streamly.FileSystem.Handle as Handle

34−import qualified Streamly.Prelude as S

3534import qualified Streamly.Internal.Data.Array.Unboxed as Array

36−import qualified Streamly.Internal.Data.Fold as FL

35+import qualified Streamly.Internal.Data.Fold as Fold

3736import qualified Streamly.Internal.Data.Parser as PR

38−import qualified Streamly.Internal.Data.Stream.IsStream as IP

37+import qualified Streamly.Internal.Data.Stream as Stream

38+import qualified Streamly.Internal.Data.Stream.IsStream as IsStream (tail)

3939import qualified Streamly.Internal.Data.Producer as Producer

4040import qualified Streamly.Internal.Data.Producer.Source as Source

4141

4242import Gauge hiding (env)

43−import Streamly.Prelude (SerialT)

43+import Streamly.Internal.Data.Stream (Stream)

4444import Streamly.Benchmark.Common

4545import Streamly.Benchmark.Common.Handle

4646

@@ -51,8 +51,8 @@ import Streamly.Benchmark.Common.Handle

5151-- XXX these can be moved to the common module

5252

5353{-# INLINE sourceUnfoldrM #-}

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

55−sourceUnfoldrM value n = S.unfoldrM step n

54+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

55+sourceUnfoldrM value n = Stream.unfoldrM step n

5656 where

5757 step cnt =

5858 if cnt > n + value

@@ -65,11 +65,11 @@ sourceUnfoldrM value n = S.unfoldrM step n

6565-- sequence of `}`.

6666{-# INLINE sourceEscapedFrames #-}

6767sourceEscapedFrames ::

68− (S.IsStream t, S.MonadAsync m)

68+ Monad m

6969 => Int

7070 -> Int

71− -> t m Char

72−sourceEscapedFrames value n = S.unfoldrM step n

71+ -> Stream m Char

72+sourceEscapedFrames value n = Stream.unfoldrM step n

7373 where

7474

7575 bs = '\\'

@@ -91,10 +91,10 @@ sourceEscapedFrames value n = S.unfoldrM step n

9191{-# INLINE benchIOSrc #-}

9292benchIOSrc

9393 :: NFData b

94− => (Int -> Int -> t IO a)

94+ => (Int -> Int -> Stream IO a)

9595 -> Int

9696 -> String

97− -> (t IO a -> IO b)

97+ -> (Stream IO a -> IO b)

9898 -> Benchmark

9999benchIOSrc src value name f =

100100 bench name $ nfIO $ randomRIO (1,1) >>= f . src value

@@ -102,8 +102,8 @@ benchIOSrc src value name f =

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

103103{-# INLINE benchIOSink #-}

104104benchIOSink

105− :: (S.IsStream t, NFData b)

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

105+ :: NFData b

106+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

107107benchIOSink value name f =

108108 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

109109

@@ -112,38 +112,38 @@ benchIOSink value name f =

112112-------------------------------------------------------------------------------

113113

114114{-# INLINE one #-}

115−one :: MonadCatch m => Int -> SerialT m Int -> m (Maybe Int)

116−one value = IP.parse p

115+one :: MonadCatch m => Int -> Stream m Int -> m (Maybe Int)

116+one value = Stream.parse p

117117

118118 where

119119

120120 p = do

121− m <- PR.fromFold FL.one

121+ m <- PR.fromFold Fold.one

122122 case m of

123123 Just i -> if i >= value then pure m else p

124124 Nothing -> pure Nothing

125125

126126{-# INLINE takeBetween #-}

127−takeBetween :: MonadCatch m => Int -> SerialT m a -> m ()

128−takeBetween value = IP.parse (PR.takeBetween 0 value FL.drain)

127+takeBetween :: MonadCatch m => Int -> Stream m a -> m ()

128+takeBetween value = Stream.parse (PR.takeBetween 0 value Fold.drain)

129129

130130{-# INLINE takeEQ #-}

131−takeEQ :: MonadCatch m => Int -> SerialT m a -> m ()

132−takeEQ value = IP.parse (PR.takeEQ value FL.drain)

131+takeEQ :: MonadCatch m => Int -> Stream m a -> m ()

132+takeEQ value = Stream.parse (PR.takeEQ value Fold.drain)

133133

134134{-# INLINE dropWhile #-}

135−dropWhile :: MonadCatch m => Int -> SerialT m Int -> m ()

136−dropWhile value = IP.parse (PR.dropWhile (<= value))

135+dropWhile :: MonadCatch m => Int -> Stream m Int -> m ()

136+dropWhile value = Stream.parse (PR.dropWhile (<= value))

137137

138138{-# INLINE takeStartBy #-}

139−takeStartBy :: MonadCatch m => Int -> SerialT m Int -> m ()

139+takeStartBy :: MonadCatch m => Int -> Stream m Int -> m ()

140140takeStartBy value stream = do

141− stream1 <- return . fromMaybe (S.fromPure (value + 1)) =<< S.tail stream

142− let stream2 = value `S.cons` stream1

143− IP.parse (PR.takeStartBy (== value) FL.drain) stream2

141+ stream1 <- return . fromMaybe (Stream.fromPure (value + 1)) =<< IsStream.tail stream

142+ let stream2 = value `Stream.cons` stream1

143+ Stream.parse (PR.takeStartBy (== value) Fold.drain) stream2

144144

145−takeFramedByEsc_ :: MonadCatch m => Int -> SerialT m Char -> m ()

146−takeFramedByEsc_ _ = IP.parse parser

145+takeFramedByEsc_ :: MonadCatch m => Int -> Stream m Char -> m ()

146+takeFramedByEsc_ _ = Stream.parse parser

147147

148148 where

149149

@@ -151,82 +151,82 @@ takeFramedByEsc_ _ = IP.parse parser

151151 isBegin = (== '{')

152152 isEnd = (== '}')

153153

154− parser = PR.takeFramedByEsc_ isEsc isBegin isEnd FL.drain

154+ parser = PR.takeFramedByEsc_ isEsc isBegin isEnd Fold.drain

155155

156156{-# INLINE takeWhile #-}

157−takeWhile :: MonadCatch m => Int -> SerialT m Int -> m ()

158−takeWhile value = IP.parse (PR.takeWhile (<= value) FL.drain)

157+takeWhile :: MonadCatch m => Int -> Stream m Int -> m ()

158+takeWhile value = Stream.parse (PR.takeWhile (<= value) Fold.drain)

159159

160−takeWhileP :: MonadCatch m => Int -> SerialT m Int -> m ()

160+takeWhileP :: MonadCatch m => Int -> Stream m Int -> m ()

161161takeWhileP value =

162− IP.parse (PR.takeWhileP (<= value) (PR.takeWhile (<= value - 1) FL.drain))

162+ Stream.parse (PR.takeWhileP (<= value) (PR.takeWhile (<= value - 1) Fold.drain))

163163

164164{-# INLINE takeP #-}

165−takeP :: MonadCatch m => Int -> SerialT m a -> m ()

166−takeP value = IP.parse (PR.takeP value (PR.fromFold FL.drain))

165+takeP :: MonadCatch m => Int -> Stream m a -> m ()

166+takeP value = Stream.parse (PR.takeP value (PR.fromFold Fold.drain))

167167

168168{-# INLINE groupBy #-}

169−groupBy :: MonadCatch m => SerialT m Int -> m ()

170−groupBy = IP.parse (PR.groupBy (<=) FL.drain)

169+groupBy :: MonadCatch m => Stream m Int -> m ()

170+groupBy = Stream.parse (PR.groupBy (<=) Fold.drain)

171171

172172{-# INLINE groupByRolling #-}

173−groupByRolling :: MonadCatch m => SerialT m Int -> m ()

174−groupByRolling = IP.parse (PR.groupByRolling (<=) FL.drain)

173+groupByRolling :: MonadCatch m => Stream m Int -> m ()

174+groupByRolling = Stream.parse (PR.groupByRolling (<=) Fold.drain)

175175

176176{-# INLINE wordBy #-}

177−wordBy :: MonadCatch m => Int -> SerialT m Int -> m ()

178−wordBy value = IP.parse (PR.wordBy (>= value) FL.drain)

177+wordBy :: MonadCatch m => Int -> Stream m Int -> m ()

178+wordBy value = Stream.parse (PR.wordBy (>= value) Fold.drain)

179179

180180{-# INLINE sepByWords #-}

181−sepByWords :: MonadCatch m => Int -> SerialT m Int -> m ()

182−sepByWords _ = IP.parse (wrds even FL.drain)

181+sepByWords :: MonadCatch m => Int -> Stream m Int -> m ()

182+sepByWords _ = Stream.parse (wrds even Fold.drain)

183183 where

184− wrds p f = PR.sepBy f (PR.takeWhile (not . p) FL.drain) (PR.dropWhile p)

184+ wrds p f = PR.sepBy f (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)

185185

186186{-# INLINE deintercalate #-}

187−deintercalate :: MonadCatch m => Int -> SerialT m Int -> m ()

188−deintercalate _ = IP.parse (partition even)

187+deintercalate :: MonadCatch m => Int -> Stream m Int -> m ()

188+deintercalate _ = Stream.parse (partition even)

189189

190190 where

191191

192192 partition p =

193193 PR.deintercalate

194− FL.drain (PR.takeWhile (not . p) FL.sum) (PR.takeWhile p FL.sum)

194+ Fold.drain (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum)

195195

196196{-# INLINE manyWordByEven #-}

197−manyWordByEven :: MonadCatch m => SerialT m Int -> m ()

198−manyWordByEven = IP.parse (PR.many (PR.wordBy even FL.drain) FL.drain)

197+manyWordByEven :: MonadCatch m => Stream m Int -> m ()

198+manyWordByEven = Stream.parse (PR.many (PR.wordBy even Fold.drain) Fold.drain)

199199

200200{-# INLINE many #-}

201−many :: MonadCatch m => SerialT m Int -> m Int

202−many = IP.parse (PR.many (PR.satisfy (> 0)) FL.length)

201+many :: MonadCatch m => Stream m Int -> m Int

202+many = Stream.parse (PR.many (PR.satisfy (> 0)) Fold.length)

203203

204204{-# INLINE manyAlt #-}

205−manyAlt :: MonadCatch m => SerialT m Int -> m Int

205+manyAlt :: MonadCatch m => Stream m Int -> m Int

206206manyAlt xs = do

207− x <- IP.parse (AP.many (PR.satisfy (> 0))) xs

207+ x <- Stream.parse (AP.many (PR.satisfy (> 0))) xs

208208 return $ Prelude.length x

209209

210210{-# INLINE some #-}

211−some :: MonadCatch m => SerialT m Int -> m Int

212−some = IP.parse (PR.some (PR.satisfy (> 0)) FL.length)

211+some :: MonadCatch m => Stream m Int -> m Int

212+some = Stream.parse (PR.some (PR.satisfy (> 0)) Fold.length)

213213

214214{-# INLINE someAlt #-}

215−someAlt :: MonadCatch m => SerialT m Int -> m Int

215+someAlt :: MonadCatch m => Stream m Int -> m Int

216216someAlt xs = do

217− x <- IP.parse (AP.some (PR.satisfy (> 0))) xs

217+ x <- Stream.parse (AP.some (PR.satisfy (> 0))) xs

218218 return $ Prelude.length x

219219

220220{-# INLINE manyTill #-}

221−manyTill :: MonadCatch m => Int -> SerialT m Int -> m Int

221+manyTill :: MonadCatch m => Int -> Stream m Int -> m Int

222222manyTill value =

223− IP.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) FL.length)

223+ Stream.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) Fold.length)

224224

225225{-# INLINE splitAp #-}

226226splitAp :: MonadCatch m

227− => Int -> SerialT m Int -> m ((), ())

227+ => Int -> Stream m Int -> m ((), ())

228228splitAp value =

229− IP.parse

229+ Stream.parse

230230 ((,)

231231 <$> PR.dropWhile (<= (value `div` 2))

232232 <*> PR.dropWhile (<= value)

@@ -234,27 +234,27 @@ splitAp value =

234234

235235{-# INLINE splitApBefore #-}

236236splitApBefore :: MonadCatch m

237− => Int -> SerialT m Int -> m ()

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

238238splitApBefore value =

239− IP.parse

239+ Stream.parse

240240 ( PR.dropWhile (<= (value `div` 2))

241241 *> PR.dropWhile (<= value)

242242 )

243243

244244{-# INLINE splitApAfter #-}

245245splitApAfter :: MonadCatch m

246− => Int -> SerialT m Int -> m ()

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

247247splitApAfter value =

248− IP.parse

248+ Stream.parse

249249 ( PR.dropWhile (<= (value `div` 2))

250250 <* PR.dropWhile (<= value)

251251 )

252252

253253{-# INLINE serialWith #-}

254254serialWith :: MonadCatch m

255− => Int -> SerialT m Int -> m ((), ())

255+ => Int -> Stream m Int -> m ((), ())

256256serialWith value =

257− IP.parse

257+ Stream.parse

258258 (PR.serialWith (,)

259259 (PR.dropWhile (<= (value `div` 2)))

260260 (PR.dropWhile (<= value))

@@ -262,9 +262,9 @@ serialWith value =

262262

263263{-# INLINE split_ #-}

264264split_ :: MonadCatch m

265− => Int -> SerialT m Int -> m ()

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

266266split_ value =

267− IP.parse

267+ Stream.parse

268268 (PR.split_

269269 (PR.dropWhile (<= (value `div` 2)))

270270 (PR.dropWhile (<= value))

@@ -272,14 +272,14 @@ split_ value =

272272

273273{-# INLINE takeEndBy_ #-}

274274takeEndBy_ :: MonadCatch m

275− => Int -> SerialT m Int -> m()

276−takeEndBy_ value = IP.parse (PR.takeEndBy_ (>= value) (PR.fromFold FL.drain))

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

276+takeEndBy_ value = Stream.parse (PR.takeEndBy_ (>= value) (PR.fromFold Fold.drain))

277277

278278{-# INLINE teeAllAny #-}

279279teeAllAny :: MonadCatch m

280− => Int -> SerialT m Int -> m ((), ())

280+ => Int -> Stream m Int -> m ((), ())

281281teeAllAny value =

282− IP.parse

282+ Stream.parse

283283 (PR.teeWith (,)

284284 (PR.dropWhile (<= value))

285285 (PR.dropWhile (<= value))

@@ -287,9 +287,9 @@ teeAllAny value =

287287

288288{-# INLINE teeFstAllAny #-}

289289teeFstAllAny :: MonadCatch m

290− => Int -> SerialT m Int -> m ((), ())

290+ => Int -> Stream m Int -> m ((), ())

291291teeFstAllAny value =

292− IP.parse

292+ Stream.parse

293293 (PR.teeWithFst (,)

294294 (PR.dropWhile (<= value))

295295 (PR.dropWhile (<= value))

@@ -297,9 +297,9 @@ teeFstAllAny value =

297297

298298{-# INLINE shortestAllAny #-}

299299shortestAllAny :: MonadCatch m

300− => Int -> SerialT m Int -> m ()

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

301301shortestAllAny value =

302− IP.parse

302+ Stream.parse

303303 (PR.shortest

304304 (PR.dropWhile (<= value))

305305 (PR.dropWhile (<= value))

@@ -307,9 +307,9 @@ shortestAllAny value =

307307

308308{-# INLINE longestAllAny #-}

309309longestAllAny :: MonadCatch m

310− => Int -> SerialT m Int -> m ()

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

311311longestAllAny value =

312− IP.parse

312+ Stream.parse

313313 (PR.longest

314314 (PR.dropWhile (<= value))

315315 (PR.dropWhile (<= value))

@@ -317,10 +317,10 @@ longestAllAny value =

317317

318318parseManyChunksOfSum :: Int -> Handle -> IO Int

319319parseManyChunksOfSum n inh =

320− S.length

321− $ IP.parseMany

322− (PR.fromFold $ FL.take n FL.sum)

323− (S.unfold Handle.read inh)

320+ Stream.fold Fold.length

321+ $ Stream.parseMany

322+ (PR.fromFold $ Fold.take n Fold.sum)

323+ (Stream.unfold Handle.read inh)

324324

325325-------------------------------------------------------------------------------

326326-- Parsing with unfolds

@@ -330,13 +330,13 @@ parseManyChunksOfSum n inh =

330330parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()

331331parseManyUnfoldArrays count arrays = do

332332 let src = Source.source (Just (Producer.OuterLoop arrays))

333− let parser = PR.fromFold (FL.take count FL.drain)

333+ let parser = PR.fromFold (Fold.take count Fold.drain)

334334 let readSrc =

335335 Source.producer

336336 $ Producer.concat Producer.fromList Array.producer

337337 let streamParser =

338338 Producer.simplify (Source.parseMany parser readSrc)

339− S.drain $ S.unfold streamParser src

339+ Stream.fold Fold.drain $ Stream.unfold streamParser src

340340

341341-------------------------------------------------------------------------------

342342-- Parsers in which -fspec-constr-recursive=16 is problematic

@@ -347,42 +347,42 @@ parseManyUnfoldArrays count arrays = do

347347-- not have to rely on it.

348348--

349349{-# INLINE lookAhead #-}

350−lookAhead :: MonadCatch m => Int -> SerialT m Int -> m ()

350+lookAhead :: MonadCatch m => Int -> Stream m Int -> m ()

351351lookAhead value =

352− IP.parse (PR.lookAhead (PR.takeWhile (<= value) FL.drain) $> ())

352+ Stream.parse (PR.lookAhead (PR.takeWhile (<= value) Fold.drain) $> ())

353353

354354{-# INLINE sequenceA #-}

355−sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int

355+sequenceA :: MonadCatch m => Int -> Stream m Int -> m Int

356356sequenceA value xs = do

357− x <- IP.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

357+ x <- Stream.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

358358 return $ length x

359359

360360{-# INLINE sequenceA_ #-}

361−sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()

361+sequenceA_ :: MonadCatch m => Int -> Stream m Int -> m ()

362362sequenceA_ value =

363− IP.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

363+ Stream.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

364364

365365{-# INLINE sequence #-}

366−sequence :: MonadCatch m => Int -> SerialT m Int -> m Int

366+sequence :: MonadCatch m => Int -> Stream m Int -> m Int

367367sequence value xs = do

368− x <- IP.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

368+ x <- Stream.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

369369 return $ length x

370370

371371{-# INLINE sequence_ #-}

372−sequence_ :: MonadCatch m => Int -> SerialT m Int -> m ()

372+sequence_ :: MonadCatch m => Int -> Stream m Int -> m ()

373373sequence_ value =

374− IP.parse (F.sequence_ $ replicate value (PR.satisfy (> 0)))

374+ Stream.parse (F.sequence_ $ replicate value (PR.satisfy (> 0)))

375375

376376{-# INLINE choiceAsum #-}

377−choiceAsum :: MonadCatch m => Int -> SerialT m Int -> m Int

377+choiceAsum :: MonadCatch m => Int -> Stream m Int -> m Int

378378choiceAsum value =

379− IP.parse (asum (replicate value (PR.satisfy (< 0)))

379+ Stream.parse (asum (replicate value (PR.satisfy (< 0)))

380380 AP.<|> PR.satisfy (> 0))

381381

382382{-# INLINE choice #-}

383−choice :: MonadCatch m => Int -> SerialT m Int -> m Int

383+choice :: MonadCatch m => Int -> Stream m Int -> m Int

384384choice value =

385− IP.parse

385+ Stream.parse

386386 (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))

387387

388388-------------------------------------------------------------------------------

@@ -390,32 +390,32 @@ choice value =

390390-------------------------------------------------------------------------------

391391

392392{-# INLINE parseMany #-}

393−parseMany :: MonadCatch m => Int -> SerialT m Int -> m ()

393+parseMany :: MonadCatch m => Int -> Stream m Int -> m ()

394394parseMany n =

395− S.drain

396− . S.map getSum

397− . IP.parseMany (PR.fromFold $ FL.take n FL.mconcat)

398− . S.map Sum

395+ Stream.fold Fold.drain

396+ . fmap getSum

397+ . Stream.parseMany (PR.fromFold $ Fold.take n Fold.mconcat)

398+ . fmap Sum

399399

400400{-# INLINE parseIterate #-}

401−parseIterate :: MonadCatch m => Int -> SerialT m Int -> m ()

401+parseIterate :: MonadCatch m => Int -> Stream m Int -> m ()

402402parseIterate n =

403− S.drain

404− . S.map getSum

405− . IP.parseIterate (PR.fromFold . FL.take n . FL.sconcat) (Sum 0)

406− . S.map Sum

403+ Stream.fold Fold.drain

404+ . fmap getSum

405+ . Stream.parseIterate (PR.fromFold . Fold.take n . Fold.sconcat) (Sum 0)

406+ . fmap Sum

407407

408408{-# INLINE parseBreak #-}

409−parseBreak :: MonadCatch m => SerialT m Int -> m ()

409+parseBreak :: MonadCatch m => Stream m Int -> m ()

410410parseBreak s = do

411− r <- try $ IP.parseBreak PR.one s

411+ r <- try $ Stream.parseBreak PR.one s

412412 case r of

413413 Left (_ :: SomeException) -> return ()

414414 Right (_, s1) -> parseBreak s1

415415

416416{-# INLINE concatSequence #-}

417−concatSequence :: MonadCatch m => SerialT m Int -> m ()

418−concatSequence = IP.parse $ PR.concatSequence FL.drain $ S.repeat PR.one

417+concatSequence :: MonadCatch m => Stream m Int -> m ()

418+concatSequence = Stream.parse $ PR.concatSequence Fold.drain $ Stream.repeat PR.one

419419

420420-------------------------------------------------------------------------------

421421-- Benchmarks

@@ -464,9 +464,9 @@ o_1_space_serial value =

464464

465465o_1_space_filesystem :: BenchEnv -> [Benchmark]

466466o_1_space_filesystem env =

467− [ mkBench ("S.parseMany (FL.take " ++ show (bigSize env) ++ " FL.sum)") env

467+ [ mkBench ("S.parseMany (Fold.take " ++ show (bigSize env) ++ " Fold.sum)") env

468468 $ \inh _ -> noinline parseManyChunksOfSum (bigSize env) inh

469− , mkBench "S.parseMany (FL.take 1 FL.sum)" env

469+ , mkBench "S.parseMany (Fold.take 1 Fold.sum)" env

470470 $ \inh _ -> inline parseManyChunksOfSum 1 inh

471471 ]

472472

@@ -514,7 +514,7 @@ main = do

514514

515515 where

516516

517− alloc value = IP.toList $ IP.arraysOf 100 $ sourceUnfoldrM value 0

517+ alloc value = Stream.fold Fold.toList $ Stream.arraysOf 100 $ sourceUnfoldrM value 0

518518

519519 allBenchmarks env arrays value =

520520 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)

benchmark/Streamly/Benchmark/Data/Parser/ParserD.hs+86−86

@@ -19,23 +19,23 @@ import Control.Monad.Catch (MonadCatch, MonadThrow)

1919import Data.Foldable (asum)

2020import Data.Functor (($>))

2121import Data.Maybe (fromMaybe)

22+import Streamly.Internal.Data.Stream (Stream)

2223import System.Random (randomRIO)

2324import Prelude hiding (any, all, take, sequence, sequenceA, sequence_, takeWhile, span)

2425

2526import qualified Data.Traversable as TR

2627import qualified Data.Foldable as F

2728import qualified Control.Applicative as AP

28−import qualified Streamly.Prelude as S

2929import qualified Streamly.Internal.Data.Array.Unboxed as Array

30−import qualified Streamly.Internal.Data.Fold as FL

30+import qualified Streamly.Internal.Data.Fold as Fold

3131import qualified Streamly.Internal.Data.Parser.ParserD as PR

3232import qualified Streamly.Internal.Data.Producer as Producer

3333import qualified Streamly.Internal.Data.Producer.Source as Source

34−import qualified Streamly.Internal.Data.Stream.IsStream as IP

34+import qualified Streamly.Internal.Data.Stream as Stream

35+import qualified Streamly.Internal.Data.Stream.IsStream as IsStream (tail)

3536import qualified Streamly.Internal.Data.Stream.StreamD as D

3637

3738import Gauge

38−import Streamly.Prelude (SerialT, MonadAsync, IsStream)

3939import Streamly.Benchmark.Common

4040

4141-------------------------------------------------------------------------------

@@ -45,8 +45,8 @@ import Streamly.Benchmark.Common

4545-- XXX these can be moved to the common module

4646

4747{-# INLINE sourceUnfoldrM #-}

48−sourceUnfoldrM :: (IsStream t, MonadAsync m) => Int -> Int -> t m Int

49−sourceUnfoldrM value n = S.unfoldrM step n

48+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

49+sourceUnfoldrM value n = Stream.unfoldrM step n

5050 where

5151 step cnt =

5252 if cnt > n + value

@@ -56,20 +56,20 @@ sourceUnfoldrM value n = S.unfoldrM step n

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

5757{-# INLINE benchIOSink #-}

5858benchIOSink

59− :: (IsStream t, NFData b)

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

59+ :: (NFData b)

60+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

6161benchIOSink value name f =

6262 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

6363

6464-- Make the input unsorted.

6565{-# INLINE benchIOSinkRandom #-}

6666benchIOSinkRandom

67− :: (IsStream t, NFData b)

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

67+ :: (NFData b)

68+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

6969benchIOSinkRandom value name f =

7070 bench name $ nfIO $ randomRIO (1,1)

7171 >>= f

72− . S.map (\x -> if even x then x + 2 else x)

72+ . fmap (\x -> if even x then x + 2 else x)

7373 . sourceUnfoldrM value

7474

7575-------------------------------------------------------------------------------

@@ -78,80 +78,80 @@ benchIOSinkRandom value name f =

7878

7979{-# INLINE drainWhile #-}

8080drainWhile :: MonadThrow m => (a -> Bool) -> PR.Parser m a ()

81−drainWhile p = PR.takeWhile p FL.drain

81+drainWhile p = PR.takeWhile p Fold.drain

8282

8383{-# INLINE takeStartBy #-}

84−takeStartBy :: MonadCatch m => Int -> SerialT m Int -> m ()

84+takeStartBy :: MonadCatch m => Int -> Stream m Int -> m ()

8585takeStartBy value stream = do

86− stream1 <- return . fromMaybe (S.fromPure (value + 1)) =<< S.tail stream

87− let stream2 = value `S.cons` stream1

88− IP.parseD (PR.takeStartBy (== value) FL.drain) stream2

86+ stream1 <- return . fromMaybe (Stream.fromPure (value + 1)) =<< IsStream.tail stream

87+ let stream2 = value `Stream.cons` stream1

88+ Stream.parseD (PR.takeStartBy (== value) Fold.drain) stream2

8989

9090{-# INLINE takeWhile #-}

91−takeWhile :: MonadThrow m => Int -> SerialT m Int -> m ()

92−takeWhile value = IP.parseD (drainWhile (<= value))

91+takeWhile :: MonadThrow m => Int -> Stream m Int -> m ()

92+takeWhile value = Stream.parseD (drainWhile (<= value))

9393

9494{-# INLINE takeP #-}

95−takeP :: MonadThrow m => Int -> SerialT m a -> m ()

96−takeP value = IP.parseD (PR.takeP value (PR.fromFold FL.drain))

95+takeP :: MonadThrow m => Int -> Stream m a -> m ()

96+takeP value = Stream.parseD (PR.takeP value (PR.fromFold Fold.drain))

9797

9898{-# INLINE takeBetween #-}

99−takeBetween :: MonadCatch m => Int -> SerialT m a -> m ()

100−takeBetween value = IP.parseD (PR.takeBetween 0 value FL.drain)

99+takeBetween :: MonadCatch m => Int -> Stream m a -> m ()

100+takeBetween value = Stream.parseD (PR.takeBetween 0 value Fold.drain)

101101

102102{-# INLINE groupBy #-}

103−groupBy :: MonadThrow m => SerialT m Int -> m ()

104−groupBy = IP.parseD (PR.groupBy (<=) FL.drain)

103+groupBy :: MonadThrow m => Stream m Int -> m ()

104+groupBy = Stream.parseD (PR.groupBy (<=) Fold.drain)

105105

106106{-# INLINE groupByRolling #-}

107−groupByRolling :: MonadThrow m => SerialT m Int -> m ()

108−groupByRolling = IP.parseD (PR.groupByRolling (<=) FL.drain)

107+groupByRolling :: MonadThrow m => Stream m Int -> m ()

108+groupByRolling = Stream.parseD (PR.groupByRolling (<=) Fold.drain)

109109

110110{-# INLINE wordBy #-}

111−wordBy :: MonadThrow m => Int -> SerialT m Int -> m ()

112−wordBy value = IP.parseD (PR.wordBy (>= value) FL.drain)

111+wordBy :: MonadThrow m => Int -> Stream m Int -> m ()

112+wordBy value = Stream.parseD (PR.wordBy (>= value) Fold.drain)

113113

114114{-# INLINE manyWordByEven #-}

115−manyWordByEven :: MonadCatch m => SerialT m Int -> m ()

115+manyWordByEven :: MonadCatch m => Stream m Int -> m ()

116116manyWordByEven =

117− IP.parseD (PR.many (PR.wordBy (Prelude.even) FL.drain) FL.drain)

117+ Stream.parseD (PR.many (PR.wordBy (Prelude.even) Fold.drain) Fold.drain)

118118

119119{-# INLINE many #-}

120−many :: MonadCatch m => SerialT m Int -> m Int

121−many = IP.parseD (PR.many (PR.satisfy (> 0)) FL.length)

120+many :: MonadCatch m => Stream m Int -> m Int

121+many = Stream.parseD (PR.many (PR.satisfy (> 0)) Fold.length)

122122

123123{-# INLINE manyAlt #-}

124−manyAlt :: MonadCatch m => SerialT m Int -> m Int

124+manyAlt :: MonadCatch m => Stream m Int -> m Int

125125manyAlt xs = do

126− x <- IP.parseD (AP.many (PR.satisfy (> 0))) xs

126+ x <- Stream.parseD (AP.many (PR.satisfy (> 0))) xs

127127 return $ Prelude.length x

128128

129129{-# INLINE some #-}

130−some :: MonadCatch m => SerialT m Int -> m Int

131−some = IP.parseD (PR.some (PR.satisfy (> 0)) FL.length)

130+some :: MonadCatch m => Stream m Int -> m Int

131+some = Stream.parseD (PR.some (PR.satisfy (> 0)) Fold.length)

132132

133133{-# INLINE someAlt #-}

134−someAlt :: MonadCatch m => SerialT m Int -> m Int

134+someAlt :: MonadCatch m => Stream m Int -> m Int

135135someAlt xs = do

136− x <- IP.parseD (AP.some (PR.satisfy (> 0))) xs

136+ x <- Stream.parseD (AP.some (PR.satisfy (> 0))) xs

137137 return $ Prelude.length x

138138

139139{-#INLINE takeEndBy_ #-}

140−takeEndBy_ :: MonadCatch m => Int -> SerialT m Int -> m ()

141−takeEndBy_ value = IP.parseD (PR.takeEndBy_ (>= value) (PR.fromFold FL.drain))

140+takeEndBy_ :: MonadCatch m => Int -> Stream m Int -> m ()

141+takeEndBy_ value = Stream.parseD (PR.takeEndBy_ (>= value) (PR.fromFold Fold.drain))

142142

143143{-# INLINE manyTill #-}

144−manyTill :: MonadCatch m => Int -> SerialT m Int -> m Int

144+manyTill :: MonadCatch m => Int -> Stream m Int -> m Int

145145manyTill value =

146146 let p = PR.satisfy (> 0)

147147 pcond = PR.satisfy (== value)

148− in IP.parseD (PR.manyTill FL.length p pcond)

148+ in Stream.parseD (PR.manyTill Fold.length p pcond)

149149

150150{-# INLINE serialWith #-}

151151serialWith :: MonadThrow m

152− => Int -> SerialT m Int -> m ((), ())

152+ => Int -> Stream m Int -> m ((), ())

153153serialWith value =

154− IP.parseD

154+ Stream.parseD

155155 ((,)

156156 <$> drainWhile (<= (value `div` 2))

157157 <*> drainWhile (<= value)

@@ -159,9 +159,9 @@ serialWith value =

159159

160160{-# INLINE teeAllAny #-}

161161teeAllAny :: MonadThrow m

162− => Int -> SerialT m Int -> m ((), ())

162+ => Int -> Stream m Int -> m ((), ())

163163teeAllAny value =

164− IP.parseD

164+ Stream.parseD

165165 (PR.teeWith (,)

166166 (drainWhile (<= value))

167167 (drainWhile (<= value))

@@ -169,9 +169,9 @@ teeAllAny value =

169169

170170{-# INLINE teeFstAllAny #-}

171171teeFstAllAny :: MonadThrow m

172− => Int -> SerialT m Int -> m ((), ())

172+ => Int -> Stream m Int -> m ((), ())

173173teeFstAllAny value =

174− IP.parseD

174+ Stream.parseD

175175 (PR.teeWithFst (,)

176176 (drainWhile (<= value))

177177 (drainWhile (<= value))

@@ -179,9 +179,9 @@ teeFstAllAny value =

179179

180180{-# INLINE shortestAllAny #-}

181181shortestAllAny :: MonadThrow m

182− => Int -> SerialT m Int -> m ()

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

183183shortestAllAny value =

184− IP.parseD

184+ Stream.parseD

185185 (PR.shortest

186186 (drainWhile (<= value))

187187 (drainWhile (<= value))

@@ -189,59 +189,59 @@ shortestAllAny value =

189189

190190{-# INLINE longestAllAny #-}

191191longestAllAny :: MonadCatch m

192− => Int -> SerialT m Int -> m ()

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

193193longestAllAny value =

194− IP.parseD

194+ Stream.parseD

195195 (PR.longest

196196 (drainWhile (<= value))

197197 (drainWhile (<= value))

198198 )

199199

200200{-# INLINE sequenceParser #-}

201−sequenceParser :: MonadCatch m => SerialT m Int -> m ()

202−sequenceParser = IP.parseD (PR.sequence FL.drain (D.repeat (PR.satisfy $ const True)))

201+sequenceParser :: MonadCatch m => Stream m Int -> m ()

202+sequenceParser = Stream.parseD (PR.sequence Fold.drain (D.repeat (PR.satisfy $ const True)))

203203

204204-------------------------------------------------------------------------------

205205-- Spanning

206206-------------------------------------------------------------------------------

207207

208208{-# INLINE span #-}

209−span :: MonadThrow m => Int -> SerialT m Int -> m ((), ())

210−span value = IP.parseD (PR.span (<= (value `div` 2)) FL.drain FL.drain)

209+span :: MonadThrow m => Int -> Stream m Int -> m ((), ())

210+span value = Stream.parseD (PR.span (<= (value `div` 2)) Fold.drain Fold.drain)

211211

212212{-# INLINE spanBy #-}

213−spanBy :: MonadThrow m => Int -> SerialT m Int -> m ((), ())

213+spanBy :: MonadThrow m => Int -> Stream m Int -> m ((), ())

214214spanBy value =

215− IP.parseD (PR.spanBy (\_ i -> i <= (value `div` 2)) FL.drain FL.drain)

215+ Stream.parseD (PR.spanBy (\_ i -> i <= (value `div` 2)) Fold.drain Fold.drain)

216216

217217{-# INLINE spanByRolling #-}

218−spanByRolling :: MonadThrow m => Int -> SerialT m Int -> m ((), ())

218+spanByRolling :: MonadThrow m => Int -> Stream m Int -> m ((), ())

219219spanByRolling value =

220− IP.parseD (PR.spanByRolling (\_ i -> i <= value `div` 2) FL.drain FL.drain)

220+ Stream.parseD (PR.spanByRolling (\_ i -> i <= value `div` 2) Fold.drain Fold.drain)

221221

222222-------------------------------------------------------------------------------

223223-- Nested

224224-------------------------------------------------------------------------------

225225

226226{-# INLINE parseMany #-}

227−parseMany :: MonadThrow m => Int -> SerialT m Int -> m ()

228−parseMany value = IP.drain . IP.parseManyD (drainWhile (<= value + 1))

227+parseMany :: MonadThrow m => Int -> Stream m Int -> m ()

228+parseMany value = Stream.fold Fold.drain . Stream.parseManyD (drainWhile (<= value + 1))

229229

230230{-# INLINE parseManyGroups #-}

231−parseManyGroups :: MonadThrow m => Bool -> SerialT m Int -> m ()

232−parseManyGroups b = IP.drain . IP.parseManyD (PR.groupBy (\_ _ -> b) FL.drain)

231+parseManyGroups :: MonadThrow m => Bool -> Stream m Int -> m ()

232+parseManyGroups b = Stream.fold Fold.drain . Stream.parseManyD (PR.groupBy (\_ _ -> b) Fold.drain)

233233

234234{-# INLINE parseManyGroupsRolling #-}

235−parseManyGroupsRolling :: MonadThrow m => Bool -> SerialT m Int -> m ()

235+parseManyGroupsRolling :: MonadThrow m => Bool -> Stream m Int -> m ()

236236parseManyGroupsRolling b =

237− IP.drain . IP.parseManyD (PR.groupByRolling (\_ _ -> b) FL.drain)

237+ Stream.fold Fold.drain . Stream.parseManyD (PR.groupByRolling (\_ _ -> b) Fold.drain)

238238

239239{-# INLINE parseManyGroupsRollingEither #-}

240240parseManyGroupsRollingEither :: (MonadThrow m, MonadCatch m) =>

241− (Int -> Int -> Bool) -> SerialT m Int -> m ()

241+ (Int -> Int -> Bool) -> Stream m Int -> m ()

242242parseManyGroupsRollingEither cmp =

243− IP.drain

244− . IP.parseManyD (PR.groupByRollingEither cmp FL.drain FL.drain)

243+ Stream.fold Fold.drain

244+ . Stream.parseManyD (PR.groupByRollingEither cmp Fold.drain Fold.drain)

245245

246246-------------------------------------------------------------------------------

247247-- Parsing with unfolds

@@ -251,13 +251,13 @@ parseManyGroupsRollingEither cmp =

251251parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()

252252parseManyUnfoldArrays count arrays = do

253253 let src = Source.source (Just (Producer.OuterLoop arrays))

254− let parser = PR.fromFold (FL.take count FL.drain)

254+ let parser = PR.fromFold (Fold.take count Fold.drain)

255255 let readSrc =

256256 Source.producer

257257 $ Producer.concat Producer.fromList Array.producer

258258 let streamParser =

259259 Producer.simplify (Source.parseManyD parser readSrc)

260− S.drain $ S.unfold streamParser src

260+ Stream.fold Fold.drain $ Stream.unfold streamParser src

261261

262262-------------------------------------------------------------------------------

263263-- Parsers in which -fspec-constr-recursive=16 is problematic

@@ -268,33 +268,33 @@ parseManyUnfoldArrays count arrays = do

268268-- not have to rely on it.

269269--

270270{-# INLINE lookAhead #-}

271−lookAhead :: MonadThrow m => Int -> SerialT m Int -> m ()

271+lookAhead :: MonadThrow m => Int -> Stream m Int -> m ()

272272lookAhead value =

273− IP.parseD (PR.lookAhead (PR.takeWhile (<= value) FL.drain) $> ())

273+ Stream.parseD (PR.lookAhead (PR.takeWhile (<= value) Fold.drain) $> ())

274274

275275{-# INLINE sequenceA_ #-}

276−sequenceA_ :: MonadThrow m => Int -> SerialT m Int -> m ()

276+sequenceA_ :: MonadThrow m => Int -> Stream m Int -> m ()

277277sequenceA_ value =

278− IP.parseD (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

278+ Stream.parseD (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

279279

280280-- quadratic complexity

281281{-# INLINE sequenceA #-}

282−sequenceA :: MonadThrow m => Int -> SerialT m Int -> m Int

282+sequenceA :: MonadThrow m => Int -> Stream m Int -> m Int

283283sequenceA value xs = do

284− x <- IP.parseD (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

284+ x <- Stream.parseD (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

285285 return $ length x

286286

287287-- quadratic complexity

288288{-# INLINE sequence #-}

289−sequence :: MonadThrow m => Int -> SerialT m Int -> m Int

289+sequence :: MonadThrow m => Int -> Stream m Int -> m Int

290290sequence value xs = do

291− x <- IP.parseD (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

291+ x <- Stream.parseD (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

292292 return $ length x

293293

294294{-# INLINE sequence_ #-}

295−sequence_ :: MonadCatch m => Int -> SerialT m Int -> m ()

295+sequence_ :: MonadCatch m => Int -> Stream m Int -> m ()

296296sequence_ value xs =

297− IP.parseD (foldr f (return ()) (replicate value (PR.takeBetween 0 1 FL.drain))) xs

297+ Stream.parseD (foldr f (return ()) (replicate value (PR.takeBetween 0 1 Fold.drain))) xs

298298

299299 where

300300

@@ -305,15 +305,15 @@ sequence_ value xs =

305305-- quadratic performance complexity.

306306--

307307{-# INLINE choiceAsum #-}

308−choiceAsum :: MonadCatch m => Int -> SerialT m Int -> m Int

308+choiceAsum :: MonadCatch m => Int -> Stream m Int -> m Int

309309choiceAsum value =

310− IP.parseD (asum (replicate value (PR.satisfy (< 0)))

310+ Stream.parseD (asum (replicate value (PR.satisfy (< 0)))

311311 AP.<|> PR.satisfy (> 0))

312312

313313{-# INLINE choice #-}

314−choice :: MonadCatch m => Int -> SerialT m Int -> m Int

314+choice :: MonadCatch m => Int -> Stream m Int -> m Int

315315choice value =

316− IP.parseD

316+ Stream.parseD

317317 (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))

318318

319319-------------------------------------------------------------------------------

@@ -410,7 +410,7 @@ main = runWithCLIOptsEnv defaultStreamSize alloc allBenchmarks

410410

411411 where

412412

413− alloc value = IP.toList $ IP.arraysOf 100 $ sourceUnfoldrM value 0

413+ alloc value = Stream.fold Fold.toList $ Stream.arraysOf 100 $ sourceUnfoldrM value 0

414414

415415 allBenchmarks arraysSmall value =

416416 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)

benchmark/Streamly/Benchmark/Data/Parser/ParserK.hs+16−17

@@ -16,20 +16,19 @@ module Main

1616import Control.DeepSeq (NFData(..))

1717import Control.Monad.Catch (MonadCatch)

1818import Data.Foldable (asum)

19+import Streamly.Internal.Data.Stream (Stream)

1920import System.Random (randomRIO)

2021import Prelude hiding (any, all, take, sequence, sequenceA, takeWhile)

2122

2223import qualified Control.Applicative as AP

2324import qualified Data.Foldable as F

2425import qualified Data.Traversable as TR

25−import qualified Streamly.Prelude as S

2626import qualified Streamly.Internal.Data.Fold as FL

2727import qualified Streamly.Internal.Data.Parser.ParserK.Type as PR

2828import qualified Streamly.Internal.Data.Parser.ParserD as PRD

29−import qualified Streamly.Internal.Data.Stream.IsStream as IP

29+import qualified Streamly.Internal.Data.Stream as Stream

3030

3131import Gauge

32−import Streamly.Prelude (SerialT, MonadAsync, IsStream)

3332import Streamly.Benchmark.Common

3433

3534-------------------------------------------------------------------------------

@@ -39,8 +38,8 @@ import Streamly.Benchmark.Common

3938-- XXX these can be moved to the common module

4039

4140{-# INLINE sourceUnfoldrM #-}

42−sourceUnfoldrM :: (IsStream t, MonadAsync m) => Int -> Int -> t m Int

43−sourceUnfoldrM value n = S.unfoldrM step n

41+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

42+sourceUnfoldrM value n = Stream.unfoldrM step n

4443 where

4544 step cnt =

4645 if cnt > n + value

@@ -50,8 +49,8 @@ sourceUnfoldrM value n = S.unfoldrM step n

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

5150{-# INLINE benchIOSink #-}

5251benchIOSink

53− :: (IsStream t, NFData b)

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

52+ :: NFData b

53+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

5554benchIOSink value name f =

5655 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

5756

@@ -60,9 +59,9 @@ benchIOSink value name f =

6059-------------------------------------------------------------------------------

6160

6261#ifdef FROM_PARSERK

63−#define PARSE_OP (IP.parseD . PRD.fromParserK)

62+#define PARSE_OP (Stream.parseD . PRD.fromParserK)

6463#else

65−#define PARSE_OP IP.parseK

64+#define PARSE_OP Stream.parseK

6665#endif

6766

6867{-# INLINE satisfy #-}

@@ -74,17 +73,17 @@ takeWhile :: MonadCatch m => (a -> Bool) -> PR.Parser m a ()

7473takeWhile p = PRD.toParserK $ PRD.takeWhile p FL.drain

7574

7675{-# INLINE takeWhileK #-}

77−takeWhileK :: MonadCatch m => Int -> SerialT m Int -> m ()

76+takeWhileK :: MonadCatch m => Int -> Stream m Int -> m ()

7877takeWhileK value = PARSE_OP (takeWhile (<= value))

7978

8079{-# INLINE splitApp #-}

8180splitApp :: MonadCatch m

82− => Int -> SerialT m Int -> m ((), ())

81+ => Int -> Stream m Int -> m ((), ())

8382splitApp value =

8483 PARSE_OP ((,) <$> takeWhile (<= (value `div` 2)) <*> takeWhile (<= value))

8584

8685{-# INLINE sequenceA #-}

87−sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int

86+sequenceA :: MonadCatch m => Int -> Stream m Int -> m Int

8887sequenceA value xs = do

8988 let parser = satisfy (> 0)

9089 list = Prelude.replicate value parser

@@ -92,14 +91,14 @@ sequenceA value xs = do

9291 return $ Prelude.length x

9392

9493{-# INLINE sequenceA_ #-}

95−sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()

94+sequenceA_ :: MonadCatch m => Int -> Stream m Int -> m ()

9695sequenceA_ value xs = do

9796 let parser = satisfy (> 0)

9897 list = Prelude.replicate value parser

9998 PARSE_OP (F.sequenceA_ list) xs

10099

101100{-# INLINE sequence #-}

102−sequence :: MonadCatch m => Int -> SerialT m Int -> m Int

101+sequence :: MonadCatch m => Int -> Stream m Int -> m Int

103102sequence value xs = do

104103 let parser = satisfy (> 0)

105104 list = Prelude.replicate value parser

@@ -107,19 +106,19 @@ sequence value xs = do

107106 return $ Prelude.length x

108107

109108{-# INLINE manyAlt #-}

110−manyAlt :: MonadCatch m => SerialT m Int -> m Int

109+manyAlt :: MonadCatch m => Stream m Int -> m Int

111110manyAlt xs = do

112111 x <- PARSE_OP (AP.many (satisfy (> 0))) xs

113112 return $ Prelude.length x

114113

115114{-# INLINE someAlt #-}

116−someAlt :: MonadCatch m => SerialT m Int -> m Int

115+someAlt :: MonadCatch m => Stream m Int -> m Int

117116someAlt xs = do

118117 x <- PARSE_OP (AP.some (satisfy (> 0))) xs

119118 return $ Prelude.length x

120119

121120{-# INLINE choice #-}

122−choice :: MonadCatch m => Int -> SerialT m Int -> m Int

121+choice :: MonadCatch m => Int -> Stream m Int -> m Int

123122choice value =

124123 PARSE_OP (asum (replicate value (satisfy (< 0)))

125124 AP.<|> satisfy (> 0))

benchmark/Streamly/Benchmark/Data/Stream/Eliminate.hs+73−74

@@ -41,8 +41,7 @@ import qualified Streamly.Internal.Data.Stream as S

4141#endif

4242

4343import Gauge

44−-- XXX Replace SerialT with Stream

45−import Streamly.Internal.Data.Stream.Serial (SerialT)

44+import Streamly.Internal.Data.Stream (Stream)

4645#ifdef USE_PRELUDE

4746import Streamly.Prelude (fromSerial)

4847import Streamly.Benchmark.Prelude

@@ -76,90 +75,90 @@ repeat count = S.take count . S.repeat

7675{-# INLINE foldableFoldl' #-}

7776foldableFoldl' :: Int -> Int -> Int

7877foldableFoldl' value n =

79− F.foldl' (+) 0 (sourceUnfoldr value n :: SerialT Identity Int)

78+ F.foldl' (+) 0 (sourceUnfoldr value n :: Stream Identity Int)

8079

8180{-# INLINE foldableFoldrElem #-}

8281foldableFoldrElem :: Int -> Int -> Bool

8382foldableFoldrElem value n =

8483 F.foldr (\x xs -> x == value || xs)

8584 False

86− (sourceUnfoldr value n :: SerialT Identity Int)

85+ (sourceUnfoldr value n :: Stream Identity Int)

8786

8887{-# INLINE foldableSum #-}

8988foldableSum :: Int -> Int -> Int

9089foldableSum value n =

91− Prelude.sum (sourceUnfoldr value n :: SerialT Identity Int)

90+ Prelude.sum (sourceUnfoldr value n :: Stream Identity Int)

9291

9392{-# INLINE foldableProduct #-}

9493foldableProduct :: Int -> Int -> Int

9594foldableProduct value n =

96− Prelude.product (sourceUnfoldr value n :: SerialT Identity Int)

95+ Prelude.product (sourceUnfoldr value n :: Stream Identity Int)

9796

9897{-# INLINE _foldableNull #-}

9998_foldableNull :: Int -> Int -> Bool

10099_foldableNull value n =

101− Prelude.null (sourceUnfoldr value n :: SerialT Identity Int)

100+ Prelude.null (sourceUnfoldr value n :: Stream Identity Int)

102101

103102{-# INLINE foldableElem #-}

104103foldableElem :: Int -> Int -> Bool

105104foldableElem value n =

106− value `Prelude.elem` (sourceUnfoldr value n :: SerialT Identity Int)

105+ value `Prelude.elem` (sourceUnfoldr value n :: Stream Identity Int)

107106

108107{-# INLINE foldableNotElem #-}

109108foldableNotElem :: Int -> Int -> Bool

110109foldableNotElem value n =

111− value `Prelude.notElem` (sourceUnfoldr value n :: SerialT Identity Int)

110+ value `Prelude.notElem` (sourceUnfoldr value n :: Stream Identity Int)

112111

113112{-# INLINE foldableFind #-}

114113foldableFind :: Int -> Int -> Maybe Int

115114foldableFind value n =

116− F.find (== (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

115+ F.find (== (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

117116

118117{-# INLINE foldableAll #-}

119118foldableAll :: Int -> Int -> Bool

120119foldableAll value n =

121− Prelude.all (<= (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

120+ Prelude.all (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

122121

123122{-# INLINE foldableAny #-}

124123foldableAny :: Int -> Int -> Bool

125124foldableAny value n =

126− Prelude.any (> (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

125+ Prelude.any (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

127126

128127{-# INLINE foldableAnd #-}

129128foldableAnd :: Int -> Int -> Bool

130129foldableAnd value n =

131130 Prelude.and $ fmap

132− (<= (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

131+ (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

133132

134133{-# INLINE foldableOr #-}

135134foldableOr :: Int -> Int -> Bool

136135foldableOr value n =

137136 Prelude.or $ fmap

138− (> (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

137+ (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

139138

140139{-# INLINE foldableLength #-}

141140foldableLength :: Int -> Int -> Int

142141foldableLength value n =

143− Prelude.length (sourceUnfoldr value n :: SerialT Identity Int)

142+ Prelude.length (sourceUnfoldr value n :: Stream Identity Int)

144143

145144{-# INLINE foldableMin #-}

146145foldableMin :: Int -> Int -> Int

147146foldableMin value n =

148− Prelude.minimum (sourceUnfoldr value n :: SerialT Identity Int)

147+ Prelude.minimum (sourceUnfoldr value n :: Stream Identity Int)

149148

150149{-# INLINE ordInstanceMin #-}

151−ordInstanceMin :: SerialT Identity Int -> SerialT Identity Int

150+ordInstanceMin :: Stream Identity Int -> Stream Identity Int

152151ordInstanceMin src = min src src

153152

154153{-# INLINE foldableMax #-}

155154foldableMax :: Int -> Int -> Int

156155foldableMax value n =

157− Prelude.maximum (sourceUnfoldr value n :: SerialT Identity Int)

156+ Prelude.maximum (sourceUnfoldr value n :: Stream Identity Int)

158157

159158{-# INLINE foldableMinBy #-}

160159foldableMinBy :: Int -> Int -> Int

161160foldableMinBy value n =

162− F.minimumBy compare (sourceUnfoldr value n :: SerialT Identity Int)

161+ F.minimumBy compare (sourceUnfoldr value n :: Stream Identity Int)

163162

164163{-# INLINE foldableListMinBy #-}

165164foldableListMinBy :: Int -> Int -> Int

@@ -168,30 +167,30 @@ foldableListMinBy value n = F.minimumBy compare [1..value+n]

168167{-# INLINE foldableMaxBy #-}

169168foldableMaxBy :: Int -> Int -> Int

170169foldableMaxBy value n =

171− F.maximumBy compare (sourceUnfoldr value n :: SerialT Identity Int)

170+ F.maximumBy compare (sourceUnfoldr value n :: Stream Identity Int)

172171

173172{-# INLINE foldableToList #-}

174173foldableToList :: Int -> Int -> [Int]

175174foldableToList value n =

176− F.toList (sourceUnfoldr value n :: SerialT Identity Int)

175+ F.toList (sourceUnfoldr value n :: Stream Identity Int)

177176

178177{-# INLINE foldableMapM_ #-}

179178foldableMapM_ :: Monad m => Int -> Int -> m ()

180179foldableMapM_ value n =

181− F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: SerialT Identity Int)

180+ F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: Stream Identity Int)

182181

183182{-# INLINE foldableSequence_ #-}

184183foldableSequence_ :: Int -> Int -> IO ()

185184foldableSequence_ value n =

186− F.sequence_ (sourceUnfoldrAction value n :: SerialT Identity (IO Int))

185+ F.sequence_ (sourceUnfoldrAction value n :: Stream Identity (IO Int))

187186

188187{-# INLINE _foldableMsum #-}

189188_foldableMsum :: Int -> Int -> IO Int

190189_foldableMsum value n =

191− F.msum (sourceUnfoldrAction value n :: SerialT Identity (IO Int))

190+ F.msum (sourceUnfoldrAction value n :: Stream Identity (IO Int))

192191

193192{-# INLINE showInstance #-}

194−showInstance :: SerialT Identity Int -> String

193+showInstance :: Stream Identity Int -> String

195194showInstance = show

196195

197196o_1_space_elimination_foldable :: Int -> [Benchmark]

@@ -251,13 +250,13 @@ o_n_space_elimination_foldable value =

251250

252251{-# INLINE benchPureSink #-}

253252benchPureSink :: NFData b

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

253+ => Int -> String -> (Stream Identity Int -> b) -> Benchmark

255254benchPureSink value name = benchPure name (sourceUnfoldr value)

256255

257256{-# INLINE benchHoistSink #-}

258257benchHoistSink

259258 :: (NFData b)

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

259+ => Int -> String -> (Stream Identity Int -> IO b) -> Benchmark

261260benchHoistSink value name f =

262261 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

263262

@@ -266,7 +265,7 @@ benchHoistSink value name f =

266265{-# INLINE benchIdentitySink #-}

267266benchIdentitySink

268267 :: (NFData b)

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

268+ => Int -> String -> (Stream Identity Int -> Identity b) -> Benchmark

270269benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

271270

272271-------------------------------------------------------------------------------

@@ -274,7 +273,7 @@ benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

274273-------------------------------------------------------------------------------

275274

276275{-# INLINE uncons #-}

277−uncons :: Monad m => SerialT m Int -> m ()

276+uncons :: Monad m => Stream m Int -> m ()

278277uncons s = do

279278 r <- S.uncons s

280279 case r of

@@ -283,16 +282,16 @@ uncons s = do

283282

284283#ifdef USE_PRELUDE

285284{-# INLINE init #-}

286−init :: Monad m => SerialT m a -> m ()

285+init :: Monad m => Stream m a -> m ()

287286init s = S.init s >>= Prelude.mapM_ S.drain

288287

289288{-# INLINE mapM_ #-}

290−mapM_ :: Monad m => SerialT m Int -> m ()

289+mapM_ :: Monad m => Stream m Int -> m ()

291290mapM_ = S.mapM_ (\_ -> return ())

292291#endif

293292

294293{-# INLINE foldrMElem #-}

295−foldrMElem :: Monad m => Int -> SerialT m Int -> m Bool

294+foldrMElem :: Monad m => Int -> Stream m Int -> m Bool

296295foldrMElem e =

297296 S.foldrM

298297 (\x xs ->

@@ -302,120 +301,120 @@ foldrMElem e =

302301 (return False)

303302

304303{-# INLINE foldrToStream #-}

305−foldrToStream :: Monad m => SerialT m Int -> m (SerialT Identity Int)

304+foldrToStream :: Monad m => Stream m Int -> m (Stream Identity Int)

306305foldrToStream = S.foldr S.cons S.nil

307306

308307{-# INLINE foldrMBuild #-}

309−foldrMBuild :: Monad m => SerialT m Int -> m [Int]

308+foldrMBuild :: Monad m => Stream m Int -> m [Int]

310309foldrMBuild = S.foldrM (\x xs -> (x :) <$> xs) (return [])

311310

312311#ifdef USE_PRELUDE

313312{-# INLINE foldl'Reduce #-}

314−foldl'Reduce :: Monad m => SerialT m Int -> m Int

313+foldl'Reduce :: Monad m => Stream m Int -> m Int

315314foldl'Reduce = S.foldl' (+) 0

316315

317316{-# INLINE foldl1'Reduce #-}

318−foldl1'Reduce :: Monad m => SerialT m Int -> m (Maybe Int)

317+foldl1'Reduce :: Monad m => Stream m Int -> m (Maybe Int)

319318foldl1'Reduce = S.foldl1' (+)

320319

321320{-# INLINE foldlM'Reduce #-}

322−foldlM'Reduce :: Monad m => SerialT m Int -> m Int

321+foldlM'Reduce :: Monad m => Stream m Int -> m Int

323322foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) (return 0)

324323

325324{-# INLINE last #-}

326−last :: Monad m => SerialT m Int -> m (Maybe Int)

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

327326last = S.last

328327

329328{-# INLINE _head #-}

330−_head :: Monad m => SerialT m Int -> m (Maybe Int)

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

331330_head = S.head

332331

333332{-# INLINE elem #-}

334−elem :: Monad m => Int -> SerialT m Int -> m Bool

333+elem :: Monad m => Int -> Stream m Int -> m Bool

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

336335

337336{-# INLINE notElem #-}

338−notElem :: Monad m => Int -> SerialT m Int -> m Bool

337+notElem :: Monad m => Int -> Stream m Int -> m Bool

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

340339

341340{-# INLINE length #-}

342−length :: Monad m => SerialT m Int -> m Int

341+length :: Monad m => Stream m Int -> m Int

343342length = S.length

344343

345344{-# INLINE all #-}

346−all :: Monad m => Int -> SerialT m Int -> m Bool

345+all :: Monad m => Int -> Stream m Int -> m Bool

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

348347

349348{-# INLINE any #-}

350−any :: Monad m => Int -> SerialT m Int -> m Bool

349+any :: Monad m => Int -> Stream m Int -> m Bool

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

352351

353352{-# INLINE and #-}

354−and :: Monad m => Int -> SerialT m Int -> m Bool

353+and :: Monad m => Int -> Stream m Int -> m Bool

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

356355

357356{-# INLINE or #-}

358−or :: Monad m => Int -> SerialT m Int -> m Bool

357+or :: Monad m => Int -> Stream m Int -> m Bool

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

360359

361360{-# INLINE find #-}

362−find :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

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

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

364363

365364{-# INLINE findM #-}

366−findM :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

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

367366findM value = S.findM (\z -> return $ z == (value + 1))

368367

369368{-# INLINE findIndex #-}

370−findIndex :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

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

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

372371

373372{-# INLINE elemIndex #-}

374−elemIndex :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

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

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

376375

377376{-# INLINE maximum #-}

378−maximum :: Monad m => SerialT m Int -> m (Maybe Int)

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

379378maximum = S.maximum

380379

381380{-# INLINE minimum #-}

382−minimum :: Monad m => SerialT m Int -> m (Maybe Int)

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

383382minimum = S.minimum

384383

385384{-# INLINE sum #-}

386−sum :: Monad m => SerialT m Int -> m Int

385+sum :: Monad m => Stream m Int -> m Int

387386sum = S.sum

388387

389388{-# INLINE product #-}

390−product :: Monad m => SerialT m Int -> m Int

389+product :: Monad m => Stream m Int -> m Int

391390product = S.product

392391

393392{-# INLINE minimumBy #-}

394−minimumBy :: Monad m => SerialT m Int -> m (Maybe Int)

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

395394minimumBy = S.minimumBy compare

396395

397396{-# INLINE maximumBy #-}

398−maximumBy :: Monad m => SerialT m Int -> m (Maybe Int)

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

399398maximumBy = S.maximumBy compare

400399

401400{-# INLINE the #-}

402−the :: Monad m => SerialT m Int -> m (Maybe Int)

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

403402the = S.the

404403

405404{-# INLINE drainN #-}

406−drainN :: Monad m => Int -> SerialT m Int -> m ()

405+drainN :: Monad m => Int -> Stream m Int -> m ()

407406drainN = S.drainN

408407

409408{-# INLINE drainWhile #-}

410−drainWhile :: Monad m => SerialT m Int -> m ()

409+drainWhile :: Monad m => Stream m Int -> m ()

411410drainWhile = S.drainWhile (const True)

412411

413412{-# INLINE (!!) #-}

414−(!!) :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

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

415414(!!) = flip (S.!!)

416415

417416{-# INLINE lookup #-}

418−lookup :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

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

419418lookup val = S.lookup val . S.map (\x -> (x, x))

420419#endif

421420

@@ -508,11 +507,11 @@ o_1_space_elimination_folds value =

508507

509508#ifdef USE_PRELUDE

510509{-# INLINE foldl'Build #-}

511−foldl'Build :: Monad m => SerialT m Int -> m [Int]

510+foldl'Build :: Monad m => Stream m Int -> m [Int]

512511foldl'Build = S.foldl' (flip (:)) []

513512

514513{-# INLINE foldlM'Build #-}

515−foldlM'Build :: Monad m => SerialT m Int -> m [Int]

514+foldlM'Build :: Monad m => Stream m Int -> m [Int]

516515foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) (return [])

517516

518517o_n_heap_elimination_foldl :: Int -> [Benchmark]

@@ -546,7 +545,7 @@ o_n_heap_elimination_buffered value =

546545 ]

547546

548547{-# INLINE foldrMReduce #-}

549−foldrMReduce :: Monad m => SerialT m Int -> m Int

548+foldrMReduce :: Monad m => Stream m Int -> m Int

550549foldrMReduce = S.foldrM (\x xs -> (x +) <$> xs) (return 0)

551550

552551o_n_space_elimination_foldr :: Int -> [Benchmark]

@@ -569,7 +568,7 @@ o_n_heap_elimination_toList value =

569568 -- Converting the stream to a list or pure stream in a strict monad

570569 [ benchIOSink value "toListRev" S.toListRev

571570 , benchIOSink value "toStreamRev"

572− (S.toStreamRev :: (SerialT IO Int -> IO (SerialT Identity Int)))

571+ (S.toStreamRev :: (Stream IO Int -> IO (Stream Identity Int)))

573572 ]

574573 ]

575574

@@ -579,7 +578,7 @@ o_n_space_elimination_toList value =

579578 -- Converting the stream to a list or pure stream in a strict monad

580579 [ benchIOSink value "toList" S.toList

581580 , benchIOSink value "toStream"

582− (S.toStream :: (SerialT IO Int -> IO (SerialT Identity Int)))

581+ (S.toStream :: (Stream IO Int -> IO (Stream Identity Int)))

583582 ]

584583 ]

585584#endif

@@ -593,7 +592,7 @@ o_n_space_elimination_toList value =

593592-------------------------------------------------------------------------------

594593

595594{-# INLINE eqBy' #-}

596−eqBy' :: (Monad m, Eq a) => SerialT m a -> m Bool

595+eqBy' :: (Monad m, Eq a) => Stream m a -> m Bool

597596eqBy' src = S.eqBy (==) src src

598597

599598{-# INLINE eqByPure #-}

@@ -607,15 +606,15 @@ inspect $ 'eqByPure `hasNoType` ''D.Step

607606#endif

608607

609608{-# INLINE eqInstance #-}

610−eqInstance :: SerialT Identity Int -> Bool

609+eqInstance :: Stream Identity Int -> Bool

611610eqInstance src = src == src

612611

613612{-# INLINE eqInstanceNotEq #-}

614−eqInstanceNotEq :: SerialT Identity Int -> Bool

613+eqInstanceNotEq :: Stream Identity Int -> Bool

615614eqInstanceNotEq src = src /= src

616615

617616{-# INLINE cmpBy' #-}

618−cmpBy' :: (Monad m, Ord a) => SerialT m a -> m Ordering

617+cmpBy' :: (Monad m, Ord a) => Stream m a -> m Ordering

619618cmpBy' src = S.cmpBy compare src src

620619

621620{-# INLINE cmpByPure #-}

@@ -629,7 +628,7 @@ inspect $ 'cmpByPure `hasNoType` ''D.Step

629628#endif

630629

631630{-# INLINE ordInstance #-}

632−ordInstance :: SerialT Identity Int -> Bool

631+ordInstance :: Stream Identity Int -> Bool

633632ordInstance src = src < src

634633

635634o_1_space_elimination_multi_stream_pure :: Int -> [Benchmark]

@@ -644,15 +643,15 @@ o_1_space_elimination_multi_stream_pure value =

644643 ]

645644

646645{-# INLINE isPrefixOf #-}

647−isPrefixOf :: Monad m => SerialT m Int -> m Bool

646+isPrefixOf :: Monad m => Stream m Int -> m Bool

648647isPrefixOf src = S.isPrefixOf src src

649648

650649{-# INLINE isSubsequenceOf #-}

651−isSubsequenceOf :: Monad m => SerialT m Int -> m Bool

650+isSubsequenceOf :: Monad m => Stream m Int -> m Bool

652651isSubsequenceOf src = S.isSubsequenceOf src src

653652

654653{-# INLINE stripPrefix #-}

655−stripPrefix :: Monad m => SerialT m Int -> m ()

654+stripPrefix :: Monad m => Stream m Int -> m ()

656655stripPrefix src = do

657656 _ <- S.stripPrefix src src

658657 return ()

benchmark/Streamly/Benchmark/Data/Stream/Exceptions.hs+2−2

@@ -23,7 +23,7 @@ module Stream.Exceptions (benchmarks) where

2323

2424import Control.Exception (SomeException, Exception, throwIO)

2525import Stream.Common (drain)

26−import Streamly.Internal.Data.Stream.Serial (SerialT)

26+import Streamly.Internal.Data.Stream (Stream)

2727import System.IO (Handle, hClose, hPutChar)

2828

2929import qualified Data.IORef as Ref

@@ -54,7 +54,7 @@ import qualified Streamly.Internal.Data.Stream.StreamD as D

5454-------------------------------------------------------------------------------

5555

5656{-# INLINE replicateM #-}

57−replicateM :: Common.MonadAsync m => Int -> m a -> SerialT m a

57+replicateM :: Common.MonadAsync m => Int -> m a -> Stream m a

5858#ifdef USE_PRELUDE

5959replicateM = Stream.replicateM

6060#else

benchmark/Streamly/Benchmark/Data/Stream/Expand.hs+8−8

@@ -21,7 +21,7 @@

2121module Stream.Expand (benchmarks) where

2222

2323import Control.Monad.Trans.Class (lift)

24−import Streamly.Internal.Data.Stream.Serial (SerialT)

24+import Streamly.Internal.Data.Stream (Stream)

2525

2626import qualified Control.Applicative as AP

2727

@@ -66,10 +66,10 @@ iterateN g initial count = f count initial

6666-- Iterate a transformation over a singleton stream

6767{-# INLINE iterateSingleton #-}

6868iterateSingleton :: Monad m

69− => (Int -> SerialT m Int -> SerialT m Int)

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

7070 -> Int

7171 -> Int

72− -> SerialT m Int

72+ -> Stream m Int

7373iterateSingleton g count n = iterateN g (return n) count

7474

7575{-

@@ -81,10 +81,10 @@ iterateSingleton g count n = iterateN g (return n) count

8181{-# INLINE _iterateSingleton #-}

8282_iterateSingleton ::

8383 Monad m

84− => (Int -> SerialT m Int -> SerialT m Int)

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

8585 -> Int

8686 -> Int

87− -> SerialT m Int

87+ -> Stream m Int

8888_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

8989-}

9090

@@ -402,7 +402,7 @@ o_1_space_monad value =

402402-- This is a good benchmark but inefficient way to compute primes. As we see a

403403-- new prime we keep appending a division filter for all the future numbers.

404404{-# INLINE sieve #-}

405−sieve :: Monad m => SerialT m Int -> SerialT m Int

405+sieve :: Monad m => Stream m Int -> Stream m Int

406406sieve s = do

407407 r <- lift $ S.uncons s

408408 case r of

@@ -435,7 +435,7 @@ toKv p = (p, p)

435435

436436{-# INLINE joinWith #-}

437437joinWith :: Common.MonadAsync m =>

438− ((Int -> Int -> Bool) -> SerialT m Int -> SerialT m Int -> SerialT m b)

438+ ((Int -> Int -> Bool) -> Stream m Int -> Stream m Int -> Stream m b)

439439 -> Int

440440 -> Int

441441 -> m ()

@@ -444,7 +444,7 @@ joinWith j val i =

444444

445445{-# INLINE joinMapWith #-}

446446joinMapWith :: Common.MonadAsync m =>

447− (SerialT m (Int, Int) -> SerialT m (Int, Int) -> SerialT m b)

447+ (Stream m (Int, Int) -> Stream m (Int, Int) -> Stream m b)

448448 -> Int

449449 -> Int

450450 -> m ()

benchmark/Streamly/Benchmark/Data/Stream/Generate.hs+22−22

@@ -26,7 +26,7 @@ import qualified Prelude

2626

2727import Gauge

2828import Streamly.Benchmark.Common

29−import Streamly.Internal.Data.Stream.Serial (SerialT)

29+import Streamly.Internal.Data.Stream (Stream)

3030#ifdef USE_PRELUDE

3131import Streamly.Prelude (MonadAsync)

3232import Stream.Common hiding (MonadAsync)

@@ -47,23 +47,23 @@ import Prelude hiding (repeat, replicate, iterate)

4747-------------------------------------------------------------------------------

4848

4949{-# INLINE sourceFromList #-}

50−sourceFromList :: Monad m => Int -> Int -> SerialT m Int

50+sourceFromList :: Monad m => Int -> Int -> Stream m Int

5151sourceFromList value n = Stream.fromList [n..n+value]

5252

5353{-# INLINE sourceFromListM #-}

54−sourceFromListM :: MonadAsync m => Int -> Int -> SerialT m Int

54+sourceFromListM :: MonadAsync m => Int -> Int -> Stream m Int

5555sourceFromListM value n = fromListM (fmap return [n..n+value])

5656

5757{-# INLINE sourceIsList #-}

58−sourceIsList :: Int -> Int -> SerialT Identity Int

58+sourceIsList :: Int -> Int -> Stream Identity Int

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

6060

6161{-# INLINE sourceIsString #-}

62−sourceIsString :: Int -> Int -> SerialT Identity Char

62+sourceIsString :: Int -> Int -> Stream Identity Char

6363sourceIsString value n = GHC.fromString (Prelude.replicate (n + value) 'a')

6464

6565{-# INLINE readInstance #-}

66−readInstance :: String -> SerialT Identity Int

66+readInstance :: String -> Stream Identity Int

6767readInstance str =

6868 let r = reads str

6969 in case r of

@@ -80,11 +80,11 @@ readInstanceList str =

8080 _ -> error "readInstance: no parse"

8181

8282{-# INLINE repeat #-}

83−repeat :: Monad m => Int -> Int -> SerialT m Int

83+repeat :: Monad m => Int -> Int -> Stream m Int

8484repeat count = Stream.take count . Stream.repeat

8585

8686{-# INLINE replicate #-}

87−replicate :: Monad m => Int -> Int -> SerialT m Int

87+replicate :: Monad m => Int -> Int -> Stream m Int

8888replicate = Stream.replicate

8989

9090-------------------------------------------------------------------------------

@@ -92,60 +92,60 @@ replicate = Stream.replicate

9292-------------------------------------------------------------------------------

9393

9494{-# INLINE sourceIntFromTo #-}

95−sourceIntFromTo :: Monad m => Int -> Int -> SerialT m Int

95+sourceIntFromTo :: Monad m => Int -> Int -> Stream m Int

9696sourceIntFromTo value n = Stream.enumerateFromTo n (n + value)

9797

9898{-# INLINE sourceIntFromThenTo #-}

99−sourceIntFromThenTo :: Monad m => Int -> Int -> SerialT m Int

99+sourceIntFromThenTo :: Monad m => Int -> Int -> Stream m Int

100100sourceIntFromThenTo value n = Stream.enumerateFromThenTo n (n + 1) (n + value)

101101

102102{-# INLINE sourceFracFromTo #-}

103−sourceFracFromTo :: Monad m => Int -> Int -> SerialT m Double

103+sourceFracFromTo :: Monad m => Int -> Int -> Stream m Double

104104sourceFracFromTo value n =

105105 Stream.enumerateFromTo (fromIntegral n) (fromIntegral (n + value))

106106

107107{-# INLINE sourceFracFromThenTo #-}

108−sourceFracFromThenTo :: Monad m => Int -> Int -> SerialT m Double

108+sourceFracFromThenTo :: Monad m => Int -> Int -> Stream m Double

109109sourceFracFromThenTo value n = Stream.enumerateFromThenTo (fromIntegral n)

110110 (fromIntegral n + 1.0001) (fromIntegral (n + value))

111111

112112{-# INLINE sourceIntegerFromStep #-}

113−sourceIntegerFromStep :: Monad m => Int -> Int -> SerialT m Integer

113+sourceIntegerFromStep :: Monad m => Int -> Int -> Stream m Integer

114114sourceIntegerFromStep value n =

115115 Stream.take value $ Stream.enumerateFromThen (fromIntegral n) (fromIntegral n + 1)

116116

117117{-# INLINE enumerateFrom #-}

118−enumerateFrom :: Monad m => Int -> Int -> SerialT m Int

118+enumerateFrom :: Monad m => Int -> Int -> Stream m Int

119119enumerateFrom count = Stream.take count . Stream.enumerateFrom

120120

121121{-# INLINE enumerateFromTo #-}

122−enumerateFromTo :: Monad m => Int -> Int -> SerialT m Int

122+enumerateFromTo :: Monad m => Int -> Int -> Stream m Int

123123enumerateFromTo = sourceIntFromTo

124124

125125{-# INLINE enumerateFromThen #-}

126−enumerateFromThen :: Monad m => Int -> Int -> SerialT m Int

126+enumerateFromThen :: Monad m => Int -> Int -> Stream m Int

127127enumerateFromThen count inp = Stream.take count $ Stream.enumerateFromThen inp (inp + 1)

128128

129129{-# INLINE enumerateFromThenTo #-}

130−enumerateFromThenTo :: Monad m => Int -> Int -> SerialT m Int

130+enumerateFromThenTo :: Monad m => Int -> Int -> Stream m Int

131131enumerateFromThenTo = sourceIntFromThenTo

132132

133133-- n ~ 1

134134{-# INLINE enumerate #-}

135−enumerate :: Monad m => Int -> Int -> SerialT m Int

135+enumerate :: Monad m => Int -> Int -> Stream m Int

136136enumerate count n = Stream.take (count + n) Stream.enumerate

137137

138138-- n ~ 1

139139{-# INLINE enumerateTo #-}

140−enumerateTo :: Monad m => Int -> Int -> SerialT m Int

140+enumerateTo :: Monad m => Int -> Int -> Stream m Int

141141enumerateTo count n = Stream.enumerateTo (minBound + count + n)

142142

143143{-# INLINE iterate #-}

144−iterate :: Monad m => Int -> Int -> SerialT m Int

144+iterate :: Monad m => Int -> Int -> Stream m Int

145145iterate count = Stream.take count . Stream.iterate (+1)

146146

147147{-# INLINE iterateM #-}

148−iterateM :: MonadAsync m => Int -> Int -> SerialT m Int

148+iterateM :: MonadAsync m => Int -> Int -> Stream m Int

149149iterateM count = Stream.take count . Stream.iterateM (return . (+1)) . return

150150

151151#ifdef USE_PRELUDE

@@ -167,7 +167,7 @@ fromIndicesM value n = S.take value $ S.fromIndicesM (return <$> (+ n))

167167#endif

168168

169169{-# INLINE mfixUnfold #-}

170−mfixUnfold :: Int -> Int -> SerialT IO (Int, Int)

170+mfixUnfold :: Int -> Int -> Stream IO (Int, Int)

171171mfixUnfold count start = Stream.mfix f

172172 where

173173 f action = do

benchmark/Streamly/Benchmark/Data/Stream/Lift.hs+10−10

@@ -30,7 +30,7 @@ import qualified Stream.Common as Common

3030import qualified Control.Monad.State.Strict as State

3131

3232import Gauge

33−import Streamly.Internal.Data.Stream.Serial (SerialT)

33+import Streamly.Internal.Data.Stream (Stream)

3434import Streamly.Benchmark.Common

3535

3636import Prelude hiding (reverse, tail)

@@ -41,7 +41,7 @@ import Prelude hiding (reverse, tail)

4141

4242{-# INLINE sourceUnfoldrState #-}

4343sourceUnfoldrState :: Common.MonadAsync m =>

44− Int -> Int -> SerialT (StateT Int m) Int

44+ Int -> Int -> Stream (StateT Int m) Int

4545sourceUnfoldrState value n = Stream.unfoldrM step n

4646 where

4747 step cnt =

@@ -53,12 +53,12 @@ sourceUnfoldrState value n = Stream.unfoldrM step n

5353 return (Just (s, cnt + 1))

5454

5555{-# INLINE evalStateT #-}

56−evalStateT :: Common.MonadAsync m => Int -> Int -> SerialT m Int

56+evalStateT :: Common.MonadAsync m => Int -> Int -> Stream m Int

5757evalStateT value n =

5858 Stream.evalStateT (return 0) (sourceUnfoldrState value n)

5959

6060{-# INLINE withState #-}

61−withState :: Common.MonadAsync m => Int -> Int -> SerialT m Int

61+withState :: Common.MonadAsync m => Int -> Int -> Stream m Int

6262withState value n =

6363 Stream.evalStateT

6464 (return (0 :: Int)) (Stream.liftInner (sourceUnfoldrM value n))

@@ -66,7 +66,7 @@ withState value n =

6666{-# INLINE benchHoistSink #-}

6767benchHoistSink

6868 :: (NFData b)

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

69+ => Int -> String -> (Stream Identity Int -> IO b) -> Benchmark

7070benchHoistSink value name f =

7171 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

7272

@@ -94,7 +94,7 @@ iterateStateIO n = do

9494 else return x

9595

9696{-# INLINE iterateStateT #-}

97−iterateStateT :: Int -> SerialT (StateT Int IO) Int

97+iterateStateT :: Int -> Stream (StateT Int IO) Int

9898iterateStateT n = do

9999 x <- lift get

100100 if x > n

@@ -104,11 +104,11 @@ iterateStateT n = do

104104 else return x

105105

106106{-# INLINE iterateState #-}

107−{-# SPECIALIZE iterateState :: Int -> SerialT (StateT Int IO) Int #-}

107+{-# SPECIALIZE iterateState :: Int -> Stream (StateT Int IO) Int #-}

108108iterateState ::

109109 MonadState Int m

110110 => Int

111− -> SerialT m Int

111+ -> Stream m Int

112112iterateState n = do

113113 x <- get

114114 if x > n

@@ -122,9 +122,9 @@ o_n_heap_transformer value =

122122 [ bgroup "transformer"

123123 [ benchIO "StateT Int IO (n times) (baseline)" $ \n ->

124124 State.evalStateT (iterateStateIO n) value

125− , benchIO "SerialT (StateT Int IO) (n times)" $ \n ->

125+ , benchIO "Stream (StateT Int IO) (n times)" $ \n ->

126126 State.evalStateT (drain (iterateStateT n)) value

127− , benchIO "MonadState Int m => SerialT m Int" $ \n ->

127+ , benchIO "MonadState Int m => Stream m Int" $ \n ->

128128 State.evalStateT (drain (iterateState n)) value

129129 ]

130130 ]

benchmark/Streamly/Benchmark/Data/Stream/Reduce.hs+45−45

@@ -18,7 +18,7 @@ import Control.Monad.IO.Class (MonadIO(..))

1818import Data.Monoid (Sum(..))

1919import GHC.Generics (Generic)

2020import Streamly.Internal.Data.IsMap.HashMap ()

21−import Streamly.Internal.Data.Stream.Serial (SerialT)

21+import Streamly.Internal.Data.Stream (Stream)

2222

2323import qualified Streamly.Internal.Data.Refold.Type as Refold

2424import qualified Streamly.Internal.Data.Fold as FL

@@ -60,10 +60,10 @@ iterateN g initial count = f count initial

6060-- Iterate a transformation over a singleton stream

6161{-# INLINE iterateSingleton #-}

6262iterateSingleton :: Monad m

63− => (Int -> SerialT m Int -> SerialT m Int)

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

6464 -> Int

6565 -> Int

66− -> SerialT m Int

66+ -> Stream m Int

6767iterateSingleton g count n = iterateN g (return n) count

6868

6969{-

@@ -75,10 +75,10 @@ iterateSingleton g count n = iterateN g (return n) count

7575{-# INLINE _iterateSingleton #-}

7676_iterateSingleton ::

7777 Monad m

78− => (Int -> SerialT m Int -> SerialT m Int)

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

7979 -> Int

8080 -> Int

81− -> SerialT m Int

81+ -> Stream m Int

8282_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

8383-}

8484

@@ -86,11 +86,11 @@ _iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

8686{-# INLINE iterateSource #-}

8787iterateSource ::

8888 MonadAsync m

89− => (SerialT m Int -> SerialT m Int)

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

9090 -> Int

9191 -> Int

9292 -> Int

93− -> SerialT m Int

93+ -> Stream m Int

9494iterateSource g count len n = f count (sourceUnfoldrM len n)

9595

9696 where

@@ -126,32 +126,32 @@ o_n_space_functor value =

126126

127127#ifdef USE_PRELUDE

128128{-# INLINE groups #-}

129−groups :: MonadIO m => SerialT m Int -> m ()

129+groups :: MonadIO m => Stream m Int -> m ()

130130groups = Common.drain . S.groups FL.drain

131131

132132-- XXX Change this test when the order of comparison is later changed

133133{-# INLINE groupsByGT #-}

134−groupsByGT :: MonadIO m => SerialT m Int -> m ()

134+groupsByGT :: MonadIO m => Stream m Int -> m ()

135135groupsByGT = Common.drain . S.groupsBy (>) FL.drain

136136

137137{-# INLINE groupsByEq #-}

138−groupsByEq :: MonadIO m => SerialT m Int -> m ()

138+groupsByEq :: MonadIO m => Stream m Int -> m ()

139139groupsByEq = Common.drain . S.groupsBy (==) FL.drain

140140

141141-- XXX Change this test when the order of comparison is later changed

142142{-# INLINE groupsByRollingLT #-}

143−groupsByRollingLT :: MonadIO m => SerialT m Int -> m ()

143+groupsByRollingLT :: MonadIO m => Stream m Int -> m ()

144144groupsByRollingLT =

145145 Common.drain . S.groupsByRolling (<) FL.drain

146146

147147{-# INLINE groupsByRollingEq #-}

148−groupsByRollingEq :: MonadIO m => SerialT m Int -> m ()

148+groupsByRollingEq :: MonadIO m => Stream m Int -> m ()

149149groupsByRollingEq =

150150 Common.drain . S.groupsByRolling (==) FL.drain

151151#endif

152152

153153{-# INLINE foldMany #-}

154−foldMany :: Monad m => SerialT m Int -> m ()

154+foldMany :: Monad m => Stream m Int -> m ()

155155foldMany =

156156 Common.drain

157157 . fmap getSum

@@ -159,7 +159,7 @@ foldMany =

159159 . fmap Sum

160160

161161{-# INLINE foldManyPost #-}

162−foldManyPost :: Monad m => SerialT m Int -> m ()

162+foldManyPost :: Monad m => Stream m Int -> m ()

163163foldManyPost =

164164 Common.drain

165165 . fmap getSum

@@ -167,7 +167,7 @@ foldManyPost =

167167 . fmap Sum

168168

169169{-# INLINE refoldMany #-}

170−refoldMany :: Monad m => SerialT m Int -> m ()

170+refoldMany :: Monad m => Stream m Int -> m ()

171171refoldMany =

172172 Common.drain

173173 . fmap getSum

@@ -175,7 +175,7 @@ refoldMany =

175175 . fmap Sum

176176

177177{-# INLINE foldIterateM #-}

178−foldIterateM :: Monad m => SerialT m Int -> m ()

178+foldIterateM :: Monad m => Stream m Int -> m ()

179179foldIterateM =

180180 Common.drain

181181 . fmap getSum

@@ -184,7 +184,7 @@ foldIterateM =

184184 . fmap Sum

185185

186186{-# INLINE refoldIterateM #-}

187−refoldIterateM :: Monad m => SerialT m Int -> m ()

187+refoldIterateM :: Monad m => Stream m Int -> m ()

188188refoldIterateM =

189189 Common.drain

190190 . fmap getSum

@@ -221,11 +221,11 @@ o_1_space_grouping value =

221221-------------------------------------------------------------------------------

222222

223223{-# INLINE reverse #-}

224−reverse :: MonadIO m => Int -> SerialT m Int -> m ()

224+reverse :: MonadIO m => Int -> Stream m Int -> m ()

225225reverse n = composeN n S.reverse

226226

227227{-# INLINE reverse' #-}

228−reverse' :: MonadIO m => Int -> SerialT m Int -> m ()

228+reverse' :: MonadIO m => Int -> Stream m Int -> m ()

229229reverse' n = composeN n S.reverse'

230230

231231o_n_heap_buffering :: Int -> [Benchmark]

@@ -248,7 +248,7 @@ o_n_heap_buffering value =

248248

249249#ifdef USE_PRELUDE

250250{-# INLINE classifySessionsOf #-}

251−classifySessionsOf :: MonadAsync m => (Int -> Int) -> SerialT m Int -> m ()

251+classifySessionsOf :: MonadAsync m => (Int -> Int) -> Stream m Int -> m ()

252252classifySessionsOf getKey =

253253 Common.drain

254254 . S.classifySessionsOf

@@ -258,7 +258,7 @@ classifySessionsOf getKey =

258258

259259{-# INLINE classifySessionsOfHash #-}

260260classifySessionsOfHash :: MonadAsync m =>

261− (Int -> Int) -> SerialT m Int -> m ()

261+ (Int -> Int) -> Stream m Int -> m ()

262262classifySessionsOfHash getKey =

263263 Common.drain

264264 . S.classifySessionsByGeneric

@@ -292,49 +292,49 @@ o_n_space_grouping value =

292292-------------------------------------------------------------------------------

293293

294294{-# INLINE scanMap #-}

295−scanMap :: MonadIO m => Int -> SerialT m Int -> m ()

295+scanMap :: MonadIO m => Int -> Stream m Int -> m ()

296296scanMap n = composeN n $ fmap (subtract 1) . Common.scanl' (+) 0

297297

298298{-# INLINE dropMap #-}

299−dropMap :: MonadIO m => Int -> SerialT m Int -> m ()

299+dropMap :: MonadIO m => Int -> Stream m Int -> m ()

300300dropMap n = composeN n $ fmap (subtract 1) . S.drop 1

301301

302302{-# INLINE dropScan #-}

303−dropScan :: MonadIO m => Int -> SerialT m Int -> m ()

303+dropScan :: MonadIO m => Int -> Stream m Int -> m ()

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

305305

306306{-# INLINE takeDrop #-}

307−takeDrop :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

307+takeDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()

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

309309

310310{-# INLINE takeScan #-}

311−takeScan :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

311+takeScan :: MonadIO m => Int -> Int -> Stream m Int -> m ()

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

313313

314314{-# INLINE takeMap #-}

315−takeMap :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

315+takeMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()

316316takeMap value n = composeN n $ fmap (subtract 1) . S.take (value + 1)

317317

318318{-# INLINE filterDrop #-}

319−filterDrop :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

319+filterDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()

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

321321

322322{-# INLINE filterTake #-}

323−filterTake :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

323+filterTake :: MonadIO m => Int -> Int -> Stream m Int -> m ()

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

325325

326326{-# INLINE filterScan #-}

327−filterScan :: MonadIO m => Int -> SerialT m Int -> m ()

327+filterScan :: MonadIO m => Int -> Stream m Int -> m ()

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

329329

330330#ifdef USE_PRELUDE

331331{-# INLINE filterScanl1 #-}

332−filterScanl1 :: MonadIO m => Int -> SerialT m Int -> m ()

332+filterScanl1 :: MonadIO m => Int -> Stream m Int -> m ()

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

334334#endif

335335

336336{-# INLINE filterMap #-}

337−filterMap :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

337+filterMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()

338338filterMap value n = composeN n $ fmap (subtract 1) . S.filter (<= (value + 1))

339339

340340-------------------------------------------------------------------------------

@@ -346,17 +346,17 @@ data Pair a b =

346346 deriving (Generic, NFData)

347347

348348{-# INLINE sumProductFold #-}

349−sumProductFold :: Monad m => SerialT m Int -> m (Int, Int)

349+sumProductFold :: Monad m => Stream m Int -> m (Int, Int)

350350sumProductFold = Common.foldl' (\(s, p) x -> (s + x, p * x)) (0, 1)

351351

352352{-# INLINE sumProductScan #-}

353−sumProductScan :: Monad m => SerialT m Int -> m (Pair Int Int)

353+sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)

354354sumProductScan =

355355 Common.foldl' (\(Pair _ p) (s0, x) -> Pair s0 (p * x)) (Pair 0 1) .

356356 Common.scanl' (\(s, _) x -> (s + x, x)) (0, 0)

357357

358358{-# INLINE foldl'ReduceMap #-}

359−foldl'ReduceMap :: Monad m => SerialT m Int -> m Int

359+foldl'ReduceMap :: Monad m => Stream m Int -> m Int

360360foldl'ReduceMap = fmap (+ 1) . Common.foldl' (+) 0

361361

362362o_1_space_transformations_mixed :: Int -> [Benchmark]

@@ -397,49 +397,49 @@ o_1_space_transformations_mixedX4 value =

397397

398398-- this is quadratic

399399{-# INLINE iterateScan #-}

400−iterateScan :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

400+iterateScan :: MonadAsync m => Int -> Int -> Int -> Stream m Int

401401iterateScan = iterateSource (Common.scanl' (+) 0)

402402

403403#ifdef USE_PRELUDE

404404-- this is quadratic

405405{-# INLINE iterateScanl1 #-}

406−iterateScanl1 :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

406+iterateScanl1 :: MonadAsync m => Int -> Int -> Int -> Stream m Int

407407iterateScanl1 = iterateSource (S.scanl1' (+))

408408#endif

409409

410410{-# INLINE iterateMapM #-}

411−iterateMapM :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

411+iterateMapM :: MonadAsync m => Int -> Int -> Int -> Stream m Int

412412iterateMapM = iterateSource (S.mapM return)

413413

414414{-# INLINE iterateFilterEven #-}

415−iterateFilterEven :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

415+iterateFilterEven :: MonadAsync m => Int -> Int -> Int -> Stream m Int

416416iterateFilterEven = iterateSource (S.filter even)

417417

418418{-# INLINE iterateTakeAll #-}

419−iterateTakeAll :: MonadAsync m => Int -> Int -> Int -> Int -> SerialT m Int

419+iterateTakeAll :: MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

420420iterateTakeAll value = iterateSource (S.take (value + 1))

421421

422422{-# INLINE iterateDropOne #-}

423−iterateDropOne :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

423+iterateDropOne :: MonadAsync m => Int -> Int -> Int -> Stream m Int

424424iterateDropOne = iterateSource (S.drop 1)

425425

426426{-# INLINE iterateDropWhileFalse #-}

427427iterateDropWhileFalse :: MonadAsync m

428− => Int -> Int -> Int -> Int -> SerialT m Int

428+ => Int -> Int -> Int -> Int -> Stream m Int

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

430430

431431{-# INLINE iterateDropWhileTrue #-}

432432iterateDropWhileTrue :: MonadAsync m

433− => Int -> Int -> Int -> Int -> SerialT m Int

433+ => Int -> Int -> Int -> Int -> Stream m Int

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

435435

436436#ifdef USE_PRELUDE

437437{-# INLINE tail #-}

438−tail :: Monad m => SerialT m a -> m ()

438+tail :: Monad m => Stream m a -> m ()

439439tail s = S.tail s >>= mapM_ tail

440440

441441{-# INLINE nullHeadTail #-}

442−nullHeadTail :: Monad m => SerialT m Int -> m ()

442+nullHeadTail :: Monad m => Stream m Int -> m ()

443443nullHeadTail s = do

444444 r <- S.null s

445445 when (not r) $ do

benchmark/Streamly/Benchmark/Data/Stream/Transform.hs+55−55

@@ -41,7 +41,7 @@ import qualified Streamly.Internal.Data.Stream as Stream

4141#endif

4242

4343import Gauge

44−import Streamly.Internal.Data.Stream.Serial (SerialT)

44+import Streamly.Internal.Data.Stream (Stream)

4545import Stream.Common hiding (scanl')

4646import Streamly.Benchmark.Common

4747import Prelude hiding (sequence, mapM)

@@ -59,25 +59,25 @@ import Prelude hiding (sequence, mapM)

5959-------------------------------------------------------------------------------

6060

6161{-# INLINE traversableTraverse #-}

62−traversableTraverse :: SerialT Identity Int -> IO (SerialT Identity Int)

62+traversableTraverse :: Stream Identity Int -> IO (Stream Identity Int)

6363traversableTraverse = traverse return

6464

6565{-# INLINE traversableSequenceA #-}

66−traversableSequenceA :: SerialT Identity Int -> IO (SerialT Identity Int)

66+traversableSequenceA :: Stream Identity Int -> IO (Stream Identity Int)

6767traversableSequenceA = sequenceA . Prelude.fmap return

6868

6969{-# INLINE traversableMapM #-}

70−traversableMapM :: SerialT Identity Int -> IO (SerialT Identity Int)

70+traversableMapM :: Stream Identity Int -> IO (Stream Identity Int)

7171traversableMapM = Prelude.mapM return

7272

7373{-# INLINE traversableSequence #-}

74−traversableSequence :: SerialT Identity Int -> IO (SerialT Identity Int)

74+traversableSequence :: Stream Identity Int -> IO (Stream Identity Int)

7575traversableSequence = Prelude.sequence . Prelude.fmap return

7676

7777{-# INLINE benchPureSinkIO #-}

7878benchPureSinkIO

7979 :: NFData b

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

80+ => Int -> String -> (Stream Identity Int -> IO b) -> Benchmark

8181benchPureSinkIO value name f =

8282 bench name $ nfIO $ randomRIO (1, 1) >>= f . sourceUnfoldr value

8383

@@ -99,51 +99,51 @@ o_n_space_traversable value =

9999

100100#ifdef USE_PRELUDE

101101{-# INLINE scanl' #-}

102−scanl' :: MonadIO m => Int -> SerialT m Int -> m ()

102+scanl' :: MonadIO m => Int -> Stream m Int -> m ()

103103scanl' n = composeN n $ Stream.scanl' (+) 0

104104

105105{-# INLINE scanlM' #-}

106−scanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

106+scanlM' :: MonadIO m => Int -> Stream m Int -> m ()

107107scanlM' n = composeN n $ Stream.scanlM' (\b a -> return $ b + a) (return 0)

108108

109109{-# INLINE scanl1' #-}

110−scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()

110+scanl1' :: MonadIO m => Int -> Stream m Int -> m ()

111111scanl1' n = composeN n $ Stream.scanl1' (+)

112112

113113{-# INLINE scanl1M' #-}

114−scanl1M' :: MonadIO m => Int -> SerialT m Int -> m ()

114+scanl1M' :: MonadIO m => Int -> Stream m Int -> m ()

115115scanl1M' n = composeN n $ Stream.scanl1M' (\b a -> return $ b + a)

116116#endif

117117

118118{-# INLINE scan #-}

119−scan :: MonadIO m => Int -> SerialT m Int -> m ()

119+scan :: MonadIO m => Int -> Stream m Int -> m ()

120120scan n = composeN n $ Stream.scan FL.sum

121121

122122#ifdef USE_PRELUDE

123123{-# INLINE postscanl' #-}

124−postscanl' :: MonadIO m => Int -> SerialT m Int -> m ()

124+postscanl' :: MonadIO m => Int -> Stream m Int -> m ()

125125postscanl' n = composeN n $ Stream.postscanl' (+) 0

126126

127127{-# INLINE postscanlM' #-}

128−postscanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

128+postscanlM' :: MonadIO m => Int -> Stream m Int -> m ()

129129postscanlM' n = composeN n $ Stream.postscanlM' (\b a -> return $ b + a) (return 0)

130130#endif

131131

132132{-# INLINE postscan #-}

133−postscan :: MonadIO m => Int -> SerialT m Int -> m ()

133+postscan :: MonadIO m => Int -> Stream m Int -> m ()

134134postscan n = composeN n $ Stream.postscan FL.sum

135135

136136{-# INLINE sequence #-}

137−sequence :: MonadAsync m => SerialT m (m Int) -> m ()

137+sequence :: MonadAsync m => Stream m (m Int) -> m ()

138138sequence = Common.drain . Stream.sequence

139139

140140{-# INLINE tap #-}

141−tap :: MonadIO m => Int -> SerialT m Int -> m ()

141+tap :: MonadIO m => Int -> Stream m Int -> m ()

142142tap n = composeN n $ Stream.tap FL.sum

143143

144144#ifdef USE_PRELUDE

145145{-# INLINE pollCounts #-}

146−pollCounts :: Int -> SerialT IO Int -> IO ()

146+pollCounts :: Int -> Stream IO Int -> IO ()

147147pollCounts n =

148148 composeN n (Stream.pollCounts (const True) f)

149149

@@ -152,28 +152,28 @@ pollCounts n =

152152 f = Stream.drain . Stream.rollingMap2 (-) . Stream.delayPost 1

153153

154154{-# INLINE timestamped #-}

155−timestamped :: (MonadAsync m) => SerialT m Int -> m ()

155+timestamped :: (MonadAsync m) => Stream m Int -> m ()

156156timestamped = Stream.drain . Stream.timestamped

157157#endif

158158

159159{-# INLINE foldrS #-}

160−foldrS :: MonadIO m => Int -> SerialT m Int -> m ()

160+foldrS :: MonadIO m => Int -> Stream m Int -> m ()

161161foldrS n = composeN n $ Stream.foldrS Stream.cons Stream.nil

162162

163163{-# INLINE foldrSMap #-}

164−foldrSMap :: MonadIO m => Int -> SerialT m Int -> m ()

164+foldrSMap :: MonadIO m => Int -> Stream m Int -> m ()

165165foldrSMap n = composeN n $ Stream.foldrS (\x xs -> x + 1 `Stream.cons` xs) Stream.nil

166166

167167{-# INLINE foldrT #-}

168−foldrT :: MonadIO m => Int -> SerialT m Int -> m ()

168+foldrT :: MonadIO m => Int -> Stream m Int -> m ()

169169foldrT n = composeN n $ Stream.foldrT Stream.cons Stream.nil

170170

171171{-# INLINE foldrTMap #-}

172−foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()

172+foldrTMap :: MonadIO m => Int -> Stream m Int -> m ()

173173foldrTMap n = composeN n $ Stream.foldrT (\x xs -> x + 1 `Stream.cons` xs) Stream.nil

174174

175175{-# INLINE trace #-}

176−trace :: MonadAsync m => Int -> SerialT m Int -> m ()

176+trace :: MonadAsync m => Int -> Stream m Int -> m ()

177177trace n = composeN n $ Stream.trace return

178178

179179o_1_space_mapping :: Int -> [Benchmark]

@@ -229,7 +229,7 @@ o_1_space_mappingX4 value =

229229 ]

230230

231231{-# INLINE sieveScan #-}

232−sieveScan :: Monad m => SerialT m Int -> SerialT m Int

232+sieveScan :: Monad m => Stream m Int -> Stream m Int

233233sieveScan =

234234 Stream.mapMaybe snd

235235 . Stream.scan (FL.foldlM' (\(primes, _) n -> do

@@ -264,48 +264,48 @@ o_1_space_functor value =

264264-------------------------------------------------------------------------------

265265

266266{-# INLINE filterEven #-}

267−filterEven :: MonadIO m => Int -> SerialT m Int -> m ()

267+filterEven :: MonadIO m => Int -> Stream m Int -> m ()

268268filterEven n = composeN n $ Stream.filter even

269269

270270{-# INLINE filterAllOut #-}

271−filterAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

271+filterAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()

272272filterAllOut value n = composeN n $ Stream.filter (> (value + 1))

273273

274274{-# INLINE filterAllIn #-}

275−filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

275+filterAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()

276276filterAllIn value n = composeN n $ Stream.filter (<= (value + 1))

277277

278278{-# INLINE filterMEven #-}

279−filterMEven :: MonadIO m => Int -> SerialT m Int -> m ()

279+filterMEven :: MonadIO m => Int -> Stream m Int -> m ()

280280filterMEven n = composeN n $ Stream.filterM (return . even)

281281

282282{-# INLINE filterMAllOut #-}

283−filterMAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

283+filterMAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()

284284filterMAllOut value n = composeN n $ Stream.filterM (\x -> return $ x > (value + 1))

285285

286286{-# INLINE filterMAllIn #-}

287−filterMAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

287+filterMAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()

288288filterMAllIn value n = composeN n $ Stream.filterM (\x -> return $ x <= (value + 1))

289289

290290{-# INLINE _takeOne #-}

291−_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()

291+_takeOne :: MonadIO m => Int -> Stream m Int -> m ()

292292_takeOne n = composeN n $ Stream.take 1

293293

294294{-# INLINE takeAll #-}

295−takeAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

295+takeAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()

296296takeAll value n = composeN n $ Stream.take (value + 1)

297297

298298{-# INLINE takeWhileTrue #-}

299−takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

299+takeWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

300300takeWhileTrue value n = composeN n $ Stream.takeWhile (<= (value + 1))

301301

302302{-# INLINE takeWhileMTrue #-}

303−takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

303+takeWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

304304takeWhileMTrue value n = composeN n $ Stream.takeWhileM (return . (<= (value + 1)))

305305

306306#ifdef USE_PRELUDE

307307{-# INLINE takeInterval #-}

308−takeInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

308+takeInterval :: NanoSecond64 -> Int -> Stream IO Int -> IO ()

309309takeInterval i n = composeN n (Stream.takeInterval i)

310310

311311#ifdef INSPECTION

@@ -316,33 +316,33 @@ inspect $ hasNoTypeClasses 'takeInterval

316316#endif

317317

318318{-# INLINE dropOne #-}

319−dropOne :: MonadIO m => Int -> SerialT m Int -> m ()

319+dropOne :: MonadIO m => Int -> Stream m Int -> m ()

320320dropOne n = composeN n $ Stream.drop 1

321321

322322{-# INLINE dropAll #-}

323−dropAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

323+dropAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()

324324dropAll value n = composeN n $ Stream.drop (value + 1)

325325

326326{-# INLINE dropWhileTrue #-}

327−dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

327+dropWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

328328dropWhileTrue value n = composeN n $ Stream.dropWhile (<= (value + 1))

329329

330330{-# INLINE dropWhileMTrue #-}

331−dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

331+dropWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

332332dropWhileMTrue value n = composeN n $ Stream.dropWhileM (return . (<= (value + 1)))

333333

334334{-# INLINE dropWhileFalse #-}

335−dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

335+dropWhileFalse :: MonadIO m => Int -> Int -> Stream m Int -> m ()

336336dropWhileFalse value n = composeN n $ Stream.dropWhile (> (value + 1))

337337

338338#ifdef USE_PRELUDE

339339-- XXX Decide on the time interval

340340{-# INLINE _intervalsOfSum #-}

341−_intervalsOfSum :: MonadAsync m => Double -> Int -> SerialT m Int -> m ()

341+_intervalsOfSum :: MonadAsync m => Double -> Int -> Stream m Int -> m ()

342342_intervalsOfSum i n = composeN n (Stream.intervalsOf i FL.sum)

343343

344344{-# INLINE dropInterval #-}

345−dropInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

345+dropInterval :: NanoSecond64 -> Int -> Stream IO Int -> IO ()

346346dropInterval i n = composeN n (Stream.dropInterval i)

347347

348348#ifdef INSPECTION

@@ -352,24 +352,24 @@ inspect $ hasNoTypeClasses 'dropInterval

352352#endif

353353

354354{-# INLINE findIndices #-}

355−findIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

355+findIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()

356356findIndices value n = composeN n $ Stream.findIndices (== (value + 1))

357357

358358{-# INLINE elemIndices #-}

359−elemIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

359+elemIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()

360360elemIndices value n = composeN n $ Stream.elemIndices (value + 1)

361361

362362{-# INLINE deleteBy #-}

363−deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

363+deleteBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()

364364deleteBy value n = composeN n $ Stream.deleteBy (>=) (value + 1)

365365

366366-- uniq . uniq == uniq, composeN 2 ~ composeN 1

367367{-# INLINE uniq #-}

368−uniq :: MonadIO m => Int -> SerialT m Int -> m ()

368+uniq :: MonadIO m => Int -> Stream m Int -> m ()

369369uniq n = composeN n Stream.uniq

370370

371371{-# INLINE mapMaybe #-}

372−mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()

372+mapMaybe :: MonadIO m => Int -> Stream m Int -> m ()

373373mapMaybe n =

374374 composeN n $

375375 Stream.mapMaybe

@@ -379,7 +379,7 @@ mapMaybe n =

379379 else Just x)

380380

381381{-# INLINE mapMaybeM #-}

382−mapMaybeM :: MonadAsync m => Int -> SerialT m Int -> m ()

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

383383mapMaybeM n =

384384 composeN n $

385385 Stream.mapMaybeM

@@ -477,24 +477,24 @@ o_1_space_filteringX4 value =

477477-------------------------------------------------------------------------------

478478

479479{-# INLINE intersperse #-}

480−intersperse :: MonadAsync m => Int -> Int -> SerialT m Int -> m ()

480+intersperse :: MonadAsync m => Int -> Int -> Stream m Int -> m ()

481481intersperse value n = composeN n $ Stream.intersperse (value + 1)

482482

483483{-# INLINE intersperseM #-}

484−intersperseM :: MonadAsync m => Int -> Int -> SerialT m Int -> m ()

484+intersperseM :: MonadAsync m => Int -> Int -> Stream m Int -> m ()

485485intersperseM value n = composeN n $ Stream.intersperseM (return $ value + 1)

486486

487487{-# INLINE insertBy #-}

488−insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

488+insertBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()

489489insertBy value n = composeN n $ Stream.insertBy compare (value + 1)

490490

491491{-# INLINE interposeSuffix #-}

492−interposeSuffix :: Monad m => Int -> Int -> SerialT m Int -> m ()

492+interposeSuffix :: Monad m => Int -> Int -> Stream m Int -> m ()

493493interposeSuffix value n =

494494 composeN n $ Stream.interposeSuffix (value + 1) Unfold.identity

495495

496496{-# INLINE intercalateSuffix #-}

497−intercalateSuffix :: Monad m => Int -> Int -> SerialT m Int -> m ()

497+intercalateSuffix :: Monad m => Int -> Int -> Stream m Int -> m ()

498498intercalateSuffix value n =

499499 composeN n $ Stream.intercalateSuffix Unfold.identity (value + 1)

500500

@@ -522,11 +522,11 @@ o_1_space_insertingX4 value =

522522-------------------------------------------------------------------------------

523523

524524{-# INLINE indexed #-}

525−indexed :: MonadIO m => Int -> SerialT m Int -> m ()

525+indexed :: MonadIO m => Int -> Stream m Int -> m ()

526526indexed n = composeN n (fmap snd . Stream.indexed)

527527

528528{-# INLINE indexedR #-}

529−indexedR :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

529+indexedR :: MonadIO m => Int -> Int -> Stream m Int -> m ()

530530indexedR value n = composeN n (fmap snd . Stream.indexedR value)

531531

532532o_1_space_indexing :: Int -> [Benchmark]

benchmark/Streamly/Benchmark/Data/Unfold.hs+9−9

@@ -31,10 +31,10 @@ import qualified Prelude

3131import qualified Streamly.FileSystem.Handle as FH

3232import qualified Streamly.Internal.Data.Fold as FL

3333import qualified Streamly.Internal.Data.Unfold as UF

34−import qualified Streamly.Internal.Data.Stream.IsStream as S

34+import qualified Streamly.Internal.Data.Stream as S

3535import qualified Streamly.Internal.Data.Stream.StreamD as D

3636import qualified Streamly.Internal.Data.Stream.StreamK as K

37−import qualified Streamly.Prelude as SP

37+

3838

3939import Gauge hiding (env)

4040import Prelude hiding (take, filter, zipWith, map, mapM, takeWhile)

@@ -161,7 +161,7 @@ swap size start =

161161{-# INLINE fromStream #-}

162162fromStream :: Int -> Int -> IO ()

163163fromStream size start =

164− drainGeneration UF.fromStream (S.replicate size start :: S.SerialT IO Int)

164+ drainGeneration UF.fromStream (S.replicate size start :: S.Stream IO Int)

165165

166166-- XXX INVESTIGATE: Although the performance of this should be equivalant to

167167-- fromStream, this is considerably worse. More than 4x worse.

@@ -749,7 +749,7 @@ o_n_space_nested size =

749749readWriteOnExceptionUnfold :: Handle -> Handle -> IO ()

750750readWriteOnExceptionUnfold inh devNull =

751751 let readEx = UF.onException (\_ -> hClose inh) FH.read

752− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

752+ in S.fold (FH.write devNull) $ S.unfold readEx inh

753753

754754#ifdef INSPECTION

755755inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold

@@ -761,7 +761,7 @@ readWriteHandleExceptionUnfold :: Handle -> Handle -> IO ()

761761readWriteHandleExceptionUnfold inh devNull =

762762 let handler (_e :: SomeException) = hClose inh >> return 10

763763 readEx = UF.handle (UF.functionM handler) FH.read

764− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

764+ in S.fold (FH.write devNull) $ S.unfold readEx inh

765765

766766#ifdef INSPECTION

767767inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

@@ -772,7 +772,7 @@ inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

772772readWriteFinally_Unfold :: Handle -> Handle -> IO ()

773773readWriteFinally_Unfold inh devNull =

774774 let readEx = UF.finally_ (\_ -> hClose inh) FH.read

775− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

775+ in S.fold (FH.write devNull) $ S.unfold readEx inh

776776

777777#ifdef INSPECTION

778778inspect $ hasNoTypeClasses 'readWriteFinally_Unfold

@@ -782,13 +782,13 @@ inspect $ hasNoTypeClasses 'readWriteFinally_Unfold

782782readWriteFinallyUnfold :: Handle -> Handle -> IO ()

783783readWriteFinallyUnfold inh devNull =

784784 let readEx = UF.finally (\_ -> hClose inh) FH.read

785− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

785+ in S.fold (FH.write devNull) $ S.unfold readEx inh

786786

787787-- | Send the file contents to /dev/null with exception handling

788788readWriteBracket_Unfold :: Handle -> Handle -> IO ()

789789readWriteBracket_Unfold inh devNull =

790790 let readEx = UF.bracket_ return (\_ -> hClose inh) FH.read

791− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

791+ in S.fold (FH.write devNull) $ S.unfold readEx inh

792792

793793#ifdef INSPECTION

794794inspect $ hasNoTypeClasses 'readWriteBracket_Unfold

@@ -798,7 +798,7 @@ inspect $ hasNoTypeClasses 'readWriteBracket_Unfold

798798readWriteBracketUnfold :: Handle -> Handle -> IO ()

799799readWriteBracketUnfold inh devNull =

800800 let readEx = UF.bracket return (\_ -> hClose inh) FH.read

801− in SP.fold (FH.write devNull) $ S.unfold readEx inh

801+ in S.fold (FH.write devNull) $ S.unfold readEx inh

802802

803803o_1_space_copy_read_exceptions :: BenchEnv -> [Benchmark]

804804o_1_space_copy_read_exceptions env =

core/src/Streamly/Data/Array/Unboxed.hs+4−4

@@ -29,8 +29,8 @@

2929-- it to IO monad as follows:

3030--

3131-- >>> import Data.Functor.Identity (Identity, runIdentity)

32−-- >>> s = Stream.fromList [1..10] :: SerialT Identity Int

33−-- >>> s1 = Stream.hoist (return . runIdentity) s :: SerialT IO Int

32+-- >>> s = Stream.fromList [1..10] :: Stream Identity Int

33+-- >>> s1 = Stream.hoist (return . runIdentity) s :: Stream IO Int

3434-- >>> Stream.fold Array.write s1 :: IO (Array Int)

3535-- [1,2,3,4,5,6,7,8,9,10]

3636--

@@ -98,7 +98,7 @@ import Streamly.Internal.Data.Array.Unboxed as A

9898-- >>> :m

9999-- >>> :set -XFlexibleContexts

100100-- >>> :set -package streamly

101−-- >>> import Streamly.Prelude (SerialT)

101+-- >>> import Streamly.Internal.Data.Stream (Stream)

102102-- >>> import Streamly.Data.Array.Unboxed (Array)

103−-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream

103+-- >>> import qualified Streamly.Internal.Data.Stream as Stream

104104-- >>> import qualified Streamly.Data.Array.Unboxed as Array

core/src/Streamly/Internal/Data/Pipe.hs+1−1

@@ -248,7 +248,7 @@ import Streamly.Internal.Data.Pipe.Type

248248 (Pipe(..), PipeState(..), Step(..), zipWith, tee, map, compose)

249249-- import Streamly.Internal.Data.Array.Unboxed.Type (Array)

250250-- import Streamly.Internal.Data.Ring.Foreign (Ring)

251−-- import Streamly.Internal.Data.Stream.Serial (SerialT)

251+-- import Streamly.Internal.Data.Stream (Stream)

252252-- import Streamly.Internal.Data.Stream.StreamK (IsStream())

253253-- import Streamly.Internal.Data.Time.Units

254254-- (AbsTime, MilliSecond64(..), addToAbsTime, diffAbsTime, toRelTime,

core/src/Streamly/Internal/Data/Stream/Serial.hs+5−48

@@ -21,8 +21,8 @@ module Streamly.Internal.Data.Stream.Serial

2121 -- * Construction

2222 , Stream.cons

2323 , Stream.consM

24− , repeat

25− , unfoldrM

24+ , Stream.repeat

25+ , Stream.unfoldrM

2626 , fromList

2727

2828 -- * Elimination

@@ -38,13 +38,10 @@ where

3838import Data.Semigroup (Semigroup(..))

3939#endif

4040import GHC.Exts (IsList(..))

41−

42−import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D

41+import Streamly.Internal.Data.Stream (Stream)

4342import qualified Streamly.Internal.Data.Stream as Stream

4443

45−import Prelude hiding (map, mapM, repeat)

46−

47−#include "inline.hs"

44+import Prelude hiding (map)

4845

4946-- $setup

5047-- >>> import qualified Streamly.Prelude as Stream

@@ -53,7 +50,7 @@ import Prelude hiding (map, mapM, repeat)

5350-- SerialT

5451------------------------------------------------------------------------------

5552

56−type SerialT = Stream.Stream

53+type SerialT = Stream

5754

5855-- | A serial IO stream of elements of type @a@. See 'SerialT' documentation

5956-- for more details.

@@ -63,17 +60,6 @@ type SerialT = Stream.Stream

6360-- @since 0.8.0

6461type Serial = SerialT IO

6562

66−------------------------------------------------------------------------------

67−-- Generation

68−------------------------------------------------------------------------------

69−

70−-- |

71−-- Generate an infinite stream by repeating a pure value.

72−--

73−{-# INLINE_NORMAL repeat #-}

74−repeat :: Monad m => a -> SerialT m a

75−repeat = Stream.fromStreamD . D.repeat

76−

7763------------------------------------------------------------------------------

7864-- Combining

7965------------------------------------------------------------------------------

@@ -98,32 +84,3 @@ serial = (<>)

9884{-# INLINE map #-}

9985map :: Monad m => (a -> b) -> SerialT m a -> SerialT m b

10086map f = Stream.mapM (return . f)

101−

102−------------------------------------------------------------------------------

103−-- Construction

104−------------------------------------------------------------------------------

105−

106−-- | Build a stream by unfolding a /monadic/ step function starting from a

107−-- seed. The step function returns the next element in the stream and the next

108−-- seed value. When it is done it returns 'Nothing' and the stream ends. For

109−-- example,

110−--

111−-- @

112−-- let f b =

113−-- if b > 3

114−-- then return Nothing

115−-- else print b >> return (Just (b, b + 1))

116−-- in drain $ unfoldrM f 0

117−-- @

118−-- @

119−-- 0

120−-- 1

121−-- 2

122−-- 3

123−-- @

124−--

125−-- /Pre-release/

126−--

127−{-# INLINE unfoldrM #-}

128−unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> SerialT m a

129−unfoldrM step seed = Stream.fromStreamD (D.unfoldrM step seed)

core/src/Streamly/Internal/Data/Stream/StreamD/Type.hs+1−1

@@ -353,7 +353,7 @@ foldContinue (Fold fstep finitial fextract) (Stream sstep state) =

353353-- lazy the following example, must work:

354354--

355355-- S.foldrM (\x t -> if x then return t else return False) (return True)

356−-- (S.fromList [False,undefined] :: SerialT IO Bool)

356+-- (S.fromList [False,undefined] :: Stream IO Bool)

357357--

358358{-# INLINE_NORMAL foldrM #-}

359359foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b

core/src/Streamly/Internal/Data/Stream/WSerial.hs+1−1

@@ -106,7 +106,7 @@ import Prelude hiding (map, mapM, repeat, filter)

106106-- [(1,3),(2,3),(1,4),(2,4)]

107107--

108108-- The @W@ in the name stands for @wide@ or breadth wise scheduling in

109−-- contrast to the depth wise scheduling behavior of 'SerialT'.

109+-- contrast to the depth wise scheduling behavior of 'Stream'.

110110--

111111-- /Since: 0.2.0 ("Streamly")/

112112--

src/Streamly/Data/Array/Foreign.hs+3−3

@@ -29,8 +29,8 @@

2929-- it to IO monad as follows:

3030--

3131-- >>> import Data.Functor.Identity (Identity, runIdentity)

32−-- >>> s = Stream.fromList [1..10] :: SerialT Identity Int

33−-- >>> s1 = Stream.hoist (return . runIdentity) s :: SerialT IO Int

32+-- >>> s = Stream.fromList [1..10] :: Stream Identity Int

33+-- >>> s1 = Stream.hoist (return . runIdentity) s :: Stream IO Int

3434-- >>> Stream.fold Array.write s1 :: IO (Array Int)

3535-- [1,2,3,4,5,6,7,8,9,10]

3636--

@@ -99,7 +99,7 @@ import Streamly.Internal.Data.Array.Unboxed as A

9999-- >>> :m

100100-- >>> :set -XFlexibleContexts

101101-- >>> :set -package streamly

102−-- >>> import Streamly.Prelude (SerialT)

102+-- >>> import Streamly.Internal.Data.Stream (Stream)

103103-- >>> import Streamly.Data.Array.Unboxed (Array)

104104-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream

105105-- >>> import qualified Streamly.Data.Array.Unboxed as Array

src/Streamly/Data/Unicode/Stream.hs+1−1

@@ -38,7 +38,7 @@

3838--

3939-- = String Literals

4040--

41−-- @SerialT Identity Char@ and @Array Char@ are instances of 'IsString' and

41+-- @Stream Identity Char@ and @Array Char@ are instances of 'IsString' and

4242-- 'IsList', therefore, 'OverloadedStrings' and 'OverloadedLists' extensions

4343-- can be used for convenience when specifying unicode strings literals using

4444-- these types.

src/Streamly/Internal/Console/Stdio.hs+11−11

@@ -43,7 +43,7 @@ import System.IO (stdin, stdout, stderr)

4343import Prelude hiding (read)

4444

4545import Streamly.Internal.Data.Array.Unboxed.Type (Array(..))

46−import Streamly.Internal.Data.Stream.Serial (SerialT)

46+import Streamly.Internal.Data.Stream (Stream)

4747import Streamly.Internal.Data.Unfold (Unfold)

4848import Streamly.Internal.Data.Fold (Fold)

4949

@@ -72,7 +72,7 @@ read = Unfold.lmap (\() -> stdin) Handle.read

7272-- /Pre-release/

7373--

7474{-# INLINE getBytes #-}

75−getBytes :: MonadIO m => SerialT m Word8

75+getBytes :: MonadIO m => Stream m Word8

7676getBytes = Handle.getBytes stdin

7777

7878-- | Read a character stream from Utf8 encoded standard input.

@@ -82,7 +82,7 @@ getBytes = Handle.getBytes stdin

8282-- /Pre-release/

8383--

8484{-# INLINE getChars #-}

85−getChars :: MonadIO m => SerialT m Char

85+getChars :: MonadIO m => Stream m Char

8686getChars = Unicode.decodeUtf8 getBytes

8787

8888-- | Unfolds standard input into a stream of 'Word8' arrays.

@@ -102,7 +102,7 @@ readChunks = Unfold.lmap (\() -> stdin) Handle.readChunks

102102-- /Pre-release/

103103--

104104{-# INLINE getChunks #-}

105−getChunks :: MonadIO m => SerialT m (Array Word8)

105+getChunks :: MonadIO m => Stream m (Array Word8)

106106getChunks = Handle.getChunks stdin

107107

108108{-

@@ -114,7 +114,7 @@ getChunks = Handle.getChunks stdin

114114-- /Pre-release/

115115--

116116{-# INLINE getChunksLn #-}

117−getChunksLn :: MonadIO m => SerialT m (Array Word8)

117+getChunksLn :: MonadIO m => Stream m (Array Word8)

118118getChunksLn = (Stream.splitWithSuffix (== '\n') f) getChars

119119

120120 -- XXX Need to implement Fold.unfoldMany, should be easy for

@@ -149,7 +149,7 @@ writeErr = Handle.write stderr

149149-- /Pre-release/

150150--

151151{-# INLINE putBytes #-}

152−putBytes :: MonadIO m => SerialT m Word8 -> m ()

152+putBytes :: MonadIO m => Stream m Word8 -> m ()

153153putBytes = Handle.putBytes stdout

154154

155155-- | Encode a character stream to Utf8 and write it to standard output.

@@ -159,7 +159,7 @@ putBytes = Handle.putBytes stdout

159159-- /Pre-release/

160160--

161161{-# INLINE putChars #-}

162−putChars :: MonadIO m => SerialT m Char -> m ()

162+putChars :: MonadIO m => Stream m Char -> m ()

163163putChars = putBytes . Unicode.encodeUtf8

164164

165165-- | Fold a stream of @Array Word8@ to standard output.

@@ -184,7 +184,7 @@ writeErrChunks = Handle.writeChunks stderr

184184-- /Pre-release/

185185--

186186{-# INLINE putChunks #-}

187−putChunks :: MonadIO m => SerialT m (Array Word8) -> m ()

187+putChunks :: MonadIO m => Stream m (Array Word8) -> m ()

188188putChunks = Handle.putChunks stdout

189189

190190-------------------------------------------------------------------------------

@@ -203,7 +203,7 @@ putChunks = Handle.putChunks stdout

203203--

204204{-# INLINE putStringsWith #-}

205205putStringsWith :: MonadIO m

206− => (SerialT m Char -> SerialT m Word8) -> SerialT m String -> m ()

206+ => (Stream m Char -> Stream m Word8) -> Stream m String -> m ()

207207putStringsWith encode = putChunks . Unicode.encodeStrings encode

208208

209209-- | Write a stream of strings to standard output using UTF8 encoding. Output

@@ -212,7 +212,7 @@ putStringsWith encode = putChunks . Unicode.encodeStrings encode

212212-- /Pre-release/

213213--

214214{-# INLINE putStrings #-}

215−putStrings :: MonadIO m => SerialT m String -> m ()

215+putStrings :: MonadIO m => Stream m String -> m ()

216216putStrings = putStringsWith Unicode.encodeUtf8

217217

218218-- | Like 'putStrings' but adds a newline at the end of each string.

@@ -222,7 +222,7 @@ putStrings = putStringsWith Unicode.encodeUtf8

222222-- /Pre-release/

223223--

224224{-# INLINE putStringsLn #-}

225−putStringsLn :: MonadIO m => SerialT m String -> m ()

225+putStringsLn :: MonadIO m => Stream m String -> m ()

226226putStringsLn =

227227 putChunks

228228 . Stream.intersperseSuffix (return $ Array.fromList [10])

src/Streamly/Internal/Data/Array/Stream/Foreign.hs+16−16

@@ -68,7 +68,7 @@ import Streamly.Internal.Data.Array.Unboxed.Type (Array(..))

6868import Streamly.Internal.Data.Array.Stream.Fold.Foreign (ArrayFold(..))

6969import Streamly.Internal.Data.Fold.Type (Fold(..))

7070import Streamly.Internal.Data.Parser (ParseError(..))

71−import Streamly.Internal.Data.Stream.Serial (SerialT)

71+import Streamly.Internal.Data.Stream (Stream)

7272import Streamly.Internal.Data.Stream.IsStream.Type

7373 (IsStream, fromStreamD, toStreamD)

7474import Streamly.Internal.Data.SVar (adaptState, defState)

@@ -221,7 +221,7 @@ lpackArraysChunksOf n fld =

221221-- @since 0.7.0

222222{-# INLINE compact #-}

223223compact :: (MonadIO m, Unboxed a)

224− => Int -> SerialT m (Array a) -> SerialT m (Array a)

224+ => Int -> Stream m (Array a) -> Stream m (Array a)

225225compact n xs = fromStreamD $ packArraysChunksOf n (toStreamD xs)

226226

227227-------------------------------------------------------------------------------

@@ -396,8 +396,8 @@ foldBreakK (Fold fstep initial extract) stream = do

396396foldBreak ::

397397 (MonadIO m, Unboxed a)

398398 => FL.Fold m a b

399− -> SerialT m (A.Array a)

400− -> m (b, SerialT m (A.Array a))

399+ -> Stream m (A.Array a)

400+ -> m (b, Stream m (A.Array a))

401401-- foldBreak f s = fmap fromStreamD <$> foldBreakD f (toStreamD s)

402402foldBreak f =

403403 fmap (fmap Stream.fromStreamK)

@@ -465,14 +465,14 @@ splitAtArrayListRev n ls

465465-- stream.

466466{-# INLINE spliceArraysLenUnsafe #-}

467467spliceArraysLenUnsafe :: (MonadIO m, Unboxed a)

468− => Int -> SerialT m (MA.Array a) -> m (MA.Array a)

468+ => Int -> Stream m (MA.Array a) -> m (MA.Array a)

469469spliceArraysLenUnsafe len buffered = do

470470 arr <- liftIO $ MA.newArray len

471471 S.foldlM' MA.spliceUnsafe (return arr) buffered

472472

473473{-# INLINE _spliceArrays #-}

474474_spliceArrays :: (MonadIO m, Unboxed a)

475− => SerialT m (Array a) -> m (Array a)

475+ => Stream m (Array a) -> m (Array a)

476476_spliceArrays s = do

477477 buffered <- S.foldr S.cons S.nil s

478478 len <- S.sum (S.map Array.length buffered)

@@ -486,7 +486,7 @@ _spliceArrays s = do

486486

487487{-# INLINE _spliceArraysBuffered #-}

488488_spliceArraysBuffered :: (MonadIO m, Unboxed a)

489− => SerialT m (Array a) -> m (Array a)

489+ => Stream m (Array a) -> m (Array a)

490490_spliceArraysBuffered s = do

491491 buffered <- S.foldr S.cons S.nil s

492492 len <- S.sum (S.map Array.length buffered)

@@ -494,7 +494,7 @@ _spliceArraysBuffered s = do

494494

495495{-# INLINE spliceArraysRealloced #-}

496496spliceArraysRealloced :: forall m a. (MonadIO m, Unboxed a)

497− => SerialT m (Array a) -> m (Array a)

497+ => Stream m (Array a) -> m (Array a)

498498spliceArraysRealloced s = do

499499 let n = allocBytesToElemCount (undefined :: a) (4 * 1024)

500500 idst = liftIO $ MA.newArray n

@@ -509,7 +509,7 @@ spliceArraysRealloced s = do

509509--

510510-- @since 0.7.0

511511{-# INLINE toArray #-}

512−toArray :: (MonadIO m, Unboxed a) => SerialT m (Array a) -> m (Array a)

512+toArray :: (MonadIO m, Unboxed a) => Stream m (Array a) -> m (Array a)

513513toArray = spliceArraysRealloced

514514-- spliceArrays = _spliceArraysBuffered

515515

@@ -529,7 +529,7 @@ toArraysInRange low high (Fold step initial extract) =

529529-- | Fold the input to a pure buffered stream (List) of arrays.

530530{-# INLINE _toArraysOf #-}

531531_toArraysOf :: (MonadIO m, Unboxed a)

532− => Int -> Fold m a (SerialT Identity (Array a))

532+ => Int -> Fold m a (Stream Identity (Array a))

533533_toArraysOf n = FL.chunksOf n (A.writeNF n) FL.toStream

534534-}

535535

@@ -710,8 +710,8 @@ parseBreakK (PRD.Parser pstep initial extract) stream = do

710710parseBreak ::

711711 (MonadIO m, MonadThrow m, Unboxed a)

712712 => PR.Parser m a b

713− -> SerialT m (A.Array a)

714− -> m (b, SerialT m (A.Array a))

713+ -> Stream m (A.Array a)

714+ -> m (b, Stream m (A.Array a))

715715{-

716716parseBreak p s =

717717 fmap fromStreamD <$> parseBreakD (PRD.fromParserK p) (toStreamD s)

@@ -808,8 +808,8 @@ runArrayParserDBreak

808808parseArr ::

809809 (MonadIO m, MonadThrow m, Unboxed a)

810810 => ASF.Parser m a b

811− -> SerialT m (A.Array a)

812− -> m (b, SerialT m (A.Array a))

811+ -> Stream m (A.Array a)

812+ -> m (b, Stream m (A.Array a))

813813parseArr p s = fmap fromStreamD <$> parseBreakD p (toStreamD s)

814814-}

815815

@@ -819,7 +819,7 @@ parseArr p s = fmap fromStreamD <$> parseBreakD p (toStreamD s)

819819--

820820{-# INLINE runArrayFold #-}

821821runArrayFold :: (MonadIO m, MonadThrow m, Unboxed a) =>

822− ArrayFold m a b -> SerialT m (A.Array a) -> m b

822+ ArrayFold m a b -> Stream m (A.Array a) -> m b

823823runArrayFold (ArrayFold p) s = fst <$> runArrayParserDBreak p (toStreamD s)

824824

825825-- | Like 'fold' but also returns the remaining stream.

@@ -828,7 +828,7 @@ runArrayFold (ArrayFold p) s = fst <$> runArrayParserDBreak p (toStreamD s)

828828--

829829{-# INLINE runArrayFoldBreak #-}

830830runArrayFoldBreak :: (MonadIO m, MonadThrow m, Unboxed a) =>

831− ArrayFold m a b -> SerialT m (A.Array a) -> m (b, SerialT m (A.Array a))

831+ ArrayFold m a b -> Stream m (A.Array a) -> m (b, Stream m (A.Array a))

832832runArrayFoldBreak (ArrayFold p) s =

833833 second fromStreamD <$> runArrayParserDBreak p (toStreamD s)

834834

src/Streamly/Internal/FileSystem/Dir.hs+5−5

@@ -66,7 +66,7 @@ import Streamly.Internal.Data.Unfold.Type (Unfold(..))

6666-- import Streamly.Internal.Data.Array.Unboxed.Type

6767-- (Array(..), writeNUnsafe, defaultChunkSize, shrinkToFit,

6868-- lpackArraysChunksOf)

69−-- import Streamly.Internal.Data.Stream.Serial (SerialT)

69+-- import Streamly.Internal.Data.Stream (Stream)

7070import Streamly.Internal.Data.Stream.IsStream.Type (IsStream)

7171-- import Streamly.String (encodeUtf8, decodeUtf8, foldLines)

7272

@@ -315,7 +315,7 @@ writeArray h Array{..} = withForeignPtr aStart $ \p -> hPutBuf h p aLen

315315-- @since 0.7.0

316316{-# INLINE fromChunks #-}

317317fromChunks :: (MonadIO m, Storable a)

318− => Handle -> SerialT m (Array a) -> m ()

318+ => Handle -> Stream m (Array a) -> m ()

319319fromChunks h m = S.mapM_ (liftIO . writeArray h) m

320320

321321-- | @fromChunksWithBufferOf bufsize handle stream@ writes a stream of arrays

@@ -326,7 +326,7 @@ fromChunks h m = S.mapM_ (liftIO . writeArray h) m

326326-- @since 0.7.0

327327{-# INLINE fromChunksWithBufferOf #-}

328328fromChunksWithBufferOf :: (MonadIO m, Storable a)

329− => Int -> Handle -> SerialT m (Array a) -> m ()

329+ => Int -> Handle -> Stream m (Array a) -> m ()

330330fromChunksWithBufferOf n h xs = fromChunks h $ AS.compact n xs

331331

332332-- | @fromStreamWithBufferOf bufsize handle stream@ writes @stream@ to @handle@

@@ -335,7 +335,7 @@ fromChunksWithBufferOf n h xs = fromChunks h $ AS.compact n xs

335335--

336336-- @since 0.7.0

337337{-# INLINE fromStreamWithBufferOf #-}

338−fromStreamWithBufferOf :: MonadIO m => Int -> Handle -> SerialT m Word8 -> m ()

338+fromStreamWithBufferOf :: MonadIO m => Int -> Handle -> Stream m Word8 -> m ()

339339fromStreamWithBufferOf n h m = fromChunks h $ S.arraysOf n m

340340-- fromStreamWithBufferOf n h m = fromChunks h $ AS.arraysOf n m

341341

@@ -349,7 +349,7 @@ fromStreamWithBufferOf n h m = fromChunks h $ S.arraysOf n m

349349--

350350-- @since 0.7.0

351351{-# INLINE fromStream #-}

352−fromStream :: MonadIO m => Handle -> SerialT m Word8 -> m ()

352+fromStream :: MonadIO m => Handle -> Stream m Word8 -> m ()

353353fromStream = fromStreamWithBufferOf defaultChunkSize

354354

355355-- | Write a stream of arrays to a handle. Each array in the stream is written

src/Streamly/Internal/FileSystem/Event.hs+3−3

@@ -48,7 +48,7 @@ where

4848import Data.List.NonEmpty (NonEmpty)

4949import Data.Word (Word8)

5050import Streamly.Internal.Data.Array.Unboxed (Array)

51−import Streamly.Prelude (SerialT)

51+import Streamly.Internal.Data.Stream (Stream)

5252

5353#if defined(CABAL_OS_DARWIN)

5454import Streamly.Internal.FileSystem.Event.Darwin (Event)

@@ -115,7 +115,7 @@ import qualified Streamly.Internal.FileSystem.Event.Windows as Event

115115--

116116-- /Pre-release/

117117--

118−watch :: NonEmpty (Array Word8) -> SerialT IO Event

118+watch :: NonEmpty (Array Word8) -> Stream IO Event

119119#if defined(CABAL_OS_DARWIN)

120120watch = Event.watchRecursive

121121#else

@@ -129,7 +129,7 @@ watch = Event.watch

129129--

130130-- /Pre-release/

131131--

132−_watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

132+_watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

133133_watchRecursive = Event.watchRecursive

134134

135135-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Darwin.hs+5−5

@@ -174,7 +174,7 @@ import Foreign.Marshal.Array (withArray)

174174import Foreign.Ptr (Ptr, castPtr)

175175import Foreign.Storable (Storable(..))

176176import GHC.IO.Handle.FD (fdToHandle)

177−import Streamly.Prelude (SerialT)

177+import Streamly.Internal.Data.Stream (Stream)

178178import Streamly.Internal.Data.Cont (contListMap)

179179import Streamly.Internal.Data.Parser (Parser)

180180import Streamly.Internal.Data.Array.Unboxed.Type (Array(..))

@@ -510,7 +510,7 @@ readOneEvent = do

510510 , eventAbsPath = path

511511 }

512512

513−watchToStream :: Watch -> SerialT IO Event

513+watchToStream :: Watch -> Stream IO Event

514514watchToStream (Watch handle _ _) =

515515 S.parseMany readOneEvent $ S.unfold FH.read handle

516516

@@ -566,7 +566,7 @@ watchToStream (Watch handle _ _) =

566566-- /Pre-release/

567567--

568568watchWith ::

569− (Config -> Config) -> NonEmpty (Array Word8) -> SerialT IO Event

569+ (Config -> Config) -> NonEmpty (Array Word8) -> Stream IO Event

570570watchWith f paths = S.bracket before after watchToStream

571571

572572 where

@@ -578,14 +578,14 @@ watchWith f paths = S.bracket before after watchToStream

578578--

579579-- >>> watchRecursive = watchWith id

580580--

581−watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

581+watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

582582watchRecursive = watchWith id

583583

584584-- | Same as 'watchWith' using defaultConfig and non-recursive mode.

585585--

586586-- /Unimplemented/

587587--

588−watch :: NonEmpty (Array Word8) -> SerialT IO Event

588+watch :: NonEmpty (Array Word8) -> Stream IO Event

589589watch _paths = undefined

590590

591591-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Linux.hs+5−5

@@ -172,7 +172,7 @@ import Foreign.Storable (peek, peekByteOff, sizeOf)

172172import GHC.IO.Device (IODeviceType(Stream))

173173import GHC.IO.FD (fdFD, mkFD)

174174import GHC.IO.Handle.FD (mkHandleFromFD)

175−import Streamly.Prelude (SerialT)

175+import Streamly.Internal.Data.Stream (Stream)

176176import Streamly.Internal.Data.Parser (Parser)

177177import Streamly.Internal.Data.Array.Unboxed.Type (Array(..), byteLength)

178178import System.Directory (doesDirectoryExist)

@@ -865,7 +865,7 @@ readOneEvent cfg wt@(Watch _ wdMap) = do

865865 pathLen :: Word32 <- peekByteOff ptr (len + 8)

866866 return (ewd, eflags, cookie, fromIntegral pathLen)

867867

868−watchToStream :: Config -> Watch -> SerialT IO Event

868+watchToStream :: Config -> Watch -> Stream IO Event

869869watchToStream cfg wt@(Watch handle _) = do

870870 -- Do not use too small a buffer. As per inotify man page:

871871 --

@@ -915,7 +915,7 @@ watchToStream cfg wt@(Watch handle _) = do

915915--

916916-- /Pre-release/

917917--

918−watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> SerialT IO Event

918+watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> Stream IO Event

919919watchWith f paths = S.bracket before after (watchToStream cfg)

920920

921921 where

@@ -932,7 +932,7 @@ watchWith f paths = S.bracket before after (watchToStream cfg)

932932--

933933-- /Pre-release/

934934--

935−watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

935+watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

936936watchRecursive = watchWith (setRecursiveMode On)

937937

938938-- | Same as 'watchWith' using defaultConfig and non-recursive mode.

@@ -941,7 +941,7 @@ watchRecursive = watchWith (setRecursiveMode On)

941941--

942942-- /Pre-release/

943943--

944−watch :: NonEmpty (Array Word8) -> SerialT IO Event

944+watch :: NonEmpty (Array Word8) -> Stream IO Event

945945watch = watchWith id

946946

947947-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Windows.hs+7−7

@@ -100,7 +100,7 @@ import Foreign.C.String (peekCWStringLen)

100100import Foreign.Marshal.Alloc (alloca, allocaBytes)

101101import Foreign.Storable (peekByteOff)

102102import Foreign.Ptr (Ptr, FunPtr, castPtr, nullPtr, nullFunPtr, plusPtr)

103−import Streamly.Prelude (SerialT, parallel)

103+import Streamly.Prelude (Stream, parallel)

104104import System.Win32.File

105105 ( FileNotificationFlag

106106 , LPOVERLAPPED

@@ -411,7 +411,7 @@ fILE_ACTION_RENAMED_OLD_NAME = 4

411411fILE_ACTION_RENAMED_NEW_NAME :: FileAction

412412fILE_ACTION_RENAMED_NEW_NAME = 5

413413

414−eventStreamAggr :: (HANDLE, FilePath, Config) -> SerialT IO Event

414+eventStreamAggr :: (HANDLE, FilePath, Config) -> Stream IO Event

415415eventStreamAggr (handle, rootPath, cfg) = do

416416 let recMode = getConfigRecMode cfg

417417 flagMasks = getConfigFlag cfg

@@ -419,7 +419,7 @@ eventStreamAggr (handle, rootPath, cfg) = do

419419 $ readDirectoryChanges rootPath handle recMode flagMasks

420420

421421pathsToHandles ::

422− NonEmpty FilePath -> Config -> SerialT IO (HANDLE, FilePath, Config)

422+ NonEmpty FilePath -> Config -> Stream IO (HANDLE, FilePath, Config)

423423pathsToHandles paths cfg = do

424424 let pathStream = S.fromList (NonEmpty.toList paths)

425425 st2 = S.mapM getWatchHandle pathStream

@@ -437,7 +437,7 @@ utf8ToStringList = NonEmpty.map utf8ToString

437437

438438-- | Close a Directory handle.

439439--

440−closePathHandleStream :: SerialT IO (HANDLE, FilePath, Config) -> IO ()

440+closePathHandleStream :: Stream IO (HANDLE, FilePath, Config) -> IO ()

441441closePathHandleStream = S.mapM_ (\(h, _, _) -> closeHandle h)

442442

443443-- XXX

@@ -471,7 +471,7 @@ closePathHandleStream = S.mapM_ (\(h, _, _) -> closeHandle h)

471471--

472472-- /Pre-release/

473473--

474−watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> SerialT IO Event

474+watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> Stream IO Event

475475watchWith f paths =

476476 S.bracket before after (S.concatMapWith parallel eventStreamAggr)

477477

@@ -486,7 +486,7 @@ watchWith f paths =

486486--

487487-- /Pre-release/

488488--

489−watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

489+watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

490490watchRecursive = watchWith (setRecursiveMode On)

491491

492492-- | Same as 'watchWith' using defaultConfig and non-recursive mode.

@@ -495,7 +495,7 @@ watchRecursive = watchWith (setRecursiveMode On)

495495--

496496-- /Pre-release/

497497--

498−watch :: NonEmpty (Array Word8) -> SerialT IO Event

498+watch :: NonEmpty (Array Word8) -> Stream IO Event

499499watch = watchWith id

500500

501501getFlag :: DWORD -> Event -> Bool

src/Streamly/Internal/Network/Inet/TCP.hs+10−10

@@ -108,7 +108,7 @@ import Streamly.Internal.Control.ForkLifted (fork)

108108import Streamly.Internal.Data.Array.Unboxed.Type (Array(..), writeNUnsafe)

109109import Streamly.Internal.Data.Fold.Type (Fold(..))

110110import Streamly.Internal.Data.Stream.IsStream.Type (IsStream)

111−import Streamly.Internal.Data.Stream.Serial (SerialT)

111+import Streamly.Internal.Data.Stream (Stream)

112112import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

113113import Streamly.Internal.Data.Unfold.Type (Unfold(..))

114114import Streamly.Internal.Network.Socket (SockSpec(..), accept, connections)

@@ -195,7 +195,7 @@ connectionsOnAddrWith

195195 => [(SocketOption, Int)]

196196 -> (Word8, Word8, Word8, Word8)

197197 -> PortNumber

198− -> SerialT m Socket

198+ -> Stream m Socket

199199connectionsOnAddrWith opts addr port =

200200 connections maxListenQueue SockSpec

201201 { sockFamily = AF_INET

@@ -214,7 +214,7 @@ connectionsOnAddr

214214 :: MonadAsync m

215215 => (Word8, Word8, Word8, Word8)

216216 -> PortNumber

217− -> SerialT m Socket

217+ -> Stream m Socket

218218connectionsOnAddr = connectionsOnAddrWith []

219219

220220-- | Like 'connections' but binds on the IPv4 address @0.0.0.0@ i.e. on all

@@ -225,7 +225,7 @@ connectionsOnAddr = connectionsOnAddrWith []

225225--

226226-- /Pre-release/

227227{-# INLINE connectionsOnPort #-}

228−connectionsOnPort :: MonadAsync m => PortNumber -> SerialT m Socket

228+connectionsOnPort :: MonadAsync m => PortNumber -> Stream m Socket

229229connectionsOnPort = connectionsOnAddr (0,0,0,0)

230230

231231-- | Like 'connections' but binds on the localhost IPv4 address @127.0.0.1@.

@@ -236,7 +236,7 @@ connectionsOnPort = connectionsOnAddr (0,0,0,0)

236236--

237237-- /Pre-release/

238238{-# INLINE connectionsOnLocalHost #-}

239−connectionsOnLocalHost :: MonadAsync m => PortNumber -> SerialT m Socket

239+connectionsOnLocalHost :: MonadAsync m => PortNumber -> Stream m Socket

240240connectionsOnLocalHost = connectionsOnAddr (127,0,0,1)

241241

242242-------------------------------------------------------------------------------

@@ -337,7 +337,7 @@ putChunks

337337 :: (MonadCatch m, MonadAsync m)

338338 => (Word8, Word8, Word8, Word8)

339339 -> PortNumber

340− -> SerialT m (Array Word8)

340+ -> Stream m (Array Word8)

341341 -> m ()

342342putChunks addr port xs =

343343 S.drain $ withConnection addr port (\sk -> S.fromEffect $ ISK.putChunks sk xs)

@@ -380,7 +380,7 @@ putBytesWithBufferOf

380380 => Int

381381 -> (Word8, Word8, Word8, Word8)

382382 -> PortNumber

383− -> SerialT m Word8

383+ -> Stream m Word8

384384 -> m ()

385385putBytesWithBufferOf n addr port m = putChunks addr port $ AS.arraysOf n m

386386

@@ -404,7 +404,7 @@ writeWithBufferOf n addr port =

404404-- @since 0.7.0

405405{-# INLINE putBytes #-}

406406putBytes :: (MonadCatch m, MonadAsync m)

407− => (Word8, Word8, Word8, Word8) -> PortNumber -> SerialT m Word8 -> m ()

407+ => (Word8, Word8, Word8, Word8) -> PortNumber -> Stream m Word8 -> m ()

408408putBytes = putBytesWithBufferOf defaultChunkSize

409409

410410-- | Write a stream to the supplied IPv4 host address and port number.

@@ -424,7 +424,7 @@ withInputConnect

424424 :: (IsStream t, MonadCatch m, MonadAsync m)

425425 => (Word8, Word8, Word8, Word8)

426426 -> PortNumber

427− -> SerialT m Word8

427+ -> Stream m Word8

428428 -> (Socket -> t m a)

429429 -> t m a

430430withInputConnect addr port input f = S.bracket pre post handler

@@ -452,6 +452,6 @@ processBytes

452452 :: (IsStream t, MonadAsync m, MonadCatch m)

453453 => (Word8, Word8, Word8, Word8)

454454 -> PortNumber

455− -> SerialT m Word8

455+ -> Stream m Word8

456456 -> t m Word8

457457processBytes addr port input = withInputConnect addr port input ISK.toBytes

src/Streamly/Internal/Unicode/Stream.hs+30−30

@@ -106,8 +106,8 @@ import Streamly.Internal.Data.Array.Unboxed.Mut.Type (ArrayContents)

106106import Streamly.Internal.Data.Fold (Fold)

107107import Streamly.Internal.Data.Stream.IsStream.Type

108108 (IsStream, fromStreamD, toStreamD, adapt)

109−import Streamly.Internal.Data.Stream.Serial (SerialT)

110−import Streamly.Internal.Data.Stream.StreamD (Stream(..), Step (..))

109+import Streamly.Internal.Data.Stream (Stream)

110+import Streamly.Internal.Data.Stream.StreamD (Step (..))

111111import Streamly.Internal.Data.SVar (adaptState)

112112import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

113113import Streamly.Internal.Data.Unboxed (peekWith)

@@ -349,14 +349,14 @@ resumeDecodeUtf8EitherD

349349 :: Monad m

350350 => DecodeState

351351 -> CodePoint

352− -> Stream m Word8

353− -> Stream m (Either DecodeError Char)

354−resumeDecodeUtf8EitherD dst codep (Stream step state) =

352+ -> D.Stream m Word8

353+ -> D.Stream m (Either DecodeError Char)

354+resumeDecodeUtf8EitherD dst codep (D.Stream step state) =

355355 let stt =

356356 if dst == 0

357357 then UTF8DecodeInit state

358358 else UTF8Decoding state dst codep

359− in Stream (step' utf8d) stt

359+ in D.Stream (step' utf8d) stt

360360 where

361361 {-# INLINE_LATE step' #-}

362362 step' _ gst (UTF8DecodeInit st) = do

@@ -420,7 +420,7 @@ resumeDecodeUtf8EitherD dst codep (Stream step state) =

420420--

421421{-# INLINE_NORMAL decodeUtf8EitherD #-}

422422decodeUtf8EitherD :: Monad m

423− => Stream m Word8 -> Stream m (Either DecodeError Char)

423+ => D.Stream m Word8 -> D.Stream m (Either DecodeError Char)

424424decodeUtf8EitherD = resumeDecodeUtf8EitherD 0 0

425425

426426-- |

@@ -563,9 +563,9 @@ parseCharUtf8With = ParserD.toParserK . parseCharUtf8WithD

563563--

564564{-# INLINE_NORMAL decodeUtf8WithD #-}

565565decodeUtf8WithD :: Monad m

566− => CodingFailureMode -> Stream m Word8 -> Stream m Char

567−decodeUtf8WithD cfm (Stream step state) =

568− Stream (step' utf8d) (UTF8DecodeInit state)

566+ => CodingFailureMode -> D.Stream m Word8 -> D.Stream m Char

567+decodeUtf8WithD cfm (D.Stream step state) =

568+ D.Stream (step' utf8d) (UTF8DecodeInit state)

569569

570570 where

571571

@@ -648,7 +648,7 @@ decodeUtf8WithD cfm (Stream step state) =

648648 step' _ _ Done = return Stop

649649

650650{-# INLINE decodeUtf8D #-}

651−decodeUtf8D :: Monad m => Stream m Word8 -> Stream m Char

651+decodeUtf8D :: Monad m => D.Stream m Word8 -> D.Stream m Char

652652decodeUtf8D = decodeUtf8WithD TransliterateCodingFailure

653653

654654-- | Decode a UTF-8 encoded bytestream to a stream of Unicode characters.

@@ -663,7 +663,7 @@ decodeUtf8 :: (Monad m, IsStream t) => t m Word8 -> t m Char

663663decodeUtf8 = fromStreamD . decodeUtf8D . toStreamD

664664

665665{-# INLINE decodeUtf8D' #-}

666−decodeUtf8D' :: Monad m => Stream m Word8 -> Stream m Char

666+decodeUtf8D' :: Monad m => D.Stream m Word8 -> D.Stream m Char

667667decodeUtf8D' = decodeUtf8WithD ErrorOnCodingFailure

668668

669669-- | Decode a UTF-8 encoded bytestream to a stream of Unicode characters.

@@ -675,7 +675,7 @@ decodeUtf8' :: (Monad m, IsStream t) => t m Word8 -> t m Char

675675decodeUtf8' = fromStreamD . decodeUtf8D' . toStreamD

676676

677677{-# INLINE decodeUtf8D_ #-}

678−decodeUtf8D_ :: Monad m => Stream m Word8 -> Stream m Char

678+decodeUtf8D_ :: Monad m => D.Stream m Word8 -> D.Stream m Char

679679decodeUtf8D_ = decodeUtf8WithD DropOnCodingFailure

680680

681681-- | Decode a UTF-8 encoded bytestream to a stream of Unicode characters.

@@ -722,10 +722,10 @@ data FlattenState s a

722722decodeUtf8ArraysWithD ::

723723 MonadIO m

724724 => CodingFailureMode

725− -> Stream m (A.Array Word8)

726− -> Stream m Char

727−decodeUtf8ArraysWithD cfm (Stream step state) =

728− Stream (step' utf8d) (OuterLoop state Nothing)

725+ -> D.Stream m (A.Array Word8)

726+ -> D.Stream m Char

727+decodeUtf8ArraysWithD cfm (D.Stream step state) =

728+ D.Stream (step' utf8d) (OuterLoop state Nothing)

729729 where

730730 {-# INLINE transliterateOrError #-}

731731 transliterateOrError e s =

@@ -824,8 +824,8 @@ decodeUtf8ArraysWithD cfm (Stream step state) =

824824{-# INLINE decodeUtf8ArraysD #-}

825825decodeUtf8ArraysD ::

826826 MonadIO m

827− => Stream m (A.Array Word8)

828− -> Stream m Char

827+ => D.Stream m (A.Array Word8)

828+ -> D.Stream m Char

829829decodeUtf8ArraysD = decodeUtf8ArraysWithD TransliterateCodingFailure

830830

831831-- |

@@ -840,8 +840,8 @@ decodeUtf8Arrays =

840840{-# INLINE decodeUtf8ArraysD' #-}

841841decodeUtf8ArraysD' ::

842842 MonadIO m

843− => Stream m (A.Array Word8)

844− -> Stream m Char

843+ => D.Stream m (A.Array Word8)

844+ -> D.Stream m Char

845845decodeUtf8ArraysD' = decodeUtf8ArraysWithD ErrorOnCodingFailure

846846

847847-- |

@@ -854,8 +854,8 @@ decodeUtf8Arrays' = fromStreamD . decodeUtf8ArraysD' . toStreamD

854854{-# INLINE decodeUtf8ArraysD_ #-}

855855decodeUtf8ArraysD_ ::

856856 MonadIO m

857− => Stream m (A.Array Word8)

858− -> Stream m Char

857+ => D.Stream m (A.Array Word8)

858+ -> D.Stream m Char

859859decodeUtf8ArraysD_ = decodeUtf8ArraysWithD DropOnCodingFailure

860860

861861-- |

@@ -930,7 +930,7 @@ readCharUtf8' =

930930-- points for now, one for the ascii chars (fast path) and one for all other

931931-- paths (slow path).

932932{-# INLINE_NORMAL encodeUtf8D' #-}

933−encodeUtf8D' :: Monad m => Stream m Char -> Stream m Word8

933+encodeUtf8D' :: Monad m => D.Stream m Char -> D.Stream m Word8

934934encodeUtf8D' = D.unfoldMany readCharUtf8'

935935

936936-- | Encode a stream of Unicode characters to a UTF-8 encoded bytestream. When

@@ -950,7 +950,7 @@ readCharUtf8 = readCharUtf8With $ WCons 239 (WCons 191 (WCons 189 WNil))

950950-- https://www.unicode.org/versions/Unicode13.0.0/UnicodeStandard-13.0.pdf

951951--

952952{-# INLINE_NORMAL encodeUtf8D #-}

953−encodeUtf8D :: Monad m => Stream m Char -> Stream m Word8

953+encodeUtf8D :: Monad m => D.Stream m Char -> D.Stream m Word8

954954encodeUtf8D = D.unfoldMany readCharUtf8

955955

956956-- | Encode a stream of Unicode characters to a UTF-8 encoded bytestream. Any

@@ -969,7 +969,7 @@ readCharUtf8_ :: Monad m => Unfold m Char Word8

969969readCharUtf8_ = readCharUtf8With WNil

970970

971971{-# INLINE_NORMAL encodeUtf8D_ #-}

972−encodeUtf8D_ :: Monad m => Stream m Char -> Stream m Word8

972+encodeUtf8D_ :: Monad m => D.Stream m Char -> D.Stream m Word8

973973encodeUtf8D_ = D.unfoldMany readCharUtf8_

974974

975975-- | Encode a stream of Unicode characters to a UTF-8 encoded bytestream. Any

@@ -1003,7 +1003,7 @@ encodeUtf8Lax = encodeUtf8

10031003-- "Haskell"

10041004--

10051005{-# INLINE fromStr# #-}

1006−fromStr# :: MonadIO m => Addr# -> SerialT m Char

1006+fromStr# :: MonadIO m => Addr# -> Stream m Char

10071007fromStr# addr = decodeUtf8 $ Stream.fromByteStr# addr

10081008

10091009-------------------------------------------------------------------------------

@@ -1016,7 +1016,7 @@ fromStr# addr = decodeUtf8 $ Stream.fromByteStr# addr

10161016-- /Internal/

10171017{-# INLINE encodeObject #-}

10181018encodeObject :: MonadIO m =>

1019− (SerialT m Char -> SerialT m Word8)

1019+ (Stream m Char -> Stream m Word8)

10201020 -> Unfold m a Char

10211021 -> a

10221022 -> m (Array Word8)

@@ -1028,7 +1028,7 @@ encodeObject encode u = S.fold Array.write . encode . S.unfold u

10281028-- /Internal/

10291029{-# INLINE encodeObjects #-}

10301030encodeObjects :: (MonadIO m, IsStream t) =>

1031− (SerialT m Char -> SerialT m Word8)

1031+ (Stream m Char -> Stream m Word8)

10321032 -> Unfold m a Char

10331033 -> t m a

10341034 -> t m (Array Word8)

@@ -1040,7 +1040,7 @@ encodeObjects encode u = adapt . Serial.mapM (encodeObject encode u) . adapt

10401040-- @since 0.8.0

10411041{-# INLINE encodeStrings #-}

10421042encodeStrings :: (MonadIO m, IsStream t) =>

1043− (SerialT m Char -> SerialT m Word8) -> t m String -> t m (Array Word8)

1043+ (Stream m Char -> Stream m Word8) -> t m String -> t m (Array Word8)

10441044encodeStrings encode = encodeObjects encode Unfold.fromList

10451045

10461046{-

src/Streamly/Network/Socket.hs+2−2

@@ -52,11 +52,11 @@

5252-- server spec addr =

5353-- Stream.unfold Socket.accept (maxListenQueue, spec, addr) -- ParallelT IO Socket

5454-- & Stream.mapM (Socket.forSocketM echo) -- ParallelT IO ()

55−-- & Stream.fromParallel -- SerialT IO ()

55+-- & Stream.fromParallel -- Stream IO ()

5656-- & Stream.drain -- IO ()

5757--

5858-- echo sk =

59−-- Stream.unfold Socket.readChunks sk -- SerialT IO (Array Word8)

59+-- Stream.unfold Socket.readChunks sk -- Stream IO (Array Word8)

6060-- & Stream.fold (Socket.writeChunks sk) -- IO ()

6161-- @

6262--

src/Streamly/Unicode/Stream.hs+1−1

@@ -38,7 +38,7 @@

3838--

3939-- = String Literals

4040--

41−-- @SerialT Identity Char@ and @Array Char@ are instances of 'IsString' and

41+-- @Stream Identity Char@ and @Array Char@ are instances of 'IsString' and

4242-- 'IsList', therefore, 'OverloadedStrings' and 'OverloadedLists' extensions

4343-- can be used for convenience when specifying unicode strings literals using

4444-- these types.

test/Streamly/Test/Data/Array/Common.hs+3−3

@@ -22,7 +22,7 @@ maxArrLen :: Int

2222maxArrLen = defaultChunkSize * 8

2323

2424genericTestFrom ::

25− (Int -> SerialT IO Int -> IO (Array Int))

25+ (Int -> Stream IO Int -> IO (Array Int))

2626 -> Property

2727genericTestFrom arrFold =

2828 forAll (choose (0, maxArrLen)) $ \len ->

@@ -38,8 +38,8 @@ testLengthFromStreamN :: Property

3838testLengthFromStreamN = genericTestFrom A.fromStreamN

3939

4040genericTestFromTo ::

41− (Int -> SerialT IO Int -> IO (Array Int))

42− -> (Array Int -> SerialT IO Int)

41+ (Int -> Stream IO Int -> IO (Array Int))

42+ -> (Array Int -> Stream IO Int)

4343 -> ([Int] -> [Int] -> Bool)

4444 -> Property

4545genericTestFromTo arrFold arrUnfold listEq =

test/Streamly/Test/Data/Array/CommonImports.hs+1−1

@@ -7,7 +7,7 @@ import Test.QuickCheck.Monadic (monadicIO, assert, run)

77import Test.Hspec as H

99import Streamly.Data.Fold (Fold)

10−import Streamly.Prelude (SerialT)

10+import Streamly.Internal.Data.Stream (Stream)

1111import Streamly.Test.Common (listEquals)

1212

1313import qualified Streamly.Prelude as S

test/Streamly/Test/FileSystem/Handle.hs+15−12

@@ -11,7 +11,7 @@ module Streamly.Test.FileSystem.Handle (main) where

1111import Data.Functor.Identity (runIdentity)

1212import Data.Word (Word8)

1313import Streamly.Internal.Data.Unboxed (sizeOf)

14−import Streamly.Internal.Data.Stream.IsStream (IsStream, SerialT)

14+import Streamly.Internal.Data.Stream (Stream)

1515import System.FilePath ((</>))

1616import System.IO

1717 ( Handle

@@ -28,7 +28,7 @@ import Test.QuickCheck.Monadic (monadicIO, assert, run)

2828

2929import qualified Streamly.Data.Fold as Fold

3030import qualified Streamly.Internal.FileSystem.Handle as Handle

31−import qualified Streamly.Internal.Data.Stream.IsStream as Stream

31+import qualified Streamly.Internal.Data.Stream as Stream

3232import qualified Streamly.Internal.Data.Array.Unboxed as Array

3333import qualified Streamly.Internal.Unicode.Stream as Unicode

3434

@@ -51,9 +51,12 @@ maxTestCount = 10

5151chooseWord8 :: (Word8, Word8) -> Gen Word8

5252chooseWord8 = choose

5353

54+toList :: Monad m => Stream m a -> m [a]

55+toList = Stream.fold Fold.toList

56+

5457utf8ToString :: Array.Array Word8 -> String

5558utf8ToString =

56− runIdentity . Stream.toList . Unicode.decodeUtf8' . Array.toStream

59+ runIdentity . toList . Unicode.decodeUtf8' . Array.toStream

5760

5861testData :: String

5962testData = "This is the test data for FileSystem.Handle ??`!@#$%^&*~~))`]"

@@ -64,7 +67,7 @@ testDataLarge = concat $ replicate 6000 testData

6467testBinData :: String

6568testBinData = "01234567890123456789012345678901234567890123456789"

6669

67−executor :: (Handle -> SerialT IO Char) -> IO (SerialT IO Char)

70+executor :: (Handle -> Stream IO Char) -> IO (Stream IO Char)

6871executor f =

6972 withSystemTempDirectory "fs_handle" $ \fp -> do

7073 let fpath = fp </> "tmp_read.txt"

@@ -72,25 +75,25 @@ executor f =

7275 h <- openFile fpath ReadMode

7376 return $ f h

7477

75−readFromHandle :: IO (SerialT IO Char)

78+readFromHandle :: IO (Stream IO Char)

7679readFromHandle =

7780 let f = Unicode.decodeUtf8 . Stream.unfold Handle.read

7881 in executor f

7982

80−readWithBufferFromHandle :: IO (SerialT IO Char)

83+readWithBufferFromHandle :: IO (Stream IO Char)

8184readWithBufferFromHandle =

8285 let f1 = (\h -> (1024, h))

8386 f2 = Unicode.decodeUtf8 . Stream.unfold Handle.readWith . f1

8487 in executor f2

8588

86−readChunksFromHandle :: IO (SerialT IO Char)

89+readChunksFromHandle :: IO (Stream IO Char)

8790readChunksFromHandle =

8891 let f = Unicode.decodeUtf8

8992 . Stream.concatMap Array.toStream

9093 . Stream.unfold Handle.readChunks

9194 in executor f

9295

93−readChunksWithBuffer :: IO (SerialT IO Char)

96+readChunksWithBuffer :: IO (Stream IO Char)

9497readChunksWithBuffer =

9598 let f1 = (\h -> (1024, h))

9699 f2 =

@@ -100,7 +103,7 @@ readChunksWithBuffer =

100103 . f1

101104 in executor f2

102105

103−testRead :: (IsStream t) => IO (t IO Char) -> Property

106+testRead :: IO (Stream IO Char) -> Property

104107testRead fn = monadicIO $ do

105108 let v2 = Stream.fromList testDataLarge

106109 v1 <- run fn

@@ -126,7 +129,7 @@ testWrite hfold =

126129 _ <- Stream.fold (hfold h) $ Stream.fromList list

127130 hFlush h

128131 hSeek h AbsoluteSeek 0

129− ls <- Stream.toList $ Stream.unfold Handle.read h

132+ ls <- toList $ Stream.unfold Handle.read h

130133 hClose h

131134 return (ls == list)

132135

@@ -151,7 +154,7 @@ testWriteWithChunk =

151154 $ Stream.unfold Handle.readChunksWith (1024, hr)

152155 hFlush hw

153156 hSeek hw AbsoluteSeek 0

154− ls <- Stream.toList $ Stream.unfold Handle.read hw

157+ ls <- toList $ Stream.unfold Handle.read hw

155158 let arr = Array.fromList ls

156159 return (testDataLarge == utf8ToString arr)

157160

@@ -166,7 +169,7 @@ testReadChunksFromToWith from to buffSize res = monadicIO $ run go

166169 writeFile fpathRead testBinData

167170 h <- openFile fpathRead ReadMode

168171 ls <-

169− Stream.toList

172+ toList

170173 $ Stream.unfold

171174 Handle.readChunksFromToWith (from, to, buffSize, h)

172175 return (res `shouldBe` fmap Array.toList ls)

test/Streamly/Test/Network/Inet/TCP.hs+8−8

@@ -16,7 +16,7 @@ import Data.Word (Word8)

1616import Network.Socket (Socket, PortNumber)

1717import Streamly.Internal.Control.Monad (discard)

1818import Streamly.Internal.System.IO (defaultChunkSize)

19−import Streamly.Prelude (SerialT)

19+import Streamly.Internal.Data.Stream (Stream)

2020import Test.QuickCheck (Property)

2121import Test.QuickCheck.Monadic (monadicIO, assert, run)

2222

@@ -78,22 +78,22 @@ server listener port sem handler = do

7878remoteAddr :: (Word8,Word8,Word8,Word8)

7979remoteAddr = (127, 0, 0, 1)

8080

81−sender :: PortNumber -> MVar () -> SerialT IO Char

81+sender :: PortNumber -> MVar () -> Stream IO Char

8282sender port sem = do

8383 _ <- liftIO $ takeMVar sem

8484 liftIO $ threadDelay 1000000 -- wait for server

85− Stream.replicate 1000 testData -- SerialT IO String

86− & Stream.concatMap Stream.fromList -- SerialT IO Char

87− & Unicode.encodeLatin1 -- SerialT IO Word8

88− & TCP.processBytes remoteAddr port -- SerialT IO Word8

89− & Unicode.decodeLatin1 -- SerialT IO Char

85+ Stream.replicate 1000 testData -- Stream IO String

86+ & Stream.concatMap Stream.fromList -- Stream IO Char

87+ & Unicode.encodeLatin1 -- Stream IO Word8

88+ & TCP.processBytes remoteAddr port -- Stream IO Word8

89+ & Unicode.decodeLatin1 -- Stream IO Char

9090

9191execute

9292 :: Unfold.Unfold IO PortNumber Socket

9393 -> PortNumber

9494 -> Int

9595 -> (Socket -> IO ())

96− -> IO (SerialT IO Char)

96+ -> IO (Stream IO Char)

9797execute listener port size handler = do

9898 sem <- newEmptyMVar

9999 tid <- forkIO $ server listener port sem handler

test/Streamly/Test/Network/Socket.hs+8−8

@@ -16,7 +16,7 @@ import Data.Word (Word8)

1616import Network.Socket (Socket, PortNumber)

1717import Streamly.Internal.Control.Monad (discard)

1818import Streamly.Internal.System.IO (defaultChunkSize)

19−import Streamly.Prelude (SerialT)

19+import Streamly.Internal.Data.Stream (Stream)

2020import Test.QuickCheck (Property)

2121import Test.QuickCheck.Monadic (monadicIO, assert, run)

2222

@@ -89,17 +89,17 @@ server port sem handler = do

8989remoteAddr :: (Word8,Word8,Word8,Word8)

9090remoteAddr = (127, 0, 0, 1)

9191

92−sender :: PortNumber -> MVar () -> SerialT IO Char

92+sender :: PortNumber -> MVar () -> Stream IO Char

9393sender port sem = do

9494 _ <- liftIO $ takeMVar sem

9595 liftIO $ threadDelay 1000000 -- wait for server

96− Stream.replicate 1000 testData -- SerialT IO String

97− & Stream.concatMap Stream.fromList -- SerialT IO Char

98− & Unicode.encodeLatin1 -- SerialT IO Word8

99− & TCP.processBytes remoteAddr port -- SerialT IO Word8

100− & Unicode.decodeLatin1 -- SerialT IO Char

96+ Stream.replicate 1000 testData -- Stream IO String

97+ & Stream.concatMap Stream.fromList -- Stream IO Char

98+ & Unicode.encodeLatin1 -- Stream IO Word8

99+ & TCP.processBytes remoteAddr port -- Stream IO Word8

100+ & Unicode.decodeLatin1 -- Stream IO Char

101101

102−execute :: PortNumber -> Int -> (Socket -> IO ()) -> IO (SerialT IO Char)

102+execute :: PortNumber -> Int -> (Socket -> IO ()) -> IO (Stream IO Char)

103103execute port size handler = do

104104 sem <- newEmptyMVar

105105 tid <- forkIO $ server port sem handler

test/Streamly/Test/Unicode/Char.hs+3−3

@@ -21,11 +21,11 @@ import Streamly.Internal.Unicode.Char

2121 ( NormalizationMode(NFC, NFD, NFKC, NFKD)

2222 , normalize

2323 )

24−import Streamly.Internal.Data.Stream.IsStream (SerialT)

24+import Streamly.Internal.Data.Stream (Stream)

2525import Text.Printf (printf)

2626import System.FilePath.Posix ((</>))

2727

28−import qualified Streamly.Internal.Data.Stream.IsStream as S

28+import qualified Streamly.Internal.Data.Stream as S

2929import qualified Streamly.Internal.Data.Fold as FL

3030import qualified System.Directory as Dir

3131

@@ -35,7 +35,7 @@ chrToHex = map toUpper . printf "%.4x" . ord

3535strToHex :: [Char] -> String

3636strToHex = unwords . map chrToHex

3737

38−type Text = SerialT IO Char

38+type Text = Stream IO Char

3939

4040checkEqual :: String -> (Text -> Text) -> (Text, Text) -> IO Bool

4141checkEqual opName op (mc1, mc2) = do