a404317 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Replace SerialT with Stream for remaining modules (#1777)

a404317Ranjeet Ranjan4 years ago

benchmark/NanoBenchmarks.hs+1−4

compare with master

unifiedsplit

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

6{-# LANGUAGE FlexibleContexts #-}

7{-# LANGUAGE ScopedTypeVariables #-}

9−import Streamly.Prelude (SerialT)

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

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

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

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

25maxValue :: Int

26maxValue = 100000

28−-- type Stream = K.Stream

29−type Stream = SerialT

30−

31{-# INLINE sourceUnfoldrM #-}

28{-# INLINE sourceUnfoldrM #-}

32sourceUnfoldrM :: MonadAsync m => Stream m Int

29sourceUnfoldrM :: MonadAsync m => Stream m Int

33sourceUnfoldrM = S.unfoldrM step 0

30sourceUnfoldrM = S.unfoldrM step 0

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

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

1−

2−

3-------------------------------------------------------------------------------

1-------------------------------------------------------------------------------

4-- Benchmark helpers

2-- Benchmark helpers

5-------------------------------------------------------------------------------

3-------------------------------------------------------------------------------

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

69{-# INLINE onArray #-}

67{-# INLINE onArray #-}

70onArray

68onArray

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

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

72 -> Stream Int

70 -> Stream Int

73 -> m (Stream Int)

71 -> m (Stream Int)

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

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

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

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

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

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

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

104

102

105−

106-------------------------------------------------------------------------------

103-------------------------------------------------------------------------------

107-- Elimination

104-- Elimination

108-------------------------------------------------------------------------------

105-------------------------------------------------------------------------------

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

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

1{-# LANGUAGE FlexibleContexts #-}

3import Control.DeepSeq (NFData(..))

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

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

4import System.Random (randomRIO)

6import System.Random (randomRIO)

6import qualified Streamly.Prelude as S

8import qualified Streamly.Prelude as S

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

8import Gauge

11import Gauge

9import Streamly.Benchmark.Common hiding (benchPureSrc)

12import Streamly.Benchmark.Common hiding (benchPureSrc)

10import qualified Streamly.Benchmark.Prelude as P

13import qualified Streamly.Benchmark.Prelude as P

12−

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

14−

15import 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)

29import Data.Functor.Identity (runIdentity)

30import Data.Maybe (isJust)

31import Data.Word (Word8)

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

32import System.IO (Handle)

33import System.IO (Handle)

33import System.Random (randomRIO)

34import System.Random (randomRIO)

34import Prelude hiding ()

35import Prelude hiding ()

36−import qualified Streamly.Prelude as Stream

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

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

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

40import 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

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

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

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

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

45import Gauge hiding (env)

46import Gauge hiding (env)

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

47import Streamly.Benchmark.Common

48import Streamly.Benchmark.Common.Handle

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

50#ifdef INSPECTION

51#ifdef INSPECTION

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

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

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

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

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

62{-# INLINE sourceUnfoldrM #-}

63{-# INLINE sourceUnfoldrM #-}

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

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

64−sourceUnfoldrM value n = Stream.unfoldrM step n

65+sourceUnfoldrM value n = S.unfoldrM step n

65 where

66 where

66 step cnt =

67 step cnt =

67 if cnt > n + value

68 if cnt > n + value

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

71{-# INLINE benchIO #-}

72{-# INLINE benchIO #-}

72benchIO

73benchIO

73 :: NFData b

74 :: 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

75benchIO name src sink =

76benchIO name src sink =

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

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

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

227-------------------------------------------------------------------------------

228-------------------------------------------------------------------------------

228

229

229{-# INLINE fold #-}

230{-# INLINE fold #-}

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

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

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

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

232

233

233{-# INLINE parse #-}

234{-# INLINE parse #-}

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

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

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

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

236

237

237{-# INLINE foldBreak #-}

238{-# INLINE foldBreak #-}

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

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

239foldBreak s = do

240foldBreak s = do

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

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

241 when (isJust r) $ foldBreak s1

242 when (isJust r) $ foldBreak s1

242

243

243{-# INLINE parseBreak #-}

244{-# INLINE parseBreak #-}

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

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

245parseBreak s = do

246parseBreak s = do

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

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

247 case r of

248 case r of

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

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

20import Control.DeepSeq (NFData(..))

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

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

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

24import System.Random (randomRIO)

23import System.Random (randomRIO)

25import Prelude

24import Prelude

26 ( IO

25 ( IO

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

36 , (||)

35 , (||)

37 , concat

36 , concat

38 , const

37 , const

38+ , fmap

39 , id

40 , undefined

41 )

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

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

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

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

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

46−import qualified Streamly.Prelude as Stream

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

48import Gauge

49import Gauge

49import Streamly.Benchmark.Common hiding (benchPureSrc)

50import Streamly.Benchmark.Common hiding (benchPureSrc)

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

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

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

78benchIOSrc name src = benchIO name src id

79benchIOSrc name src = benchIO name src id

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

82+drain = Stream.fold Fold.drain

83+

80-------------------------------------------------------------------------------

84-------------------------------------------------------------------------------

81-- Bench Ops

85-- Bench Ops

82-------------------------------------------------------------------------------

86-------------------------------------------------------------------------------

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

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

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

114

118

115{-# INLINE sourceUnfoldrM #-}

119{-# INLINE sourceUnfoldrM #-}

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

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

117sourceUnfoldrM value n = Stream.unfoldrM step n

121sourceUnfoldrM value n = Stream.unfoldrM step n

118 where

122 where

119 step cnt =

123 step cnt =

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

138

142

139{-# INLINE scanl' #-}

143{-# INLINE scanl' #-}

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

144scanl' :: 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)

142

146

143{-# INLINE scanl1' #-}

147{-# INLINE scanl1' #-}

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

148scanl1' :: 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' (+)

146

150

147{-# INLINE map #-}

151{-# INLINE map #-}

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

152map :: 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)

150

154

151{-# INLINE onArray #-}

155{-# INLINE onArray #-}

152onArray

156onArray

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

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

154 -> Stream Int

158 -> Stream Int

155 -> m (Stream Int)

159 -> m (Stream Int)

156onArray value f arr =

160onArray value f arr =

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

162

166

163{-# INLINE unfoldReadDrain #-}

167{-# INLINE unfoldReadDrain #-}

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

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

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

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

166

170

167{-# INLINE unfoldReadRevDrain #-}

171{-# INLINE unfoldReadRevDrain #-}

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

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

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

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

170

174

171{-# INLINE toStreamDRevDrain #-}

175{-# INLINE toStreamDRevDrain #-}

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

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

173toStreamDRevDrain =

177toStreamDRevDrain =

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

178+ drain . Stream.fromStreamD . MArray.toStreamDRev

175

179

176{-# INLINE toStreamDDrain #-}

180{-# INLINE toStreamDDrain #-}

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

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

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

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

179

183

180{-# INLINE unfoldFold #-}

184{-# INLINE unfoldFold #-}

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

185unfoldFold :: 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

183

187

184-------------------------------------------------------------------------------

188-------------------------------------------------------------------------------

185-- Bench groups

189-- Bench groups

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

273 where

277 where

274

278

275 alloc value = do

279 alloc value = do

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

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

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

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

278 return (marr, indices)

282 return (marr, indices)

279

283

280 allBenchmarks array value =

284 allBenchmarks array value =

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

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

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

24import System.Random (randomRIO)

26−import Streamly.Prelude (SerialT)

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

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

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

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

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

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

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

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

34−import qualified Streamly.Prelude as S

36import Gauge

35import Gauge

37import Streamly.Benchmark.Common

36import Streamly.Benchmark.Common

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

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

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

43{-# INLINE sourceUnfoldrM #-}

42{-# INLINE sourceUnfoldrM #-}

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

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

45−sourceUnfoldrM value n = S.unfoldrM step n

44+sourceUnfoldrM value n = Stream.unfoldrM step n

46 where

45 where

47 step cnt =

46 step cnt =

48 if cnt > n + value

47 if cnt > n + value

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

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

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

52{-# INLINE source #-}

51{-# INLINE source #-}

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

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

54source = sourceUnfoldrM

53source = sourceUnfoldrM

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

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

57{-# INLINE benchIOSink #-}

56{-# INLINE benchIOSink #-}

58benchIOSink

57benchIOSink

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

58+ :: NFData b

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

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

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

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

63-------------------------------------------------------------------------------

62-------------------------------------------------------------------------------

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

65-------------------------------------------------------------------------------

64-------------------------------------------------------------------------------

67{-# INLINE any #-}

66{-# INLINE any #-}

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

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

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

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

71{-# INLINE all #-}

70{-# INLINE all #-}

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

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

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

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

75{-# INLINE take #-}

74{-# INLINE take #-}

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

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

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

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

79{-# INLINE sequence_ #-}

78{-# INLINE sequence_ #-}

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

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

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

91-------------------------------------------------------------------------------

90-------------------------------------------------------------------------------

93{-# INLINE filter #-}

92{-# INLINE filter #-}

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

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

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

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

97{-# INLINE foldFilter #-}

96{-# INLINE foldFilter #-}

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

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

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

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

100

101{-# INLINE foldFilter2 #-}

100{-# INLINE foldFilter2 #-}

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

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

103foldFilter2 _ =

102foldFilter2 _ =

104− IP.fold

103+ Stream.fold

105 $ FL.foldFilter (FL.satisfy even)

104 $ FL.foldFilter (FL.satisfy even)

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

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

107

106

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

110-------------------------------------------------------------------------------

109-------------------------------------------------------------------------------

111

110

112{-# INLINE takeEndBy_ #-}

111{-# INLINE takeEndBy_ #-}

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

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

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

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

115

114

116{-# INLINE many #-}

115{-# INLINE many #-}

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

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

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

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

119

118

120{-# INLINE splitAllAny #-}

119{-# INLINE splitAllAny #-}

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

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

122splitAllAny value =

121splitAllAny value =

123− IP.fold

122+ Stream.fold

124 (FL.serialWith (,)

123 (FL.serialWith (,)

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

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

126 (FL.any (> value))

125 (FL.any (> value))

127 )

126 )

128

127

129{-# INLINE serial_ #-}

128{-# INLINE serial_ #-}

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

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

131serial_ value =

130serial_ value =

132− IP.fold

131+ Stream.fold

133 (FL.serial_

132 (FL.serial_

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

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

135 (FL.any (> value))

134 (FL.any (> value))

136 )

135 )

137

136

138{-# INLINE shortest #-}

137{-# INLINE shortest #-}

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

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

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

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

141

140

142{-# INLINE longest #-}

141{-# INLINE longest #-}

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

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

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

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

145

144

146{-# INLINE foldBreak #-}

145{-# INLINE foldBreak #-}

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

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

148foldBreak s = do

147foldBreak s = do

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

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

150 when (r /= 0) $ foldBreak s1

149 when (r /= 0) $ foldBreak s1

151

150

152-------------------------------------------------------------------------------

151-------------------------------------------------------------------------------

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

154-------------------------------------------------------------------------------

153-------------------------------------------------------------------------------

155

154

156{-# INLINE teeSumLength #-}

155{-# INLINE teeSumLength #-}

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

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

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

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

159

158

160{-# INLINE teeAllAny #-}

159{-# INLINE teeAllAny #-}

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

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

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

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

163

162

164 where

163 where

165

164

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

167 any_ = FL.any (> value)

166 any_ = FL.any (> value)

168

167

169{-# INLINE teeWithFst #-}

168{-# INLINE teeWithFst #-}

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

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

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

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

172

171

173{-# INLINE teeWithMin #-}

172{-# INLINE teeWithMin #-}

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

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

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

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

176

175

177{-# INLINE distribute #-}

176{-# INLINE distribute #-}

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

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

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

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

180

179

181-------------------------------------------------------------------------------

180-------------------------------------------------------------------------------

182-- Partitioning

181-- Partitioning

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

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

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

188

187

189{-# INLINE partition #-}

188{-# INLINE partition #-}

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

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

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

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

192

191

193{-# INLINE partitionByFstM #-}

192{-# INLINE partitionByFstM #-}

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

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

195partitionByFstM =

194partitionByFstM =

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

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

197

196

198{-# INLINE partitionByMinM #-}

197{-# INLINE partitionByMinM #-}

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

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

200partitionByMinM =

199partitionByMinM =

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

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

202

201

203{-# INLINE demuxWith #-}

202{-# INLINE demuxWith #-}

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

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

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

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

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

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

207

206

208{-# INLINE demuxWithInt #-}

207{-# INLINE demuxWithInt #-}

209demuxWithInt :: Monad m =>

208demuxWithInt :: Monad m =>

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

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

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

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

212

211

213{-# INLINE demuxWithHash #-}

212{-# INLINE demuxWithHash #-}

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

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

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

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

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

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

217

216

218{-# INLINE demuxMutWith #-}

217{-# INLINE demuxMutWith #-}

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

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

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

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

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

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

222

221

223{-# INLINE demuxMutWithHash #-}

222{-# INLINE demuxMutWithHash #-}

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

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

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

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

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

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

227

226

228{-# INLINE classifyWith #-}

227{-# INLINE classifyWith #-}

229classifyWith ::

228classifyWith ::

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

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

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

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

232

231

233{-# INLINE classifyWithInt #-}

232{-# INLINE classifyWithInt #-}

234classifyWithInt ::

233classifyWithInt ::

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

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

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

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

237

236

238{-# INLINE classifyMutWith #-}

237{-# INLINE classifyMutWith #-}

239classifyMutWith ::

238classifyMutWith ::

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

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

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

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

242

241

243{-# INLINE classifyMutWithInt #-}

242{-# INLINE classifyMutWithInt #-}

244classifyMutWithInt ::

243classifyMutWithInt ::

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

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

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

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

247

246

248{-# INLINE classifyMutWithHash #-}

247{-# INLINE classifyMutWithHash #-}

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

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

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

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

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

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

252

251

253-------------------------------------------------------------------------------

252-------------------------------------------------------------------------------

254-- unzip

253-- unzip

255-------------------------------------------------------------------------------

254-------------------------------------------------------------------------------

256

255

257{-# INLINE unzip #-}

256{-# INLINE unzip #-}

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

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

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

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

260

259

261{-# INLINE unzipWithFstM #-}

260{-# INLINE unzipWithFstM #-}

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

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

263unzipWithFstM = do

262unzipWithFstM = do

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

263 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)

266

265

267{-# INLINE unzipWithMinM #-}

266{-# INLINE unzipWithMinM #-}

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

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

269unzipWithMinM = do

268unzipWithMinM = do

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

269 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)

272

271

273-------------------------------------------------------------------------------

272-------------------------------------------------------------------------------

274-- Nested

273-- Nested

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

278unfoldMany :: Int -> Benchmarkable

277unfoldMany :: Int -> Benchmarkable

279unfoldMany val =

278unfoldMany val =

280 nfIO

279 nfIO

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

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

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

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

283

282

284-------------------------------------------------------------------------------

283-------------------------------------------------------------------------------

285-- Benchmarks

284-- Benchmarks

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

291o_1_space_serial_elimination :: Int -> [Benchmark]

290o_1_space_serial_elimination :: Int -> [Benchmark]

292o_1_space_serial_elimination value =

291o_1_space_serial_elimination value =

293 [ bgroup "elimination"

292 [ bgroup "elimination"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

309 , benchIOSink

308 , benchIOSink

310 value

309 value

311 "mean"

310 "mean"

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

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

313 , benchIOSink

312 , benchIOSink

314 value

313 value

315 "variance"

314 "variance"

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

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

317 , benchIOSink

316 , benchIOSink

318 value

317 value

319 "stdDev"

318 "stdDev"

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

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

321 , benchIOSink

320 , benchIOSink

322 value

321 value

323 "mconcat"

322 "mconcat"

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

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

325 , benchIOSink

324 , benchIOSink

326 value

325 value

327 "foldMap"

326 "foldMap"

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

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

329 , benchIOSink

328 , benchIOSink

330 value

329 value

331 "foldMapM"

330 "foldMapM"

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

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

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

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

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

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

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

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

336 , benchIOSink

335 , benchIOSink

337 value

336 value

338 "lookup"

337 "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))))

340 , benchIOSink

339 , benchIOSink

341 value

340 value

342 "findIndex"

341 "findIndex"

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

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

344 , benchIOSink

343 , benchIOSink

345 value

344 value

346 "elemIndex"

345 "elemIndex"

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

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

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

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

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

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

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

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

351 , benchIOSink value "all" $ all value

350 , benchIOSink value "all" $ all value

352 , benchIOSink value "any" $ any value

351 , benchIOSink value "any" $ any value

353 , benchIOSink value "take" $ take value

352 , benchIOSink value "take" $ take value

354 , benchIOSink value "takeEndBy_" $ takeEndBy_ value

353 , benchIOSink value "takeEndBy_" $ takeEndBy_ value

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

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

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

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

357 ]

356 ]

358 ]

357 ]

359

358

360o_1_space_serial_transformation :: Int -> [Benchmark]

359o_1_space_serial_transformation :: Int -> [Benchmark]

361o_1_space_serial_transformation value =

360o_1_space_serial_transformation value =

362 [ bgroup "transformation"

361 [ bgroup "transformation"

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

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

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

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

365 fld = FL.mapMaybe f FL.drain

364 fld = FL.mapMaybe f FL.drain

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

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

367 , benchIOSink

366 , benchIOSink

368 value

367 value

369 "rsequence"

368 "rsequence"

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

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

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

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

372 , benchIOSink

371 , benchIOSink

373 value

372 value

374 "pipe-mapM"

373 "pipe-mapM"

375− (S.fold

374+ (Stream.fold

376 (FL.transform

375 (FL.transform

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

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

378 FL.drain))

377 FL.drain))

379 , benchIOSink

378 , benchIOSink

380 value

379 value

381 "fold-scan"

380 "fold-scan"

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

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

383 , benchIOSink

382 , benchIOSink

384 value

383 value

385 "fold-scanMany"

384 "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)

387 , benchIOSink

386 , benchIOSink

388 value

387 value

389 "fold-postscan"

388 "fold-postscan"

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

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

391 ]

390 ]

392 ]

391 ]

393

392

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

421

420

422o_n_space_serial :: Int -> [Benchmark]

421o_n_space_serial :: Int -> [Benchmark]

423o_n_space_serial value =

422o_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))

425 ]

424 ]

426

425

427o_n_heap_serial :: Int -> [Benchmark]

426o_n_heap_serial :: Int -> [Benchmark]

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

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

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

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

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

432 [

431 [

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

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

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

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

435 , benchIOSink value "toStream"

434 , benchIOSink value "toStream"

436− (S.fold FL.toStream

435+ (Stream.fold FL.toStream

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

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

438 , benchIOSink value "toStreamRev"

437 , benchIOSink value "toStreamRev"

439− (S.fold FL.toStreamRev

438+ (Stream.fold FL.toStreamRev

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

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

441 ]

440 ]

442 , bgroup "key-value"

441 , bgroup "key-value"

443 [

442 [

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

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

3import Control.DeepSeq (NFData)

4import Streamly.Data.Fold (Fold)

5−import Streamly.Prelude (SerialT)

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

6import System.Random (randomRIO)

8import qualified Streamly.Data.Fold as Fold

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

34{-# INLINE benchWith #-}

35benchWith :: (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

37benchWith src len name f =

38 bench name

39 $ nfIO

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

50{-# INLINE benchScanWith #-}

51benchScanWith :: 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

53benchScanWith src len name f =

54 bench name

55 $ nfIO

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

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

31import qualified Data.Foldable as F

32import qualified Control.Applicative as AP

33import qualified Streamly.FileSystem.Handle as Handle

34−import qualified Streamly.Prelude as S

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

34import 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

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

36import 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)

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

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

42import Gauge hiding (env)

43−import Streamly.Prelude (SerialT)

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

44import Streamly.Benchmark.Common

45import Streamly.Benchmark.Common.Handle

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

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

53{-# INLINE sourceUnfoldrM #-}

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

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

55−sourceUnfoldrM value n = S.unfoldrM step n

55+sourceUnfoldrM value n = Stream.unfoldrM step n

56 where

57 step cnt =

58 if cnt > n + value

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

65-- sequence of `}`.

66{-# INLINE sourceEscapedFrames #-}

67sourceEscapedFrames ::

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

68+ Monad m

69 => Int

70 -> Int

71− -> t m Char

71+ -> Stream m Char

72−sourceEscapedFrames value n = S.unfoldrM step n

72+sourceEscapedFrames value n = Stream.unfoldrM step n

73 where

75 bs = '\\'

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

91{-# INLINE benchIOSrc #-}

92benchIOSrc

93 :: NFData b

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

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

95 -> Int

96 -> String

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

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

98 -> Benchmark

99benchIOSrc src value name f =

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

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

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

103{-# INLINE benchIOSink #-}

104benchIOSink

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

105+ :: NFData b

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

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

107benchIOSink value name f =

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

109

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

112-------------------------------------------------------------------------------

113

114{-# INLINE one #-}

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

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

116−one value = IP.parse p

116+one value = Stream.parse p

117

118 where

119

120 p = do

121− m <- PR.fromFold FL.one

121+ m <- PR.fromFold Fold.one

122 case m of

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

124 Nothing -> pure Nothing

125

126{-# INLINE takeBetween #-}

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

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

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

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

129

130{-# INLINE takeEQ #-}

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

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

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

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

133

134{-# INLINE dropWhile #-}

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

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

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

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

137

138{-# INLINE takeStartBy #-}

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

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

140takeStartBy value stream = do

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

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

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

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

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

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

144

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

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

146−takeFramedByEsc_ _ = IP.parse parser

146+takeFramedByEsc_ _ = Stream.parse parser

147

148 where

149

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

151 isBegin = (== '{')

152 isEnd = (== '}')

153

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

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

155

156{-# INLINE takeWhile #-}

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

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

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

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

159

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

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

161takeWhileP 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))

163

164{-# INLINE takeP #-}

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

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

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

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

167

168{-# INLINE groupBy #-}

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

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

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

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

171

172{-# INLINE groupByRolling #-}

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

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

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

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

175

176{-# INLINE wordBy #-}

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

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

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

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

179

180{-# INLINE sepByWords #-}

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

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

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

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

183 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)

185

186{-# INLINE deintercalate #-}

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

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

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

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

189

190 where

191

192 partition p =

193 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)

195

196{-# INLINE manyWordByEven #-}

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

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

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

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

199

200{-# INLINE many #-}

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

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

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

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

203

204{-# INLINE manyAlt #-}

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

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

206manyAlt xs = do

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

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

208 return $ Prelude.length x

209

210{-# INLINE some #-}

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

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

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

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

213

214{-# INLINE someAlt #-}

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

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

216someAlt xs = do

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

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

218 return $ Prelude.length x

219

220{-# INLINE manyTill #-}

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

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

222manyTill 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)

224

225{-# INLINE splitAp #-}

226splitAp :: MonadCatch m

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

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

228splitAp value =

229− IP.parse

229+ Stream.parse

230 ((,)

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

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

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

234

235{-# INLINE splitApBefore #-}

236splitApBefore :: MonadCatch m

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

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

238splitApBefore value =

239− IP.parse

239+ Stream.parse

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

241 *> PR.dropWhile (<= value)

242 )

243

244{-# INLINE splitApAfter #-}

245splitApAfter :: MonadCatch m

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

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

247splitApAfter value =

248− IP.parse

248+ Stream.parse

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

250 <* PR.dropWhile (<= value)

251 )

252

253{-# INLINE serialWith #-}

254serialWith :: MonadCatch m

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

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

256serialWith value =

257− IP.parse

257+ Stream.parse

258 (PR.serialWith (,)

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

260 (PR.dropWhile (<= value))

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

262

263{-# INLINE split_ #-}

264split_ :: MonadCatch m

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

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

266split_ value =

267− IP.parse

267+ Stream.parse

268 (PR.split_

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

270 (PR.dropWhile (<= value))

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

272

273{-# INLINE takeEndBy_ #-}

274takeEndBy_ :: MonadCatch m

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

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

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

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

277

278{-# INLINE teeAllAny #-}

279teeAllAny :: MonadCatch m

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

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

281teeAllAny value =

282− IP.parse

282+ Stream.parse

283 (PR.teeWith (,)

284 (PR.dropWhile (<= value))

285 (PR.dropWhile (<= value))

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

287

288{-# INLINE teeFstAllAny #-}

289teeFstAllAny :: MonadCatch m

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

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

291teeFstAllAny value =

292− IP.parse

292+ Stream.parse

293 (PR.teeWithFst (,)

294 (PR.dropWhile (<= value))

295 (PR.dropWhile (<= value))

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

297

298{-# INLINE shortestAllAny #-}

299shortestAllAny :: MonadCatch m

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

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

301shortestAllAny value =

302− IP.parse

302+ Stream.parse

303 (PR.shortest

304 (PR.dropWhile (<= value))

305 (PR.dropWhile (<= value))

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

307

308{-# INLINE longestAllAny #-}

309longestAllAny :: MonadCatch m

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

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

311longestAllAny value =

312− IP.parse

312+ Stream.parse

313 (PR.longest

314 (PR.dropWhile (<= value))

315 (PR.dropWhile (<= value))

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

317

318parseManyChunksOfSum :: Int -> Handle -> IO Int

319parseManyChunksOfSum n inh =

320− S.length

320+ Stream.fold Fold.length

321− $ IP.parseMany

321+ $ Stream.parseMany

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

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

323− (S.unfold Handle.read inh)

323+ (Stream.unfold Handle.read inh)

324

325-------------------------------------------------------------------------------

326-- Parsing with unfolds

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

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

331parseManyUnfoldArrays count arrays = do

332 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)

334 let readSrc =

335 Source.producer

336 $ Producer.concat Producer.fromList Array.producer

337 let streamParser =

338 Producer.simplify (Source.parseMany parser readSrc)

339− S.drain $ S.unfold streamParser src

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

340

341-------------------------------------------------------------------------------

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

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

347-- not have to rely on it.

348--

349{-# INLINE lookAhead #-}

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

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

351lookAhead value =

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

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

353

354{-# INLINE sequenceA #-}

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

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

356sequenceA 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

358 return $ length x

359

360{-# INLINE sequenceA_ #-}

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

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

362sequenceA_ value =

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

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

364

365{-# INLINE sequence #-}

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

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

367sequence 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

369 return $ length x

370

371{-# INLINE sequence_ #-}

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

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

373sequence_ value =

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

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

375

376{-# INLINE choiceAsum #-}

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

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

378choiceAsum value =

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

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

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

381

382{-# INLINE choice #-}

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

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

384choice value =

385− IP.parse

385+ Stream.parse

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

387

388-------------------------------------------------------------------------------

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

390-------------------------------------------------------------------------------

391

392{-# INLINE parseMany #-}

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

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

394parseMany n =

395− S.drain

395+ Stream.fold Fold.drain

396− . S.map getSum

396+ . fmap getSum

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

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

398− . S.map Sum

398+ . fmap Sum

399

400{-# INLINE parseIterate #-}

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

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

402parseIterate n =

403− S.drain

403+ Stream.fold Fold.drain

404− . S.map getSum

404+ . fmap getSum

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

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

406− . S.map Sum

406+ . fmap Sum

407

408{-# INLINE parseBreak #-}

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

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

410parseBreak s = do

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

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

412 case r of

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

414 Right (_, s1) -> parseBreak s1

415

416{-# INLINE concatSequence #-}

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

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

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

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

419

420-------------------------------------------------------------------------------

421-- Benchmarks

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

464

465o_1_space_filesystem :: BenchEnv -> [Benchmark]

466o_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

468 $ \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

470 $ \inh _ -> inline parseManyChunksOfSum 1 inh

471 ]

472

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

514

515 where

516

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

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

518

519 allBenchmarks env arrays value =

520 [ 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)

19import Data.Foldable (asum)

20import Data.Functor (($>))

21import Data.Maybe (fromMaybe)

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

22import System.Random (randomRIO)

23import System.Random (randomRIO)

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

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

25import qualified Data.Traversable as TR

26import qualified Data.Traversable as TR

26import qualified Data.Foldable as F

27import qualified Data.Foldable as F

27import qualified Control.Applicative as AP

28import qualified Control.Applicative as AP

28−import qualified Streamly.Prelude as S

29import 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

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

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

33import 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)

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

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

37import Gauge

38import Gauge

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

39import Streamly.Benchmark.Common

41-------------------------------------------------------------------------------

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

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

47{-# INLINE sourceUnfoldrM #-}

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

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

49−sourceUnfoldrM value n = S.unfoldrM step n

49+sourceUnfoldrM value n = Stream.unfoldrM step n

50 where

51 step cnt =

52 if cnt > n + value

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

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

57{-# INLINE benchIOSink #-}

58benchIOSink

59− :: (IsStream t, NFData b)

59+ :: (NFData b)

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

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

61benchIOSink value name f =

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

64-- Make the input unsorted.

65{-# INLINE benchIOSinkRandom #-}

66benchIOSinkRandom

67− :: (IsStream t, NFData b)

67+ :: (NFData b)

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

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

69benchIOSinkRandom value name f =

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

71 >>= f

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

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

73 . sourceUnfoldrM value

75-------------------------------------------------------------------------------

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

79{-# INLINE drainWhile #-}

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

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

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

83{-# INLINE takeStartBy #-}

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

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

85takeStartBy value stream = do

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

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

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

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

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

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

90{-# INLINE takeWhile #-}

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

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

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

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

94{-# INLINE takeP #-}

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

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

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

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

98{-# INLINE takeBetween #-}

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

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

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

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

101

102{-# INLINE groupBy #-}

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

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

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

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

105

106{-# INLINE groupByRolling #-}

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

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

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

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

109

110{-# INLINE wordBy #-}

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

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

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

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

113

114{-# INLINE manyWordByEven #-}

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

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

116manyWordByEven =

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)

118

119{-# INLINE many #-}

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

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

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

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

122

123{-# INLINE manyAlt #-}

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

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

125manyAlt xs = do

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

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

127 return $ Prelude.length x

128

129{-# INLINE some #-}

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

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

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

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

132

133{-# INLINE someAlt #-}

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

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

135someAlt xs = do

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

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

137 return $ Prelude.length x

138

139{-#INLINE takeEndBy_ #-}

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

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

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

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

142

143{-# INLINE manyTill #-}

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

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

145manyTill value =

146 let p = PR.satisfy (> 0)

147 pcond = PR.satisfy (== value)

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

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

149

150{-# INLINE serialWith #-}

151serialWith :: MonadThrow m

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

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

153serialWith value =

154− IP.parseD

154+ Stream.parseD

155 ((,)

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

157 <*> drainWhile (<= value)

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

159

160{-# INLINE teeAllAny #-}

161teeAllAny :: MonadThrow m

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

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

163teeAllAny value =

164− IP.parseD

164+ Stream.parseD

165 (PR.teeWith (,)

166 (drainWhile (<= value))

167 (drainWhile (<= value))

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

169

170{-# INLINE teeFstAllAny #-}

171teeFstAllAny :: MonadThrow m

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

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

173teeFstAllAny value =

174− IP.parseD

174+ Stream.parseD

175 (PR.teeWithFst (,)

176 (drainWhile (<= value))

177 (drainWhile (<= value))

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

179

180{-# INLINE shortestAllAny #-}

181shortestAllAny :: MonadThrow m

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

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

183shortestAllAny value =

184− IP.parseD

184+ Stream.parseD

185 (PR.shortest

186 (drainWhile (<= value))

187 (drainWhile (<= value))

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

189

190{-# INLINE longestAllAny #-}

191longestAllAny :: MonadCatch m

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

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

193longestAllAny value =

194− IP.parseD

194+ Stream.parseD

195 (PR.longest

196 (drainWhile (<= value))

197 (drainWhile (<= value))

198 )

199

200{-# INLINE sequenceParser #-}

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

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

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

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

203

204-------------------------------------------------------------------------------

205-- Spanning

206-------------------------------------------------------------------------------

207

208{-# INLINE span #-}

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

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

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

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

211

212{-# INLINE spanBy #-}

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

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

214spanBy 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)

216

217{-# INLINE spanByRolling #-}

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

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

219spanByRolling 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)

221

222-------------------------------------------------------------------------------

223-- Nested

224-------------------------------------------------------------------------------

225

226{-# INLINE parseMany #-}

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

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

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

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

229

230{-# INLINE parseManyGroups #-}

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

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

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

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

233

234{-# INLINE parseManyGroupsRolling #-}

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

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

236parseManyGroupsRolling b =

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

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

238

239{-# INLINE parseManyGroupsRollingEither #-}

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

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

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

242parseManyGroupsRollingEither cmp =

243− IP.drain

243+ Stream.fold Fold.drain

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

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

245

246-------------------------------------------------------------------------------

247-- Parsing with unfolds

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

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

252parseManyUnfoldArrays count arrays = do

253 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)

255 let readSrc =

256 Source.producer

257 $ Producer.concat Producer.fromList Array.producer

258 let streamParser =

259 Producer.simplify (Source.parseManyD parser readSrc)

260− S.drain $ S.unfold streamParser src

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

261

262-------------------------------------------------------------------------------

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

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

268-- not have to rely on it.

269--

270{-# INLINE lookAhead #-}

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

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

272lookAhead value =

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

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

274

275{-# INLINE sequenceA_ #-}

276−sequenceA_ :: MonadThrow m => Int -> SerialT m Int -> m ()

276+sequenceA_ :: MonadThrow m => Int -> Stream m Int -> m ()

277sequenceA_ value =

278− IP.parseD (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

278+ Stream.parseD (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

279

280-- quadratic complexity

281{-# INLINE sequenceA #-}

282−sequenceA :: MonadThrow m => Int -> SerialT m Int -> m Int

282+sequenceA :: MonadThrow m => Int -> Stream m Int -> m Int

283sequenceA 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

285 return $ length x

286

287-- quadratic complexity

288{-# INLINE sequence #-}

289−sequence :: MonadThrow m => Int -> SerialT m Int -> m Int

289+sequence :: MonadThrow m => Int -> Stream m Int -> m Int

290sequence 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

292 return $ length x

293

294{-# INLINE sequence_ #-}

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

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

296sequence_ 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

298

299 where

300

@@ -305,15 +305,15 @@ sequence_ value xs =

305-- quadratic performance complexity.

306--

307{-# INLINE choiceAsum #-}

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

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

309choiceAsum value =

310− IP.parseD (asum (replicate value (PR.satisfy (< 0)))

310+ Stream.parseD (asum (replicate value (PR.satisfy (< 0)))

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

312

313{-# INLINE choice #-}

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

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

315choice value =

316− IP.parseD

316+ Stream.parseD

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

318

319-------------------------------------------------------------------------------

@@ -410,7 +410,7 @@ main = runWithCLIOptsEnv defaultStreamSize alloc allBenchmarks

410

411 where

412

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

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

414

415 allBenchmarks arraysSmall value =

416 [ 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

16import Control.DeepSeq (NFData(..))

17import Control.Monad.Catch (MonadCatch)

18import Data.Foldable (asum)

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

19import System.Random (randomRIO)

20import System.Random (randomRIO)

20import Prelude hiding (any, all, take, sequence, sequenceA, takeWhile)

21import Prelude hiding (any, all, take, sequence, sequenceA, takeWhile)

22import qualified Control.Applicative as AP

23import qualified Control.Applicative as AP

23import qualified Data.Foldable as F

24import qualified Data.Foldable as F

24import qualified Data.Traversable as TR

25import qualified Data.Traversable as TR

25−import qualified Streamly.Prelude as S

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

27import qualified Streamly.Internal.Data.Parser.ParserK.Type as PR

28import 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

31import Gauge

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

33import Streamly.Benchmark.Common

32import Streamly.Benchmark.Common

35-------------------------------------------------------------------------------

34-------------------------------------------------------------------------------

@@ -39,8 +38,8 @@ import Streamly.Benchmark.Common

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

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

41{-# INLINE sourceUnfoldrM #-}

40{-# INLINE sourceUnfoldrM #-}

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

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

43−sourceUnfoldrM value n = S.unfoldrM step n

42+sourceUnfoldrM value n = Stream.unfoldrM step n

44 where

43 where

45 step cnt =

44 step cnt =

46 if cnt > n + value

45 if cnt > n + value

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

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

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

51{-# INLINE benchIOSink #-}

50{-# INLINE benchIOSink #-}

52benchIOSink

51benchIOSink

53− :: (IsStream t, NFData b)

52+ :: NFData b

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

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

55benchIOSink value name f =

54benchIOSink value name f =

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

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

@@ -60,9 +59,9 @@ benchIOSink value name f =

60-------------------------------------------------------------------------------

59-------------------------------------------------------------------------------

62#ifdef FROM_PARSERK

61#ifdef FROM_PARSERK

63−#define PARSE_OP (IP.parseD . PRD.fromParserK)

62+#define PARSE_OP (Stream.parseD . PRD.fromParserK)

64#else

63#else

65−#define PARSE_OP IP.parseK

64+#define PARSE_OP Stream.parseK

66#endif

65#endif

68{-# INLINE satisfy #-}

67{-# INLINE satisfy #-}

@@ -74,17 +73,17 @@ takeWhile :: MonadCatch m => (a -> Bool) -> PR.Parser m a ()

74takeWhile p = PRD.toParserK $ PRD.takeWhile p FL.drain

73takeWhile p = PRD.toParserK $ PRD.takeWhile p FL.drain

76{-# INLINE takeWhileK #-}

75{-# INLINE takeWhileK #-}

77−takeWhileK :: MonadCatch m => Int -> SerialT m Int -> m ()

76+takeWhileK :: MonadCatch m => Int -> Stream m Int -> m ()

78takeWhileK value = PARSE_OP (takeWhile (<= value))

77takeWhileK value = PARSE_OP (takeWhile (<= value))

80{-# INLINE splitApp #-}

79{-# INLINE splitApp #-}

81splitApp :: MonadCatch m

80splitApp :: MonadCatch m

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

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

83splitApp value =

82splitApp value =

84 PARSE_OP ((,) <$> takeWhile (<= (value `div` 2)) <*> takeWhile (<= value))

83 PARSE_OP ((,) <$> takeWhile (<= (value `div` 2)) <*> takeWhile (<= value))

86{-# INLINE sequenceA #-}

85{-# INLINE sequenceA #-}

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

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

88sequenceA value xs = do

87sequenceA value xs = do

89 let parser = satisfy (> 0)

88 let parser = satisfy (> 0)

90 list = Prelude.replicate value parser

89 list = Prelude.replicate value parser

@@ -92,14 +91,14 @@ sequenceA value xs = do

92 return $ Prelude.length x

91 return $ Prelude.length x

94{-# INLINE sequenceA_ #-}

93{-# INLINE sequenceA_ #-}

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

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

96sequenceA_ value xs = do

95sequenceA_ value xs = do

97 let parser = satisfy (> 0)

96 let parser = satisfy (> 0)

98 list = Prelude.replicate value parser

97 list = Prelude.replicate value parser

99 PARSE_OP (F.sequenceA_ list) xs

98 PARSE_OP (F.sequenceA_ list) xs

100

101{-# INLINE sequence #-}

100{-# INLINE sequence #-}

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

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

103sequence value xs = do

102sequence value xs = do

104 let parser = satisfy (> 0)

103 let parser = satisfy (> 0)

105 list = Prelude.replicate value parser

104 list = Prelude.replicate value parser

@@ -107,19 +106,19 @@ sequence value xs = do

107 return $ Prelude.length x

106 return $ Prelude.length x

108

107

109{-# INLINE manyAlt #-}

108{-# INLINE manyAlt #-}

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

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

111manyAlt xs = do

110manyAlt xs = do

112 x <- PARSE_OP (AP.many (satisfy (> 0))) xs

111 x <- PARSE_OP (AP.many (satisfy (> 0))) xs

113 return $ Prelude.length x

112 return $ Prelude.length x

114

113

115{-# INLINE someAlt #-}

114{-# INLINE someAlt #-}

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

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

117someAlt xs = do

116someAlt xs = do

118 x <- PARSE_OP (AP.some (satisfy (> 0))) xs

117 x <- PARSE_OP (AP.some (satisfy (> 0))) xs

119 return $ Prelude.length x

118 return $ Prelude.length x

120

119

121{-# INLINE choice #-}

120{-# INLINE choice #-}

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

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

123choice value =

122choice value =

124 PARSE_OP (asum (replicate value (satisfy (< 0)))

123 PARSE_OP (asum (replicate value (satisfy (< 0)))

125 AP.<|> satisfy (> 0))

124 AP.<|> satisfy (> 0))

benchmark/Streamly/Benchmark/Data/Stream/Eliminate.hs+73−74

@@ -41,8 +41,7 @@ import qualified Streamly.Internal.Data.Stream as S

41#endif

43import Gauge

44−-- XXX Replace SerialT with Stream

45−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

46#ifdef USE_PRELUDE

45#ifdef USE_PRELUDE

47import Streamly.Prelude (fromSerial)

46import Streamly.Prelude (fromSerial)

48import Streamly.Benchmark.Prelude

47import Streamly.Benchmark.Prelude

@@ -76,90 +75,90 @@ repeat count = S.take count . S.repeat

76{-# INLINE foldableFoldl' #-}

75{-# INLINE foldableFoldl' #-}

77foldableFoldl' :: Int -> Int -> Int

76foldableFoldl' :: Int -> Int -> Int

78foldableFoldl' value n =

77foldableFoldl' value n =

79− F.foldl' (+) 0 (sourceUnfoldr value n :: SerialT Identity Int)

78+ F.foldl' (+) 0 (sourceUnfoldr value n :: Stream Identity Int)

81{-# INLINE foldableFoldrElem #-}

80{-# INLINE foldableFoldrElem #-}

82foldableFoldrElem :: Int -> Int -> Bool

81foldableFoldrElem :: Int -> Int -> Bool

83foldableFoldrElem value n =

82foldableFoldrElem value n =

84 F.foldr (\x xs -> x == value || xs)

83 F.foldr (\x xs -> x == value || xs)

85 False

84 False

86− (sourceUnfoldr value n :: SerialT Identity Int)

85+ (sourceUnfoldr value n :: Stream Identity Int)

88{-# INLINE foldableSum #-}

87{-# INLINE foldableSum #-}

89foldableSum :: Int -> Int -> Int

88foldableSum :: Int -> Int -> Int

90foldableSum value n =

89foldableSum value n =

91− Prelude.sum (sourceUnfoldr value n :: SerialT Identity Int)

90+ Prelude.sum (sourceUnfoldr value n :: Stream Identity Int)

93{-# INLINE foldableProduct #-}

92{-# INLINE foldableProduct #-}

94foldableProduct :: Int -> Int -> Int

93foldableProduct :: Int -> Int -> Int

95foldableProduct value n =

94foldableProduct value n =

96− Prelude.product (sourceUnfoldr value n :: SerialT Identity Int)

95+ Prelude.product (sourceUnfoldr value n :: Stream Identity Int)

98{-# INLINE _foldableNull #-}

97{-# INLINE _foldableNull #-}

99_foldableNull :: Int -> Int -> Bool

98_foldableNull :: Int -> Int -> Bool

100_foldableNull value n =

99_foldableNull value n =

101− Prelude.null (sourceUnfoldr value n :: SerialT Identity Int)

100+ Prelude.null (sourceUnfoldr value n :: Stream Identity Int)

102

101

103{-# INLINE foldableElem #-}

102{-# INLINE foldableElem #-}

104foldableElem :: Int -> Int -> Bool

103foldableElem :: Int -> Int -> Bool

105foldableElem value n =

104foldableElem value n =

106− value `Prelude.elem` (sourceUnfoldr value n :: SerialT Identity Int)

105+ value `Prelude.elem` (sourceUnfoldr value n :: Stream Identity Int)

107

106

108{-# INLINE foldableNotElem #-}

107{-# INLINE foldableNotElem #-}

109foldableNotElem :: Int -> Int -> Bool

108foldableNotElem :: Int -> Int -> Bool

110foldableNotElem value n =

109foldableNotElem value n =

111− value `Prelude.notElem` (sourceUnfoldr value n :: SerialT Identity Int)

110+ value `Prelude.notElem` (sourceUnfoldr value n :: Stream Identity Int)

112

111

113{-# INLINE foldableFind #-}

112{-# INLINE foldableFind #-}

114foldableFind :: Int -> Int -> Maybe Int

113foldableFind :: Int -> Int -> Maybe Int

115foldableFind value n =

114foldableFind value n =

116− F.find (== (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

115+ F.find (== (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

117

116

118{-# INLINE foldableAll #-}

117{-# INLINE foldableAll #-}

119foldableAll :: Int -> Int -> Bool

118foldableAll :: Int -> Int -> Bool

120foldableAll value n =

119foldableAll value n =

121− Prelude.all (<= (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

120+ Prelude.all (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

122

121

123{-# INLINE foldableAny #-}

122{-# INLINE foldableAny #-}

124foldableAny :: Int -> Int -> Bool

123foldableAny :: Int -> Int -> Bool

125foldableAny value n =

124foldableAny value n =

126− Prelude.any (> (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

125+ Prelude.any (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

127

126

128{-# INLINE foldableAnd #-}

127{-# INLINE foldableAnd #-}

129foldableAnd :: Int -> Int -> Bool

128foldableAnd :: Int -> Int -> Bool

130foldableAnd value n =

129foldableAnd value n =

131 Prelude.and $ fmap

130 Prelude.and $ fmap

132− (<= (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

131+ (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

133

132

134{-# INLINE foldableOr #-}

133{-# INLINE foldableOr #-}

135foldableOr :: Int -> Int -> Bool

134foldableOr :: Int -> Int -> Bool

136foldableOr value n =

135foldableOr value n =

137 Prelude.or $ fmap

136 Prelude.or $ fmap

138− (> (value + 1)) (sourceUnfoldr value n :: SerialT Identity Int)

137+ (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

139

138

140{-# INLINE foldableLength #-}

139{-# INLINE foldableLength #-}

141foldableLength :: Int -> Int -> Int

140foldableLength :: Int -> Int -> Int

142foldableLength value n =

141foldableLength value n =

143− Prelude.length (sourceUnfoldr value n :: SerialT Identity Int)

142+ Prelude.length (sourceUnfoldr value n :: Stream Identity Int)

144

143

145{-# INLINE foldableMin #-}

144{-# INLINE foldableMin #-}

146foldableMin :: Int -> Int -> Int

145foldableMin :: Int -> Int -> Int

147foldableMin value n =

146foldableMin value n =

148− Prelude.minimum (sourceUnfoldr value n :: SerialT Identity Int)

147+ Prelude.minimum (sourceUnfoldr value n :: Stream Identity Int)

149

148

150{-# INLINE ordInstanceMin #-}

149{-# INLINE ordInstanceMin #-}

151−ordInstanceMin :: SerialT Identity Int -> SerialT Identity Int

150+ordInstanceMin :: Stream Identity Int -> Stream Identity Int

152ordInstanceMin src = min src src

151ordInstanceMin src = min src src

153

152

154{-# INLINE foldableMax #-}

153{-# INLINE foldableMax #-}

155foldableMax :: Int -> Int -> Int

154foldableMax :: Int -> Int -> Int

156foldableMax value n =

155foldableMax value n =

157− Prelude.maximum (sourceUnfoldr value n :: SerialT Identity Int)

156+ Prelude.maximum (sourceUnfoldr value n :: Stream Identity Int)

158

157

159{-# INLINE foldableMinBy #-}

158{-# INLINE foldableMinBy #-}

160foldableMinBy :: Int -> Int -> Int

159foldableMinBy :: Int -> Int -> Int

161foldableMinBy value n =

160foldableMinBy value n =

162− F.minimumBy compare (sourceUnfoldr value n :: SerialT Identity Int)

161+ F.minimumBy compare (sourceUnfoldr value n :: Stream Identity Int)

163

162

164{-# INLINE foldableListMinBy #-}

163{-# INLINE foldableListMinBy #-}

165foldableListMinBy :: Int -> Int -> Int

164foldableListMinBy :: Int -> Int -> Int

@@ -168,30 +167,30 @@ foldableListMinBy value n = F.minimumBy compare [1..value+n]

168{-# INLINE foldableMaxBy #-}

167{-# INLINE foldableMaxBy #-}

169foldableMaxBy :: Int -> Int -> Int

168foldableMaxBy :: Int -> Int -> Int

170foldableMaxBy value n =

169foldableMaxBy value n =

171− F.maximumBy compare (sourceUnfoldr value n :: SerialT Identity Int)

170+ F.maximumBy compare (sourceUnfoldr value n :: Stream Identity Int)

172

171

173{-# INLINE foldableToList #-}

172{-# INLINE foldableToList #-}

174foldableToList :: Int -> Int -> [Int]

173foldableToList :: Int -> Int -> [Int]

175foldableToList value n =

174foldableToList value n =

176− F.toList (sourceUnfoldr value n :: SerialT Identity Int)

175+ F.toList (sourceUnfoldr value n :: Stream Identity Int)

177

176

178{-# INLINE foldableMapM_ #-}

177{-# INLINE foldableMapM_ #-}

179foldableMapM_ :: Monad m => Int -> Int -> m ()

178foldableMapM_ :: Monad m => Int -> Int -> m ()

180foldableMapM_ value n =

179foldableMapM_ value n =

181− F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: SerialT Identity Int)

180+ F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: Stream Identity Int)

182

181

183{-# INLINE foldableSequence_ #-}

182{-# INLINE foldableSequence_ #-}

184foldableSequence_ :: Int -> Int -> IO ()

183foldableSequence_ :: Int -> Int -> IO ()

185foldableSequence_ value n =

184foldableSequence_ value n =

186− F.sequence_ (sourceUnfoldrAction value n :: SerialT Identity (IO Int))

185+ F.sequence_ (sourceUnfoldrAction value n :: Stream Identity (IO Int))

187

186

188{-# INLINE _foldableMsum #-}

187{-# INLINE _foldableMsum #-}

189_foldableMsum :: Int -> Int -> IO Int

188_foldableMsum :: Int -> Int -> IO Int

190_foldableMsum value n =

189_foldableMsum value n =

191− F.msum (sourceUnfoldrAction value n :: SerialT Identity (IO Int))

190+ F.msum (sourceUnfoldrAction value n :: Stream Identity (IO Int))

192

191

193{-# INLINE showInstance #-}

192{-# INLINE showInstance #-}

194−showInstance :: SerialT Identity Int -> String

193+showInstance :: Stream Identity Int -> String

195showInstance = show

194showInstance = show

196

195

197o_1_space_elimination_foldable :: Int -> [Benchmark]

196o_1_space_elimination_foldable :: Int -> [Benchmark]

@@ -251,13 +250,13 @@ o_n_space_elimination_foldable value =

251

250

252{-# INLINE benchPureSink #-}

251{-# INLINE benchPureSink #-}

253benchPureSink :: NFData b

252benchPureSink :: NFData b

254− => Int -> String -> (SerialT Identity Int -> b) -> Benchmark

253+ => Int -> String -> (Stream Identity Int -> b) -> Benchmark

255benchPureSink value name = benchPure name (sourceUnfoldr value)

254benchPureSink value name = benchPure name (sourceUnfoldr value)

256

255

257{-# INLINE benchHoistSink #-}

256{-# INLINE benchHoistSink #-}

258benchHoistSink

257benchHoistSink

259 :: (NFData b)

258 :: (NFData b)

260− => Int -> String -> (SerialT Identity Int -> IO b) -> Benchmark

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

261benchHoistSink value name f =

260benchHoistSink value name f =

262 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

261 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

263

262

@@ -266,7 +265,7 @@ benchHoistSink value name f =

266{-# INLINE benchIdentitySink #-}

265{-# INLINE benchIdentitySink #-}

267benchIdentitySink

266benchIdentitySink

268 :: (NFData b)

267 :: (NFData b)

269− => Int -> String -> (SerialT Identity Int -> Identity b) -> Benchmark

268+ => Int -> String -> (Stream Identity Int -> Identity b) -> Benchmark

270benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

269benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

271

270

272-------------------------------------------------------------------------------

271-------------------------------------------------------------------------------

@@ -274,7 +273,7 @@ benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

274-------------------------------------------------------------------------------

273-------------------------------------------------------------------------------

275

274

276{-# INLINE uncons #-}

275{-# INLINE uncons #-}

277−uncons :: Monad m => SerialT m Int -> m ()

276+uncons :: Monad m => Stream m Int -> m ()

278uncons s = do

277uncons s = do

279 r <- S.uncons s

278 r <- S.uncons s

280 case r of

279 case r of

@@ -283,16 +282,16 @@ uncons s = do

283

282

284#ifdef USE_PRELUDE

283#ifdef USE_PRELUDE

285{-# INLINE init #-}

284{-# INLINE init #-}

286−init :: Monad m => SerialT m a -> m ()

285+init :: Monad m => Stream m a -> m ()

287init s = S.init s >>= Prelude.mapM_ S.drain

286init s = S.init s >>= Prelude.mapM_ S.drain

288

287

289{-# INLINE mapM_ #-}

288{-# INLINE mapM_ #-}

290−mapM_ :: Monad m => SerialT m Int -> m ()

289+mapM_ :: Monad m => Stream m Int -> m ()

291mapM_ = S.mapM_ (\_ -> return ())

290mapM_ = S.mapM_ (\_ -> return ())

292#endif

291#endif

293

292

294{-# INLINE foldrMElem #-}

293{-# INLINE foldrMElem #-}

295−foldrMElem :: Monad m => Int -> SerialT m Int -> m Bool

294+foldrMElem :: Monad m => Int -> Stream m Int -> m Bool

296foldrMElem e =

295foldrMElem e =

297 S.foldrM

296 S.foldrM

298 (\x xs ->

297 (\x xs ->

@@ -302,120 +301,120 @@ foldrMElem e =

302 (return False)

301 (return False)

303

302

304{-# INLINE foldrToStream #-}

303{-# INLINE foldrToStream #-}

305−foldrToStream :: Monad m => SerialT m Int -> m (SerialT Identity Int)

304+foldrToStream :: Monad m => Stream m Int -> m (Stream Identity Int)

306foldrToStream = S.foldr S.cons S.nil

305foldrToStream = S.foldr S.cons S.nil

307

306

308{-# INLINE foldrMBuild #-}

307{-# INLINE foldrMBuild #-}

309−foldrMBuild :: Monad m => SerialT m Int -> m [Int]

308+foldrMBuild :: Monad m => Stream m Int -> m [Int]

310foldrMBuild = S.foldrM (\x xs -> (x :) <$> xs) (return [])

309foldrMBuild = S.foldrM (\x xs -> (x :) <$> xs) (return [])

311

310

312#ifdef USE_PRELUDE

311#ifdef USE_PRELUDE

313{-# INLINE foldl'Reduce #-}

312{-# INLINE foldl'Reduce #-}

314−foldl'Reduce :: Monad m => SerialT m Int -> m Int

313+foldl'Reduce :: Monad m => Stream m Int -> m Int

315foldl'Reduce = S.foldl' (+) 0

314foldl'Reduce = S.foldl' (+) 0

316

315

317{-# INLINE foldl1'Reduce #-}

316{-# 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)

319foldl1'Reduce = S.foldl1' (+)

318foldl1'Reduce = S.foldl1' (+)

320

319

321{-# INLINE foldlM'Reduce #-}

320{-# INLINE foldlM'Reduce #-}

322−foldlM'Reduce :: Monad m => SerialT m Int -> m Int

321+foldlM'Reduce :: Monad m => Stream m Int -> m Int

323foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) (return 0)

322foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) (return 0)

324

323

325{-# INLINE last #-}

324{-# INLINE last #-}

326−last :: Monad m => SerialT m Int -> m (Maybe Int)

325+last :: Monad m => Stream m Int -> m (Maybe Int)

327last = S.last

326last = S.last

328

327

329{-# INLINE _head #-}

328{-# INLINE _head #-}

330−_head :: Monad m => SerialT m Int -> m (Maybe Int)

329+_head :: Monad m => Stream m Int -> m (Maybe Int)

331_head = S.head

330_head = S.head

332

331

333{-# INLINE elem #-}

332{-# INLINE elem #-}

334−elem :: Monad m => Int -> SerialT m Int -> m Bool

333+elem :: Monad m => Int -> Stream m Int -> m Bool

335elem value = S.elem (value + 1)

334elem value = S.elem (value + 1)

336

335

337{-# INLINE notElem #-}

336{-# INLINE notElem #-}

338−notElem :: Monad m => Int -> SerialT m Int -> m Bool

337+notElem :: Monad m => Int -> Stream m Int -> m Bool

339notElem value = S.notElem (value + 1)

338notElem value = S.notElem (value + 1)

340

339

341{-# INLINE length #-}

340{-# INLINE length #-}

342−length :: Monad m => SerialT m Int -> m Int

341+length :: Monad m => Stream m Int -> m Int

343length = S.length

342length = S.length

344

343

345{-# INLINE all #-}

344{-# INLINE all #-}

346−all :: Monad m => Int -> SerialT m Int -> m Bool

345+all :: Monad m => Int -> Stream m Int -> m Bool

347all value = S.all (<= (value + 1))

346all value = S.all (<= (value + 1))

348

347

349{-# INLINE any #-}

348{-# INLINE any #-}

350−any :: Monad m => Int -> SerialT m Int -> m Bool

349+any :: Monad m => Int -> Stream m Int -> m Bool

351any value = S.any (> (value + 1))

350any value = S.any (> (value + 1))

352

351

353{-# INLINE and #-}

352{-# INLINE and #-}

354−and :: Monad m => Int -> SerialT m Int -> m Bool

353+and :: Monad m => Int -> Stream m Int -> m Bool

355and value = S.and . S.map (<= (value + 1))

354and value = S.and . S.map (<= (value + 1))

356

355

357{-# INLINE or #-}

356{-# INLINE or #-}

358−or :: Monad m => Int -> SerialT m Int -> m Bool

357+or :: Monad m => Int -> Stream m Int -> m Bool

359or value = S.or . S.map (> (value + 1))

358or value = S.or . S.map (> (value + 1))

360

359

361{-# INLINE find #-}

360{-# INLINE find #-}

362−find :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

361+find :: Monad m => Int -> Stream m Int -> m (Maybe Int)

363find value = S.find (== (value + 1))

362find value = S.find (== (value + 1))

364

363

365{-# INLINE findM #-}

364{-# INLINE findM #-}

366−findM :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

365+findM :: Monad m => Int -> Stream m Int -> m (Maybe Int)

367findM value = S.findM (\z -> return $ z == (value + 1))

366findM value = S.findM (\z -> return $ z == (value + 1))

368

367

369{-# INLINE findIndex #-}

368{-# INLINE findIndex #-}

370−findIndex :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

369+findIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)

371findIndex value = S.findIndex (== (value + 1))

370findIndex value = S.findIndex (== (value + 1))

372

371

373{-# INLINE elemIndex #-}

372{-# INLINE elemIndex #-}

374−elemIndex :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

373+elemIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)

375elemIndex value = S.elemIndex (value + 1)

374elemIndex value = S.elemIndex (value + 1)

376

375

377{-# INLINE maximum #-}

376{-# INLINE maximum #-}

378−maximum :: Monad m => SerialT m Int -> m (Maybe Int)

377+maximum :: Monad m => Stream m Int -> m (Maybe Int)

379maximum = S.maximum

378maximum = S.maximum

380

379

381{-# INLINE minimum #-}

380{-# INLINE minimum #-}

382−minimum :: Monad m => SerialT m Int -> m (Maybe Int)

381+minimum :: Monad m => Stream m Int -> m (Maybe Int)

383minimum = S.minimum

382minimum = S.minimum

384

383

385{-# INLINE sum #-}

384{-# INLINE sum #-}

386−sum :: Monad m => SerialT m Int -> m Int

385+sum :: Monad m => Stream m Int -> m Int

387sum = S.sum

386sum = S.sum

388

387

389{-# INLINE product #-}

388{-# INLINE product #-}

390−product :: Monad m => SerialT m Int -> m Int

389+product :: Monad m => Stream m Int -> m Int

391product = S.product

390product = S.product

392

391

393{-# INLINE minimumBy #-}

392{-# INLINE minimumBy #-}

394−minimumBy :: Monad m => SerialT m Int -> m (Maybe Int)

393+minimumBy :: Monad m => Stream m Int -> m (Maybe Int)

395minimumBy = S.minimumBy compare

394minimumBy = S.minimumBy compare

396

395

397{-# INLINE maximumBy #-}

396{-# INLINE maximumBy #-}

398−maximumBy :: Monad m => SerialT m Int -> m (Maybe Int)

397+maximumBy :: Monad m => Stream m Int -> m (Maybe Int)

399maximumBy = S.maximumBy compare

398maximumBy = S.maximumBy compare

400

399

401{-# INLINE the #-}

400{-# INLINE the #-}

402−the :: Monad m => SerialT m Int -> m (Maybe Int)

401+the :: Monad m => Stream m Int -> m (Maybe Int)

403the = S.the

402the = S.the

404

403

405{-# INLINE drainN #-}

404{-# INLINE drainN #-}

406−drainN :: Monad m => Int -> SerialT m Int -> m ()

405+drainN :: Monad m => Int -> Stream m Int -> m ()

407drainN = S.drainN

406drainN = S.drainN

408

407

409{-# INLINE drainWhile #-}

408{-# INLINE drainWhile #-}

410−drainWhile :: Monad m => SerialT m Int -> m ()

409+drainWhile :: Monad m => Stream m Int -> m ()

411drainWhile = S.drainWhile (const True)

410drainWhile = S.drainWhile (const True)

412

411

413{-# INLINE (!!) #-}

412{-# INLINE (!!) #-}

414−(!!) :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

413+(!!) :: Monad m => Int -> Stream m Int -> m (Maybe Int)

415(!!) = flip (S.!!)

414(!!) = flip (S.!!)

416

415

417{-# INLINE lookup #-}

416{-# INLINE lookup #-}

418−lookup :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

417+lookup :: Monad m => Int -> Stream m Int -> m (Maybe Int)

419lookup val = S.lookup val . S.map (\x -> (x, x))

418lookup val = S.lookup val . S.map (\x -> (x, x))

420#endif

419#endif

421

420

@@ -508,11 +507,11 @@ o_1_space_elimination_folds value =

508

507

509#ifdef USE_PRELUDE

508#ifdef USE_PRELUDE

510{-# INLINE foldl'Build #-}

509{-# INLINE foldl'Build #-}

511−foldl'Build :: Monad m => SerialT m Int -> m [Int]

510+foldl'Build :: Monad m => Stream m Int -> m [Int]

512foldl'Build = S.foldl' (flip (:)) []

511foldl'Build = S.foldl' (flip (:)) []

513

512

514{-# INLINE foldlM'Build #-}

513{-# INLINE foldlM'Build #-}

515−foldlM'Build :: Monad m => SerialT m Int -> m [Int]

514+foldlM'Build :: Monad m => Stream m Int -> m [Int]

516foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) (return [])

515foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) (return [])

517

516

518o_n_heap_elimination_foldl :: Int -> [Benchmark]

517o_n_heap_elimination_foldl :: Int -> [Benchmark]

@@ -546,7 +545,7 @@ o_n_heap_elimination_buffered value =

546 ]

545 ]

547

546

548{-# INLINE foldrMReduce #-}

547{-# INLINE foldrMReduce #-}

549−foldrMReduce :: Monad m => SerialT m Int -> m Int

548+foldrMReduce :: Monad m => Stream m Int -> m Int

550foldrMReduce = S.foldrM (\x xs -> (x +) <$> xs) (return 0)

549foldrMReduce = S.foldrM (\x xs -> (x +) <$> xs) (return 0)

551

550

552o_n_space_elimination_foldr :: Int -> [Benchmark]

551o_n_space_elimination_foldr :: Int -> [Benchmark]

@@ -569,7 +568,7 @@ o_n_heap_elimination_toList value =

569 -- Converting the stream to a list or pure stream in a strict monad

568 -- Converting the stream to a list or pure stream in a strict monad

570 [ benchIOSink value "toListRev" S.toListRev

569 [ benchIOSink value "toListRev" S.toListRev

571 , benchIOSink value "toStreamRev"

570 , benchIOSink value "toStreamRev"

572− (S.toStreamRev :: (SerialT IO Int -> IO (SerialT Identity Int)))

571+ (S.toStreamRev :: (Stream IO Int -> IO (Stream Identity Int)))

573 ]

572 ]

574 ]

573 ]

575

574

@@ -579,7 +578,7 @@ o_n_space_elimination_toList value =

579 -- Converting the stream to a list or pure stream in a strict monad

578 -- Converting the stream to a list or pure stream in a strict monad

580 [ benchIOSink value "toList" S.toList

579 [ benchIOSink value "toList" S.toList

581 , benchIOSink value "toStream"

580 , benchIOSink value "toStream"

582− (S.toStream :: (SerialT IO Int -> IO (SerialT Identity Int)))

581+ (S.toStream :: (Stream IO Int -> IO (Stream Identity Int)))

583 ]

582 ]

584 ]

583 ]

585#endif

584#endif

@@ -593,7 +592,7 @@ o_n_space_elimination_toList value =

593-------------------------------------------------------------------------------

592-------------------------------------------------------------------------------

594

593

595{-# INLINE eqBy' #-}

594{-# INLINE eqBy' #-}

596−eqBy' :: (Monad m, Eq a) => SerialT m a -> m Bool

595+eqBy' :: (Monad m, Eq a) => Stream m a -> m Bool

597eqBy' src = S.eqBy (==) src src

596eqBy' src = S.eqBy (==) src src

598

597

599{-# INLINE eqByPure #-}

598{-# INLINE eqByPure #-}

@@ -607,15 +606,15 @@ inspect $ 'eqByPure `hasNoType` ''D.Step

607#endif

606#endif

608

607

609{-# INLINE eqInstance #-}

608{-# INLINE eqInstance #-}

610−eqInstance :: SerialT Identity Int -> Bool

609+eqInstance :: Stream Identity Int -> Bool

611eqInstance src = src == src

610eqInstance src = src == src

612

611

613{-# INLINE eqInstanceNotEq #-}

612{-# INLINE eqInstanceNotEq #-}

614−eqInstanceNotEq :: SerialT Identity Int -> Bool

613+eqInstanceNotEq :: Stream Identity Int -> Bool

615eqInstanceNotEq src = src /= src

614eqInstanceNotEq src = src /= src

616

615

617{-# INLINE cmpBy' #-}

616{-# INLINE cmpBy' #-}

618−cmpBy' :: (Monad m, Ord a) => SerialT m a -> m Ordering

617+cmpBy' :: (Monad m, Ord a) => Stream m a -> m Ordering

619cmpBy' src = S.cmpBy compare src src

618cmpBy' src = S.cmpBy compare src src

620

619

621{-# INLINE cmpByPure #-}

620{-# INLINE cmpByPure #-}

@@ -629,7 +628,7 @@ inspect $ 'cmpByPure `hasNoType` ''D.Step

629#endif

628#endif

630

629

631{-# INLINE ordInstance #-}

630{-# INLINE ordInstance #-}

632−ordInstance :: SerialT Identity Int -> Bool

631+ordInstance :: Stream Identity Int -> Bool

633ordInstance src = src < src

632ordInstance src = src < src

634

633

635o_1_space_elimination_multi_stream_pure :: Int -> [Benchmark]

634o_1_space_elimination_multi_stream_pure :: Int -> [Benchmark]

@@ -644,15 +643,15 @@ o_1_space_elimination_multi_stream_pure value =

644 ]

643 ]

645

644

646{-# INLINE isPrefixOf #-}

645{-# INLINE isPrefixOf #-}

647−isPrefixOf :: Monad m => SerialT m Int -> m Bool

646+isPrefixOf :: Monad m => Stream m Int -> m Bool

648isPrefixOf src = S.isPrefixOf src src

647isPrefixOf src = S.isPrefixOf src src

649

648

650{-# INLINE isSubsequenceOf #-}

649{-# INLINE isSubsequenceOf #-}

651−isSubsequenceOf :: Monad m => SerialT m Int -> m Bool

650+isSubsequenceOf :: Monad m => Stream m Int -> m Bool

652isSubsequenceOf src = S.isSubsequenceOf src src

651isSubsequenceOf src = S.isSubsequenceOf src src

653

652

654{-# INLINE stripPrefix #-}

653{-# INLINE stripPrefix #-}

655−stripPrefix :: Monad m => SerialT m Int -> m ()

654+stripPrefix :: Monad m => Stream m Int -> m ()

656stripPrefix src = do

655stripPrefix src = do

657 _ <- S.stripPrefix src src

656 _ <- S.stripPrefix src src

658 return ()

657 return ()

benchmark/Streamly/Benchmark/Data/Stream/Exceptions.hs+2−2

@@ -23,7 +23,7 @@ module Stream.Exceptions (benchmarks) where

24import Control.Exception (SomeException, Exception, throwIO)

25import Stream.Common (drain)

26−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

27import System.IO (Handle, hClose, hPutChar)

29import qualified Data.IORef as Ref

@@ -54,7 +54,7 @@ import qualified Streamly.Internal.Data.Stream.StreamD as D

54-------------------------------------------------------------------------------

56{-# INLINE replicateM #-}

57−replicateM :: Common.MonadAsync m => Int -> m a -> SerialT m a

57+replicateM :: Common.MonadAsync m => Int -> m a -> Stream m a

58#ifdef USE_PRELUDE

59replicateM = Stream.replicateM

60#else

benchmark/Streamly/Benchmark/Data/Stream/Expand.hs+8−8

@@ -21,7 +21,7 @@

21module Stream.Expand (benchmarks) where

23import Control.Monad.Trans.Class (lift)

24−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

26import qualified Control.Applicative as AP

@@ -66,10 +66,10 @@ iterateN g initial count = f count initial

66-- Iterate a transformation over a singleton stream

67{-# INLINE iterateSingleton #-}

68iterateSingleton :: Monad m

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

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

70 -> Int

71 -> Int

72− -> SerialT m Int

72+ -> Stream m Int

73iterateSingleton g count n = iterateN g (return n) count

75{-

@@ -81,10 +81,10 @@ iterateSingleton g count n = iterateN g (return n) count

81{-# INLINE _iterateSingleton #-}

82_iterateSingleton ::

83 Monad m

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

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

85 -> Int

86 -> Int

87− -> SerialT m Int

87+ -> Stream m Int

88_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

89-}

@@ -402,7 +402,7 @@ o_1_space_monad value =

402-- This is a good benchmark but inefficient way to compute primes. As we see a

403-- new prime we keep appending a division filter for all the future numbers.

404{-# INLINE sieve #-}

405−sieve :: Monad m => SerialT m Int -> SerialT m Int

405+sieve :: Monad m => Stream m Int -> Stream m Int

406sieve s = do

407 r <- lift $ S.uncons s

408 case r of

@@ -435,7 +435,7 @@ toKv p = (p, p)

435

436{-# INLINE joinWith #-}

437joinWith :: 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)

439 -> Int

440 -> Int

441 -> m ()

@@ -444,7 +444,7 @@ joinWith j val i =

444

445{-# INLINE joinMapWith #-}

446joinMapWith :: 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)

448 -> Int

449 -> Int

450 -> m ()

benchmark/Streamly/Benchmark/Data/Stream/Generate.hs+22−22

@@ -26,7 +26,7 @@ import qualified Prelude

27import Gauge

28import Streamly.Benchmark.Common

29−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

30#ifdef USE_PRELUDE

31import Streamly.Prelude (MonadAsync)

32import Stream.Common hiding (MonadAsync)

@@ -47,23 +47,23 @@ import Prelude hiding (repeat, replicate, iterate)

47-------------------------------------------------------------------------------

49{-# INLINE sourceFromList #-}

50−sourceFromList :: Monad m => Int -> Int -> SerialT m Int

50+sourceFromList :: Monad m => Int -> Int -> Stream m Int

51sourceFromList value n = Stream.fromList [n..n+value]

53{-# INLINE sourceFromListM #-}

54−sourceFromListM :: MonadAsync m => Int -> Int -> SerialT m Int

54+sourceFromListM :: MonadAsync m => Int -> Int -> Stream m Int

55sourceFromListM value n = fromListM (fmap return [n..n+value])

57{-# INLINE sourceIsList #-}

58−sourceIsList :: Int -> Int -> SerialT Identity Int

58+sourceIsList :: Int -> Int -> Stream Identity Int

59sourceIsList value n = GHC.fromList [n..n+value]

61{-# INLINE sourceIsString #-}

62−sourceIsString :: Int -> Int -> SerialT Identity Char

62+sourceIsString :: Int -> Int -> Stream Identity Char

63sourceIsString value n = GHC.fromString (Prelude.replicate (n + value) 'a')

65{-# INLINE readInstance #-}

66−readInstance :: String -> SerialT Identity Int

66+readInstance :: String -> Stream Identity Int

67readInstance str =

68 let r = reads str

69 in case r of

@@ -80,11 +80,11 @@ readInstanceList str =

80 _ -> error "readInstance: no parse"

82{-# INLINE repeat #-}

83−repeat :: Monad m => Int -> Int -> SerialT m Int

83+repeat :: Monad m => Int -> Int -> Stream m Int

84repeat count = Stream.take count . Stream.repeat

86{-# INLINE replicate #-}

87−replicate :: Monad m => Int -> Int -> SerialT m Int

87+replicate :: Monad m => Int -> Int -> Stream m Int

88replicate = Stream.replicate

90-------------------------------------------------------------------------------

@@ -92,60 +92,60 @@ replicate = Stream.replicate

92-------------------------------------------------------------------------------

94{-# INLINE sourceIntFromTo #-}

95−sourceIntFromTo :: Monad m => Int -> Int -> SerialT m Int

95+sourceIntFromTo :: Monad m => Int -> Int -> Stream m Int

96sourceIntFromTo value n = Stream.enumerateFromTo n (n + value)

98{-# INLINE sourceIntFromThenTo #-}

99−sourceIntFromThenTo :: Monad m => Int -> Int -> SerialT m Int

99+sourceIntFromThenTo :: Monad m => Int -> Int -> Stream m Int

100sourceIntFromThenTo value n = Stream.enumerateFromThenTo n (n + 1) (n + value)

101

102{-# INLINE sourceFracFromTo #-}

103−sourceFracFromTo :: Monad m => Int -> Int -> SerialT m Double

103+sourceFracFromTo :: Monad m => Int -> Int -> Stream m Double

104sourceFracFromTo value n =

105 Stream.enumerateFromTo (fromIntegral n) (fromIntegral (n + value))

106

107{-# INLINE sourceFracFromThenTo #-}

108−sourceFracFromThenTo :: Monad m => Int -> Int -> SerialT m Double

108+sourceFracFromThenTo :: Monad m => Int -> Int -> Stream m Double

109sourceFracFromThenTo value n = Stream.enumerateFromThenTo (fromIntegral n)

110 (fromIntegral n + 1.0001) (fromIntegral (n + value))

111

112{-# INLINE sourceIntegerFromStep #-}

113−sourceIntegerFromStep :: Monad m => Int -> Int -> SerialT m Integer

113+sourceIntegerFromStep :: Monad m => Int -> Int -> Stream m Integer

114sourceIntegerFromStep value n =

115 Stream.take value $ Stream.enumerateFromThen (fromIntegral n) (fromIntegral n + 1)

116

117{-# INLINE enumerateFrom #-}

118−enumerateFrom :: Monad m => Int -> Int -> SerialT m Int

118+enumerateFrom :: Monad m => Int -> Int -> Stream m Int

119enumerateFrom count = Stream.take count . Stream.enumerateFrom

120

121{-# INLINE enumerateFromTo #-}

122−enumerateFromTo :: Monad m => Int -> Int -> SerialT m Int

122+enumerateFromTo :: Monad m => Int -> Int -> Stream m Int

123enumerateFromTo = sourceIntFromTo

124

125{-# INLINE enumerateFromThen #-}

126−enumerateFromThen :: Monad m => Int -> Int -> SerialT m Int

126+enumerateFromThen :: Monad m => Int -> Int -> Stream m Int

127enumerateFromThen count inp = Stream.take count $ Stream.enumerateFromThen inp (inp + 1)

128

129{-# INLINE enumerateFromThenTo #-}

130−enumerateFromThenTo :: Monad m => Int -> Int -> SerialT m Int

130+enumerateFromThenTo :: Monad m => Int -> Int -> Stream m Int

131enumerateFromThenTo = sourceIntFromThenTo

132

133-- n ~ 1

134{-# INLINE enumerate #-}

135−enumerate :: Monad m => Int -> Int -> SerialT m Int

135+enumerate :: Monad m => Int -> Int -> Stream m Int

136enumerate count n = Stream.take (count + n) Stream.enumerate

137

138-- n ~ 1

139{-# INLINE enumerateTo #-}

140−enumerateTo :: Monad m => Int -> Int -> SerialT m Int

140+enumerateTo :: Monad m => Int -> Int -> Stream m Int

141enumerateTo count n = Stream.enumerateTo (minBound + count + n)

142

143{-# INLINE iterate #-}

144−iterate :: Monad m => Int -> Int -> SerialT m Int

144+iterate :: Monad m => Int -> Int -> Stream m Int

145iterate count = Stream.take count . Stream.iterate (+1)

146

147{-# INLINE iterateM #-}

148−iterateM :: MonadAsync m => Int -> Int -> SerialT m Int

148+iterateM :: MonadAsync m => Int -> Int -> Stream m Int

149iterateM count = Stream.take count . Stream.iterateM (return . (+1)) . return

150

151#ifdef USE_PRELUDE

@@ -167,7 +167,7 @@ fromIndicesM value n = S.take value $ S.fromIndicesM (return <$> (+ n))

167#endif

168

169{-# INLINE mfixUnfold #-}

170−mfixUnfold :: Int -> Int -> SerialT IO (Int, Int)

170+mfixUnfold :: Int -> Int -> Stream IO (Int, Int)

171mfixUnfold count start = Stream.mfix f

172 where

173 f action = do

benchmark/Streamly/Benchmark/Data/Stream/Lift.hs+10−10

@@ -30,7 +30,7 @@ import qualified Stream.Common as Common

30import qualified Control.Monad.State.Strict as State

32import Gauge

33−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

34import Streamly.Benchmark.Common

36import Prelude hiding (reverse, tail)

@@ -41,7 +41,7 @@ import Prelude hiding (reverse, tail)

42{-# INLINE sourceUnfoldrState #-}

43sourceUnfoldrState :: Common.MonadAsync m =>

44− Int -> Int -> SerialT (StateT Int m) Int

44+ Int -> Int -> Stream (StateT Int m) Int

45sourceUnfoldrState value n = Stream.unfoldrM step n

46 where

47 step cnt =

@@ -53,12 +53,12 @@ sourceUnfoldrState value n = Stream.unfoldrM step n

53 return (Just (s, cnt + 1))

55{-# INLINE evalStateT #-}

56−evalStateT :: Common.MonadAsync m => Int -> Int -> SerialT m Int

56+evalStateT :: Common.MonadAsync m => Int -> Int -> Stream m Int

57evalStateT value n =

58 Stream.evalStateT (return 0) (sourceUnfoldrState value n)

60{-# INLINE withState #-}

61−withState :: Common.MonadAsync m => Int -> Int -> SerialT m Int

61+withState :: Common.MonadAsync m => Int -> Int -> Stream m Int

62withState value n =

63 Stream.evalStateT

64 (return (0 :: Int)) (Stream.liftInner (sourceUnfoldrM value n))

@@ -66,7 +66,7 @@ withState value n =

66{-# INLINE benchHoistSink #-}

67benchHoistSink

68 :: (NFData b)

69− => Int -> String -> (SerialT Identity Int -> IO b) -> Benchmark

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

70benchHoistSink value name f =

71 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

@@ -94,7 +94,7 @@ iterateStateIO n = do

94 else return x

96{-# INLINE iterateStateT #-}

97−iterateStateT :: Int -> SerialT (StateT Int IO) Int

97+iterateStateT :: Int -> Stream (StateT Int IO) Int

98iterateStateT n = do

99 x <- lift get

100 if x > n

@@ -104,11 +104,11 @@ iterateStateT n = do

104 else return x

105

106{-# INLINE iterateState #-}

107−{-# SPECIALIZE iterateState :: Int -> SerialT (StateT Int IO) Int #-}

107+{-# SPECIALIZE iterateState :: Int -> Stream (StateT Int IO) Int #-}

108iterateState ::

109 MonadState Int m

110 => Int

111− -> SerialT m Int

111+ -> Stream m Int

112iterateState n = do

113 x <- get

114 if x > n

@@ -122,9 +122,9 @@ o_n_heap_transformer value =

122 [ bgroup "transformer"

123 [ benchIO "StateT Int IO (n times) (baseline)" $ \n ->

124 State.evalStateT (iterateStateIO n) value

125− , benchIO "SerialT (StateT Int IO) (n times)" $ \n ->

125+ , benchIO "Stream (StateT Int IO) (n times)" $ \n ->

126 State.evalStateT (drain (iterateStateT n)) value

127− , benchIO "MonadState Int m => SerialT m Int" $ \n ->

127+ , benchIO "MonadState Int m => Stream m Int" $ \n ->

128 State.evalStateT (drain (iterateState n)) value

129 ]

130 ]

benchmark/Streamly/Benchmark/Data/Stream/Reduce.hs+45−45

@@ -18,7 +18,7 @@ import Control.Monad.IO.Class (MonadIO(..))

18import Data.Monoid (Sum(..))

19import GHC.Generics (Generic)

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

21−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

23import qualified Streamly.Internal.Data.Refold.Type as Refold

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

@@ -60,10 +60,10 @@ iterateN g initial count = f count initial

60-- Iterate a transformation over a singleton stream

61{-# INLINE iterateSingleton #-}

62iterateSingleton :: Monad m

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

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

64 -> Int

65 -> Int

66− -> SerialT m Int

66+ -> Stream m Int

67iterateSingleton g count n = iterateN g (return n) count

69{-

@@ -75,10 +75,10 @@ iterateSingleton g count n = iterateN g (return n) count

75{-# INLINE _iterateSingleton #-}

76_iterateSingleton ::

77 Monad m

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

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

79 -> Int

80 -> Int

81− -> SerialT m Int

81+ -> Stream m Int

82_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

83-}

@@ -86,11 +86,11 @@ _iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

86{-# INLINE iterateSource #-}

87iterateSource ::

88 MonadAsync m

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

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

90 -> Int

91 -> Int

92 -> Int

93− -> SerialT m Int

93+ -> Stream m Int

94iterateSource g count len n = f count (sourceUnfoldrM len n)

96 where

@@ -126,32 +126,32 @@ o_n_space_functor value =

126

127#ifdef USE_PRELUDE

128{-# INLINE groups #-}

129−groups :: MonadIO m => SerialT m Int -> m ()

129+groups :: MonadIO m => Stream m Int -> m ()

130groups = Common.drain . S.groups FL.drain

131

132-- XXX Change this test when the order of comparison is later changed

133{-# INLINE groupsByGT #-}

134−groupsByGT :: MonadIO m => SerialT m Int -> m ()

134+groupsByGT :: MonadIO m => Stream m Int -> m ()

135groupsByGT = Common.drain . S.groupsBy (>) FL.drain

136

137{-# INLINE groupsByEq #-}

138−groupsByEq :: MonadIO m => SerialT m Int -> m ()

138+groupsByEq :: MonadIO m => Stream m Int -> m ()

139groupsByEq = Common.drain . S.groupsBy (==) FL.drain

140

141-- XXX Change this test when the order of comparison is later changed

142{-# INLINE groupsByRollingLT #-}

143−groupsByRollingLT :: MonadIO m => SerialT m Int -> m ()

143+groupsByRollingLT :: MonadIO m => Stream m Int -> m ()

144groupsByRollingLT =

145 Common.drain . S.groupsByRolling (<) FL.drain

146

147{-# INLINE groupsByRollingEq #-}

148−groupsByRollingEq :: MonadIO m => SerialT m Int -> m ()

148+groupsByRollingEq :: MonadIO m => Stream m Int -> m ()

149groupsByRollingEq =

150 Common.drain . S.groupsByRolling (==) FL.drain

151#endif

152

153{-# INLINE foldMany #-}

154−foldMany :: Monad m => SerialT m Int -> m ()

154+foldMany :: Monad m => Stream m Int -> m ()

155foldMany =

156 Common.drain

157 . fmap getSum

@@ -159,7 +159,7 @@ foldMany =

159 . fmap Sum

160

161{-# INLINE foldManyPost #-}

162−foldManyPost :: Monad m => SerialT m Int -> m ()

162+foldManyPost :: Monad m => Stream m Int -> m ()

163foldManyPost =

164 Common.drain

165 . fmap getSum

@@ -167,7 +167,7 @@ foldManyPost =

167 . fmap Sum

168

169{-# INLINE refoldMany #-}

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

170+refoldMany :: Monad m => Stream m Int -> m ()

171refoldMany =

172 Common.drain

173 . fmap getSum

@@ -175,7 +175,7 @@ refoldMany =

175 . fmap Sum

176

177{-# INLINE foldIterateM #-}

178−foldIterateM :: Monad m => SerialT m Int -> m ()

178+foldIterateM :: Monad m => Stream m Int -> m ()

179foldIterateM =

180 Common.drain

181 . fmap getSum

@@ -184,7 +184,7 @@ foldIterateM =

184 . fmap Sum

185

186{-# INLINE refoldIterateM #-}

187−refoldIterateM :: Monad m => SerialT m Int -> m ()

187+refoldIterateM :: Monad m => Stream m Int -> m ()

188refoldIterateM =

189 Common.drain

190 . fmap getSum

@@ -221,11 +221,11 @@ o_1_space_grouping value =

221-------------------------------------------------------------------------------

222

223{-# INLINE reverse #-}

224−reverse :: MonadIO m => Int -> SerialT m Int -> m ()

224+reverse :: MonadIO m => Int -> Stream m Int -> m ()

225reverse n = composeN n S.reverse

226

227{-# INLINE reverse' #-}

228−reverse' :: MonadIO m => Int -> SerialT m Int -> m ()

228+reverse' :: MonadIO m => Int -> Stream m Int -> m ()

229reverse' n = composeN n S.reverse'

230

231o_n_heap_buffering :: Int -> [Benchmark]

@@ -248,7 +248,7 @@ o_n_heap_buffering value =

248

249#ifdef USE_PRELUDE

250{-# INLINE classifySessionsOf #-}

251−classifySessionsOf :: MonadAsync m => (Int -> Int) -> SerialT m Int -> m ()

251+classifySessionsOf :: MonadAsync m => (Int -> Int) -> Stream m Int -> m ()

252classifySessionsOf getKey =

253 Common.drain

254 . S.classifySessionsOf

@@ -258,7 +258,7 @@ classifySessionsOf getKey =

258

259{-# INLINE classifySessionsOfHash #-}

260classifySessionsOfHash :: MonadAsync m =>

261− (Int -> Int) -> SerialT m Int -> m ()

261+ (Int -> Int) -> Stream m Int -> m ()

262classifySessionsOfHash getKey =

263 Common.drain

264 . S.classifySessionsByGeneric

@@ -292,49 +292,49 @@ o_n_space_grouping value =

292-------------------------------------------------------------------------------

293

294{-# INLINE scanMap #-}

295−scanMap :: MonadIO m => Int -> SerialT m Int -> m ()

295+scanMap :: MonadIO m => Int -> Stream m Int -> m ()

296scanMap n = composeN n $ fmap (subtract 1) . Common.scanl' (+) 0

297

298{-# INLINE dropMap #-}

299−dropMap :: MonadIO m => Int -> SerialT m Int -> m ()

299+dropMap :: MonadIO m => Int -> Stream m Int -> m ()

300dropMap n = composeN n $ fmap (subtract 1) . S.drop 1

301

302{-# INLINE dropScan #-}

303−dropScan :: MonadIO m => Int -> SerialT m Int -> m ()

303+dropScan :: MonadIO m => Int -> Stream m Int -> m ()

304dropScan n = composeN n $ Common.scanl' (+) 0 . S.drop 1

305

306{-# INLINE takeDrop #-}

307−takeDrop :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

307+takeDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()

308takeDrop value n = composeN n $ S.drop 1 . S.take (value + 1)

309

310{-# INLINE takeScan #-}

311−takeScan :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

311+takeScan :: MonadIO m => Int -> Int -> Stream m Int -> m ()

312takeScan value n = composeN n $ Common.scanl' (+) 0 . S.take (value + 1)

313

314{-# INLINE takeMap #-}

315−takeMap :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

315+takeMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()

316takeMap value n = composeN n $ fmap (subtract 1) . S.take (value + 1)

317

318{-# INLINE filterDrop #-}

319−filterDrop :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

319+filterDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()

320filterDrop value n = composeN n $ S.drop 1 . S.filter (<= (value + 1))

321

322{-# INLINE filterTake #-}

323−filterTake :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

323+filterTake :: MonadIO m => Int -> Int -> Stream m Int -> m ()

324filterTake value n = composeN n $ S.take (value + 1) . S.filter (<= (value + 1))

325

326{-# INLINE filterScan #-}

327−filterScan :: MonadIO m => Int -> SerialT m Int -> m ()

327+filterScan :: MonadIO m => Int -> Stream m Int -> m ()

328filterScan n = composeN n $ Common.scanl' (+) 0 . S.filter (<= maxBound)

329

330#ifdef USE_PRELUDE

331{-# INLINE filterScanl1 #-}

332−filterScanl1 :: MonadIO m => Int -> SerialT m Int -> m ()

332+filterScanl1 :: MonadIO m => Int -> Stream m Int -> m ()

333filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)

334#endif

335

336{-# INLINE filterMap #-}

337−filterMap :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

337+filterMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()

338filterMap value n = composeN n $ fmap (subtract 1) . S.filter (<= (value + 1))

339

340-------------------------------------------------------------------------------

@@ -346,17 +346,17 @@ data Pair a b =

346 deriving (Generic, NFData)

347

348{-# INLINE sumProductFold #-}

349−sumProductFold :: Monad m => SerialT m Int -> m (Int, Int)

349+sumProductFold :: Monad m => Stream m Int -> m (Int, Int)

350sumProductFold = Common.foldl' (\(s, p) x -> (s + x, p * x)) (0, 1)

351

352{-# INLINE sumProductScan #-}

353−sumProductScan :: Monad m => SerialT m Int -> m (Pair Int Int)

353+sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)

354sumProductScan =

355 Common.foldl' (\(Pair _ p) (s0, x) -> Pair s0 (p * x)) (Pair 0 1) .

356 Common.scanl' (\(s, _) x -> (s + x, x)) (0, 0)

357

358{-# INLINE foldl'ReduceMap #-}

359−foldl'ReduceMap :: Monad m => SerialT m Int -> m Int

359+foldl'ReduceMap :: Monad m => Stream m Int -> m Int

360foldl'ReduceMap = fmap (+ 1) . Common.foldl' (+) 0

361

362o_1_space_transformations_mixed :: Int -> [Benchmark]

@@ -397,49 +397,49 @@ o_1_space_transformations_mixedX4 value =

397

398-- this is quadratic

399{-# INLINE iterateScan #-}

400−iterateScan :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

400+iterateScan :: MonadAsync m => Int -> Int -> Int -> Stream m Int

401iterateScan = iterateSource (Common.scanl' (+) 0)

402

403#ifdef USE_PRELUDE

404-- this is quadratic

405{-# INLINE iterateScanl1 #-}

406−iterateScanl1 :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

406+iterateScanl1 :: MonadAsync m => Int -> Int -> Int -> Stream m Int

407iterateScanl1 = iterateSource (S.scanl1' (+))

408#endif

409

410{-# INLINE iterateMapM #-}

411−iterateMapM :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

411+iterateMapM :: MonadAsync m => Int -> Int -> Int -> Stream m Int

412iterateMapM = iterateSource (S.mapM return)

413

414{-# INLINE iterateFilterEven #-}

415−iterateFilterEven :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

415+iterateFilterEven :: MonadAsync m => Int -> Int -> Int -> Stream m Int

416iterateFilterEven = iterateSource (S.filter even)

417

418{-# INLINE iterateTakeAll #-}

419−iterateTakeAll :: MonadAsync m => Int -> Int -> Int -> Int -> SerialT m Int

419+iterateTakeAll :: MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

420iterateTakeAll value = iterateSource (S.take (value + 1))

421

422{-# INLINE iterateDropOne #-}

423−iterateDropOne :: MonadAsync m => Int -> Int -> Int -> SerialT m Int

423+iterateDropOne :: MonadAsync m => Int -> Int -> Int -> Stream m Int

424iterateDropOne = iterateSource (S.drop 1)

425

426{-# INLINE iterateDropWhileFalse #-}

427iterateDropWhileFalse :: MonadAsync m

428− => Int -> Int -> Int -> Int -> SerialT m Int

428+ => Int -> Int -> Int -> Int -> Stream m Int

429iterateDropWhileFalse value = iterateSource (S.dropWhile (> (value + 1)))

430

431{-# INLINE iterateDropWhileTrue #-}

432iterateDropWhileTrue :: MonadAsync m

433− => Int -> Int -> Int -> Int -> SerialT m Int

433+ => Int -> Int -> Int -> Int -> Stream m Int

434iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1)))

435

436#ifdef USE_PRELUDE

437{-# INLINE tail #-}

438−tail :: Monad m => SerialT m a -> m ()

438+tail :: Monad m => Stream m a -> m ()

439tail s = S.tail s >>= mapM_ tail

440

441{-# INLINE nullHeadTail #-}

442−nullHeadTail :: Monad m => SerialT m Int -> m ()

442+nullHeadTail :: Monad m => Stream m Int -> m ()

443nullHeadTail s = do

444 r <- S.null s

445 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

41#endif

43import Gauge

44−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

45import Stream.Common hiding (scanl')

46import Streamly.Benchmark.Common

47import Prelude hiding (sequence, mapM)

@@ -59,25 +59,25 @@ import Prelude hiding (sequence, mapM)

59-------------------------------------------------------------------------------

61{-# INLINE traversableTraverse #-}

62−traversableTraverse :: SerialT Identity Int -> IO (SerialT Identity Int)

62+traversableTraverse :: Stream Identity Int -> IO (Stream Identity Int)

63traversableTraverse = traverse return

65{-# INLINE traversableSequenceA #-}

66−traversableSequenceA :: SerialT Identity Int -> IO (SerialT Identity Int)

66+traversableSequenceA :: Stream Identity Int -> IO (Stream Identity Int)

67traversableSequenceA = sequenceA . Prelude.fmap return

69{-# INLINE traversableMapM #-}

70−traversableMapM :: SerialT Identity Int -> IO (SerialT Identity Int)

70+traversableMapM :: Stream Identity Int -> IO (Stream Identity Int)

71traversableMapM = Prelude.mapM return

73{-# INLINE traversableSequence #-}

74−traversableSequence :: SerialT Identity Int -> IO (SerialT Identity Int)

74+traversableSequence :: Stream Identity Int -> IO (Stream Identity Int)

75traversableSequence = Prelude.sequence . Prelude.fmap return

77{-# INLINE benchPureSinkIO #-}

78benchPureSinkIO

79 :: NFData b

80− => Int -> String -> (SerialT Identity Int -> IO b) -> Benchmark

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

81benchPureSinkIO value name f =

82 bench name $ nfIO $ randomRIO (1, 1) >>= f . sourceUnfoldr value

@@ -99,51 +99,51 @@ o_n_space_traversable value =

100#ifdef USE_PRELUDE

101{-# INLINE scanl' #-}

102−scanl' :: MonadIO m => Int -> SerialT m Int -> m ()

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

103scanl' n = composeN n $ Stream.scanl' (+) 0

104

105{-# INLINE scanlM' #-}

106−scanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

106+scanlM' :: MonadIO m => Int -> Stream m Int -> m ()

107scanlM' n = composeN n $ Stream.scanlM' (\b a -> return $ b + a) (return 0)

108

109{-# INLINE scanl1' #-}

110−scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()

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

111scanl1' n = composeN n $ Stream.scanl1' (+)

112

113{-# INLINE scanl1M' #-}

114−scanl1M' :: MonadIO m => Int -> SerialT m Int -> m ()

114+scanl1M' :: MonadIO m => Int -> Stream m Int -> m ()

115scanl1M' n = composeN n $ Stream.scanl1M' (\b a -> return $ b + a)

116#endif

117

118{-# INLINE scan #-}

119−scan :: MonadIO m => Int -> SerialT m Int -> m ()

119+scan :: MonadIO m => Int -> Stream m Int -> m ()

120scan n = composeN n $ Stream.scan FL.sum

121

122#ifdef USE_PRELUDE

123{-# INLINE postscanl' #-}

124−postscanl' :: MonadIO m => Int -> SerialT m Int -> m ()

124+postscanl' :: MonadIO m => Int -> Stream m Int -> m ()

125postscanl' n = composeN n $ Stream.postscanl' (+) 0

126

127{-# INLINE postscanlM' #-}

128−postscanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

128+postscanlM' :: MonadIO m => Int -> Stream m Int -> m ()

129postscanlM' n = composeN n $ Stream.postscanlM' (\b a -> return $ b + a) (return 0)

130#endif

131

132{-# INLINE postscan #-}

133−postscan :: MonadIO m => Int -> SerialT m Int -> m ()

133+postscan :: MonadIO m => Int -> Stream m Int -> m ()

134postscan n = composeN n $ Stream.postscan FL.sum

135

136{-# INLINE sequence #-}

137−sequence :: MonadAsync m => SerialT m (m Int) -> m ()

137+sequence :: MonadAsync m => Stream m (m Int) -> m ()

138sequence = Common.drain . Stream.sequence

139

140{-# INLINE tap #-}

141−tap :: MonadIO m => Int -> SerialT m Int -> m ()

141+tap :: MonadIO m => Int -> Stream m Int -> m ()

142tap n = composeN n $ Stream.tap FL.sum

143

144#ifdef USE_PRELUDE

145{-# INLINE pollCounts #-}

146−pollCounts :: Int -> SerialT IO Int -> IO ()

146+pollCounts :: Int -> Stream IO Int -> IO ()

147pollCounts n =

148 composeN n (Stream.pollCounts (const True) f)

149

@@ -152,28 +152,28 @@ pollCounts n =

152 f = Stream.drain . Stream.rollingMap2 (-) . Stream.delayPost 1

153

154{-# INLINE timestamped #-}

155−timestamped :: (MonadAsync m) => SerialT m Int -> m ()

155+timestamped :: (MonadAsync m) => Stream m Int -> m ()

156timestamped = Stream.drain . Stream.timestamped

157#endif

158

159{-# INLINE foldrS #-}

160−foldrS :: MonadIO m => Int -> SerialT m Int -> m ()

160+foldrS :: MonadIO m => Int -> Stream m Int -> m ()

161foldrS n = composeN n $ Stream.foldrS Stream.cons Stream.nil

162

163{-# INLINE foldrSMap #-}

164−foldrSMap :: MonadIO m => Int -> SerialT m Int -> m ()

164+foldrSMap :: MonadIO m => Int -> Stream m Int -> m ()

165foldrSMap n = composeN n $ Stream.foldrS (\x xs -> x + 1 `Stream.cons` xs) Stream.nil

166

167{-# INLINE foldrT #-}

168−foldrT :: MonadIO m => Int -> SerialT m Int -> m ()

168+foldrT :: MonadIO m => Int -> Stream m Int -> m ()

169foldrT n = composeN n $ Stream.foldrT Stream.cons Stream.nil

170

171{-# INLINE foldrTMap #-}

172−foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()

172+foldrTMap :: MonadIO m => Int -> Stream m Int -> m ()

173foldrTMap n = composeN n $ Stream.foldrT (\x xs -> x + 1 `Stream.cons` xs) Stream.nil

174

175{-# INLINE trace #-}

176−trace :: MonadAsync m => Int -> SerialT m Int -> m ()

176+trace :: MonadAsync m => Int -> Stream m Int -> m ()

177trace n = composeN n $ Stream.trace return

178

179o_1_space_mapping :: Int -> [Benchmark]

@@ -229,7 +229,7 @@ o_1_space_mappingX4 value =

229 ]

230

231{-# INLINE sieveScan #-}

232−sieveScan :: Monad m => SerialT m Int -> SerialT m Int

232+sieveScan :: Monad m => Stream m Int -> Stream m Int

233sieveScan =

234 Stream.mapMaybe snd

235 . Stream.scan (FL.foldlM' (\(primes, _) n -> do

@@ -264,48 +264,48 @@ o_1_space_functor value =

264-------------------------------------------------------------------------------

265

266{-# INLINE filterEven #-}

267−filterEven :: MonadIO m => Int -> SerialT m Int -> m ()

267+filterEven :: MonadIO m => Int -> Stream m Int -> m ()

268filterEven n = composeN n $ Stream.filter even

269

270{-# INLINE filterAllOut #-}

271−filterAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

271+filterAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()

272filterAllOut value n = composeN n $ Stream.filter (> (value + 1))

273

274{-# INLINE filterAllIn #-}

275−filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

275+filterAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()

276filterAllIn value n = composeN n $ Stream.filter (<= (value + 1))

277

278{-# INLINE filterMEven #-}

279−filterMEven :: MonadIO m => Int -> SerialT m Int -> m ()

279+filterMEven :: MonadIO m => Int -> Stream m Int -> m ()

280filterMEven n = composeN n $ Stream.filterM (return . even)

281

282{-# INLINE filterMAllOut #-}

283−filterMAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

283+filterMAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()

284filterMAllOut value n = composeN n $ Stream.filterM (\x -> return $ x > (value + 1))

285

286{-# INLINE filterMAllIn #-}

287−filterMAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

287+filterMAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()

288filterMAllIn value n = composeN n $ Stream.filterM (\x -> return $ x <= (value + 1))

289

290{-# INLINE _takeOne #-}

291−_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()

291+_takeOne :: MonadIO m => Int -> Stream m Int -> m ()

292_takeOne n = composeN n $ Stream.take 1

293

294{-# INLINE takeAll #-}

295−takeAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

295+takeAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()

296takeAll value n = composeN n $ Stream.take (value + 1)

297

298{-# INLINE takeWhileTrue #-}

299−takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

299+takeWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

300takeWhileTrue value n = composeN n $ Stream.takeWhile (<= (value + 1))

301

302{-# INLINE takeWhileMTrue #-}

303−takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

303+takeWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

304takeWhileMTrue value n = composeN n $ Stream.takeWhileM (return . (<= (value + 1)))

305

306#ifdef USE_PRELUDE

307{-# INLINE takeInterval #-}

308−takeInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

308+takeInterval :: NanoSecond64 -> Int -> Stream IO Int -> IO ()

309takeInterval i n = composeN n (Stream.takeInterval i)

310

311#ifdef INSPECTION

@@ -316,33 +316,33 @@ inspect $ hasNoTypeClasses 'takeInterval

316#endif

317

318{-# INLINE dropOne #-}

319−dropOne :: MonadIO m => Int -> SerialT m Int -> m ()

319+dropOne :: MonadIO m => Int -> Stream m Int -> m ()

320dropOne n = composeN n $ Stream.drop 1

321

322{-# INLINE dropAll #-}

323−dropAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

323+dropAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()

324dropAll value n = composeN n $ Stream.drop (value + 1)

325

326{-# INLINE dropWhileTrue #-}

327−dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

327+dropWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

328dropWhileTrue value n = composeN n $ Stream.dropWhile (<= (value + 1))

329

330{-# INLINE dropWhileMTrue #-}

331−dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

331+dropWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

332dropWhileMTrue value n = composeN n $ Stream.dropWhileM (return . (<= (value + 1)))

333

334{-# INLINE dropWhileFalse #-}

335−dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

335+dropWhileFalse :: MonadIO m => Int -> Int -> Stream m Int -> m ()

336dropWhileFalse value n = composeN n $ Stream.dropWhile (> (value + 1))

337

338#ifdef USE_PRELUDE

339-- XXX Decide on the time interval

340{-# INLINE _intervalsOfSum #-}

341−_intervalsOfSum :: MonadAsync m => Double -> Int -> SerialT m Int -> m ()

341+_intervalsOfSum :: MonadAsync m => Double -> Int -> Stream m Int -> m ()

342_intervalsOfSum i n = composeN n (Stream.intervalsOf i FL.sum)

343

344{-# INLINE dropInterval #-}

345−dropInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

345+dropInterval :: NanoSecond64 -> Int -> Stream IO Int -> IO ()

346dropInterval i n = composeN n (Stream.dropInterval i)

347

348#ifdef INSPECTION

@@ -352,24 +352,24 @@ inspect $ hasNoTypeClasses 'dropInterval

352#endif

353

354{-# INLINE findIndices #-}

355−findIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

355+findIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()

356findIndices value n = composeN n $ Stream.findIndices (== (value + 1))

357

358{-# INLINE elemIndices #-}

359−elemIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

359+elemIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()

360elemIndices value n = composeN n $ Stream.elemIndices (value + 1)

361

362{-# INLINE deleteBy #-}

363−deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

363+deleteBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()

364deleteBy value n = composeN n $ Stream.deleteBy (>=) (value + 1)

365

366-- uniq . uniq == uniq, composeN 2 ~ composeN 1

367{-# INLINE uniq #-}

368−uniq :: MonadIO m => Int -> SerialT m Int -> m ()

368+uniq :: MonadIO m => Int -> Stream m Int -> m ()

369uniq n = composeN n Stream.uniq

370

371{-# INLINE mapMaybe #-}

372−mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()

372+mapMaybe :: MonadIO m => Int -> Stream m Int -> m ()

373mapMaybe n =

374 composeN n $

375 Stream.mapMaybe

@@ -379,7 +379,7 @@ mapMaybe n =

379 else Just x)

380

381{-# INLINE mapMaybeM #-}

382−mapMaybeM :: MonadAsync m => Int -> SerialT m Int -> m ()

382+mapMaybeM :: MonadAsync m => Int -> Stream m Int -> m ()

383mapMaybeM n =

384 composeN n $

385 Stream.mapMaybeM

@@ -477,24 +477,24 @@ o_1_space_filteringX4 value =

477-------------------------------------------------------------------------------

478

479{-# INLINE intersperse #-}

480−intersperse :: MonadAsync m => Int -> Int -> SerialT m Int -> m ()

480+intersperse :: MonadAsync m => Int -> Int -> Stream m Int -> m ()

481intersperse value n = composeN n $ Stream.intersperse (value + 1)

482

483{-# INLINE intersperseM #-}

484−intersperseM :: MonadAsync m => Int -> Int -> SerialT m Int -> m ()

484+intersperseM :: MonadAsync m => Int -> Int -> Stream m Int -> m ()

485intersperseM value n = composeN n $ Stream.intersperseM (return $ value + 1)

486

487{-# INLINE insertBy #-}

488−insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

488+insertBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()

489insertBy value n = composeN n $ Stream.insertBy compare (value + 1)

490

491{-# INLINE interposeSuffix #-}

492−interposeSuffix :: Monad m => Int -> Int -> SerialT m Int -> m ()

492+interposeSuffix :: Monad m => Int -> Int -> Stream m Int -> m ()

493interposeSuffix value n =

494 composeN n $ Stream.interposeSuffix (value + 1) Unfold.identity

495

496{-# INLINE intercalateSuffix #-}

497−intercalateSuffix :: Monad m => Int -> Int -> SerialT m Int -> m ()

497+intercalateSuffix :: Monad m => Int -> Int -> Stream m Int -> m ()

498intercalateSuffix value n =

499 composeN n $ Stream.intercalateSuffix Unfold.identity (value + 1)

500

@@ -522,11 +522,11 @@ o_1_space_insertingX4 value =

522-------------------------------------------------------------------------------

523

524{-# INLINE indexed #-}

525−indexed :: MonadIO m => Int -> SerialT m Int -> m ()

525+indexed :: MonadIO m => Int -> Stream m Int -> m ()

526indexed n = composeN n (fmap snd . Stream.indexed)

527

528{-# INLINE indexedR #-}

529−indexedR :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

529+indexedR :: MonadIO m => Int -> Int -> Stream m Int -> m ()

530indexedR value n = composeN n (fmap snd . Stream.indexedR value)

531

532o_1_space_indexing :: Int -> [Benchmark]

benchmark/Streamly/Benchmark/Data/Unfold.hs+9−9

@@ -31,10 +31,10 @@ import qualified Prelude

31import qualified Streamly.FileSystem.Handle as FH

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

33import 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

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

36import qualified Streamly.Internal.Data.Stream.StreamK as K

37−import qualified Streamly.Prelude as SP

37+

39import Gauge hiding (env)

40import Prelude hiding (take, filter, zipWith, map, mapM, takeWhile)

@@ -161,7 +161,7 @@ swap size start =

161{-# INLINE fromStream #-}

162fromStream :: Int -> Int -> IO ()

163fromStream 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)

165

166-- XXX INVESTIGATE: Although the performance of this should be equivalant to

167-- fromStream, this is considerably worse. More than 4x worse.

@@ -749,7 +749,7 @@ o_n_space_nested size =

749readWriteOnExceptionUnfold :: Handle -> Handle -> IO ()

750readWriteOnExceptionUnfold inh devNull =

751 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

753

754#ifdef INSPECTION

755inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold

@@ -761,7 +761,7 @@ readWriteHandleExceptionUnfold :: Handle -> Handle -> IO ()

761readWriteHandleExceptionUnfold inh devNull =

762 let handler (_e :: SomeException) = hClose inh >> return 10

763 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

765

766#ifdef INSPECTION

767inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

@@ -772,7 +772,7 @@ inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

772readWriteFinally_Unfold :: Handle -> Handle -> IO ()

773readWriteFinally_Unfold inh devNull =

774 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

776

777#ifdef INSPECTION

778inspect $ hasNoTypeClasses 'readWriteFinally_Unfold

@@ -782,13 +782,13 @@ inspect $ hasNoTypeClasses 'readWriteFinally_Unfold

782readWriteFinallyUnfold :: Handle -> Handle -> IO ()

783readWriteFinallyUnfold inh devNull =

784 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

786

787-- | Send the file contents to /dev/null with exception handling

788readWriteBracket_Unfold :: Handle -> Handle -> IO ()

789readWriteBracket_Unfold inh devNull =

790 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

792

793#ifdef INSPECTION

794inspect $ hasNoTypeClasses 'readWriteBracket_Unfold

@@ -798,7 +798,7 @@ inspect $ hasNoTypeClasses 'readWriteBracket_Unfold

798readWriteBracketUnfold :: Handle -> Handle -> IO ()

799readWriteBracketUnfold inh devNull =

800 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

802

803o_1_space_copy_read_exceptions :: BenchEnv -> [Benchmark]

804o_1_space_copy_read_exceptions env =

core/src/Streamly/Data/Array/Unboxed.hs+4−4

@@ -29,8 +29,8 @@

29-- it to IO monad as follows:

30--

31-- >>> import Data.Functor.Identity (Identity, runIdentity)

32−-- >>> s = Stream.fromList [1..10] :: SerialT Identity Int

32+-- >>> s = Stream.fromList [1..10] :: Stream Identity Int

33−-- >>> s1 = Stream.hoist (return . runIdentity) s :: SerialT IO Int

33+-- >>> s1 = Stream.hoist (return . runIdentity) s :: Stream IO Int

34-- >>> Stream.fold Array.write s1 :: IO (Array Int)

35-- [1,2,3,4,5,6,7,8,9,10]

36--

@@ -98,7 +98,7 @@ import Streamly.Internal.Data.Array.Unboxed as A

98-- >>> :m

99-- >>> :set -XFlexibleContexts

100-- >>> :set -package streamly

101−-- >>> import Streamly.Prelude (SerialT)

101+-- >>> import Streamly.Internal.Data.Stream (Stream)

102-- >>> 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

104-- >>> 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

248 (Pipe(..), PipeState(..), Step(..), zipWith, tee, map, compose)

249-- import Streamly.Internal.Data.Array.Unboxed.Type (Array)

250-- import Streamly.Internal.Data.Ring.Foreign (Ring)

251−-- import Streamly.Internal.Data.Stream.Serial (SerialT)

251+-- import Streamly.Internal.Data.Stream (Stream)

252-- import Streamly.Internal.Data.Stream.StreamK (IsStream())

253-- import Streamly.Internal.Data.Time.Units

254-- (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

21 -- * Construction

22 , Stream.cons

23 , Stream.consM

24− , repeat

24+ , Stream.repeat

25− , unfoldrM

25+ , Stream.unfoldrM

26 , fromList

28 -- * Elimination

@@ -38,13 +38,10 @@ where

38import Data.Semigroup (Semigroup(..))

39#endif

40import GHC.Exts (IsList(..))

41−

42−import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D

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

43import qualified Streamly.Internal.Data.Stream as Stream

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

45−import Prelude hiding (map, mapM, repeat)

44+import Prelude hiding (map)

46−

47−#include "inline.hs"

49-- $setup

46-- $setup

50-- >>> import qualified Streamly.Prelude as Stream

47-- >>> import qualified Streamly.Prelude as Stream

@@ -53,7 +50,7 @@ import Prelude hiding (map, mapM, repeat)

53-- SerialT

50-- SerialT

54------------------------------------------------------------------------------

51------------------------------------------------------------------------------

56−type SerialT = Stream.Stream

53+type SerialT = Stream

58-- | A serial IO stream of elements of type @a@. See 'SerialT' documentation

55-- | A serial IO stream of elements of type @a@. See 'SerialT' documentation

59-- for more details.

56-- for more details.

@@ -63,17 +60,6 @@ type SerialT = Stream.Stream

63-- @since 0.8.0

60-- @since 0.8.0

64type Serial = SerialT IO

61type Serial = SerialT IO

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−

77------------------------------------------------------------------------------

63------------------------------------------------------------------------------

78-- Combining

64-- Combining

79------------------------------------------------------------------------------

65------------------------------------------------------------------------------

@@ -98,32 +84,3 @@ serial = (<>)

98{-# INLINE map #-}

84{-# INLINE map #-}

99map :: Monad m => (a -> b) -> SerialT m a -> SerialT m b

85map :: Monad m => (a -> b) -> SerialT m a -> SerialT m b

100map f = Stream.mapM (return . f)

86map 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) =

353-- lazy the following example, must work:

354--

355-- 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)

357--

358{-# INLINE_NORMAL foldrM #-}

359foldrM :: 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)

106-- [(1,3),(2,3),(1,4),(2,4)]

107--

108-- 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'.

110--

111-- /Since: 0.2.0 ("Streamly")/

112--

src/Streamly/Data/Array/Foreign.hs+3−3

@@ -29,8 +29,8 @@

29-- it to IO monad as follows:

30--

31-- >>> import Data.Functor.Identity (Identity, runIdentity)

32−-- >>> s = Stream.fromList [1..10] :: SerialT Identity Int

32+-- >>> s = Stream.fromList [1..10] :: Stream Identity Int

33−-- >>> s1 = Stream.hoist (return . runIdentity) s :: SerialT IO Int

33+-- >>> s1 = Stream.hoist (return . runIdentity) s :: Stream IO Int

34-- >>> Stream.fold Array.write s1 :: IO (Array Int)

35-- [1,2,3,4,5,6,7,8,9,10]

36--

@@ -99,7 +99,7 @@ import Streamly.Internal.Data.Array.Unboxed as A

99-- >>> :m

100-- >>> :set -XFlexibleContexts

101-- >>> :set -package streamly

102−-- >>> import Streamly.Prelude (SerialT)

102+-- >>> import Streamly.Internal.Data.Stream (Stream)

103-- >>> import Streamly.Data.Array.Unboxed (Array)

104-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream

105-- >>> import qualified Streamly.Data.Array.Unboxed as Array

src/Streamly/Data/Unicode/Stream.hs+1−1

@@ -38,7 +38,7 @@

38--

39-- = String Literals

40--

41−-- @SerialT Identity Char@ and @Array Char@ are instances of 'IsString' and

41+-- @Stream Identity Char@ and @Array Char@ are instances of 'IsString' and

42-- 'IsList', therefore, 'OverloadedStrings' and 'OverloadedLists' extensions

43-- can be used for convenience when specifying unicode strings literals using

44-- these types.

src/Streamly/Internal/Console/Stdio.hs+11−11

@@ -43,7 +43,7 @@ import System.IO (stdin, stdout, stderr)

43import Prelude hiding (read)

45import Streamly.Internal.Data.Array.Unboxed.Type (Array(..))

46−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

47import Streamly.Internal.Data.Unfold (Unfold)

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

@@ -72,7 +72,7 @@ read = Unfold.lmap (\() -> stdin) Handle.read

72-- /Pre-release/

73--

74{-# INLINE getBytes #-}

75−getBytes :: MonadIO m => SerialT m Word8

75+getBytes :: MonadIO m => Stream m Word8

76getBytes = Handle.getBytes stdin

78-- | Read a character stream from Utf8 encoded standard input.

@@ -82,7 +82,7 @@ getBytes = Handle.getBytes stdin

82-- /Pre-release/

83--

84{-# INLINE getChars #-}

85−getChars :: MonadIO m => SerialT m Char

85+getChars :: MonadIO m => Stream m Char

86getChars = Unicode.decodeUtf8 getBytes

88-- | Unfolds standard input into a stream of 'Word8' arrays.

@@ -102,7 +102,7 @@ readChunks = Unfold.lmap (\() -> stdin) Handle.readChunks

102-- /Pre-release/

103--

104{-# INLINE getChunks #-}

105−getChunks :: MonadIO m => SerialT m (Array Word8)

105+getChunks :: MonadIO m => Stream m (Array Word8)

106getChunks = Handle.getChunks stdin

107

108{-

@@ -114,7 +114,7 @@ getChunks = Handle.getChunks stdin

114-- /Pre-release/

115--

116{-# INLINE getChunksLn #-}

117−getChunksLn :: MonadIO m => SerialT m (Array Word8)

117+getChunksLn :: MonadIO m => Stream m (Array Word8)

118getChunksLn = (Stream.splitWithSuffix (== '\n') f) getChars

119

120 -- XXX Need to implement Fold.unfoldMany, should be easy for

@@ -149,7 +149,7 @@ writeErr = Handle.write stderr

149-- /Pre-release/

150--

151{-# INLINE putBytes #-}

152−putBytes :: MonadIO m => SerialT m Word8 -> m ()

152+putBytes :: MonadIO m => Stream m Word8 -> m ()

153putBytes = Handle.putBytes stdout

154

155-- | Encode a character stream to Utf8 and write it to standard output.

@@ -159,7 +159,7 @@ putBytes = Handle.putBytes stdout

159-- /Pre-release/

160--

161{-# INLINE putChars #-}

162−putChars :: MonadIO m => SerialT m Char -> m ()

162+putChars :: MonadIO m => Stream m Char -> m ()

163putChars = putBytes . Unicode.encodeUtf8

164

165-- | Fold a stream of @Array Word8@ to standard output.

@@ -184,7 +184,7 @@ writeErrChunks = Handle.writeChunks stderr

184-- /Pre-release/

185--

186{-# INLINE putChunks #-}

187−putChunks :: MonadIO m => SerialT m (Array Word8) -> m ()

187+putChunks :: MonadIO m => Stream m (Array Word8) -> m ()

188putChunks = Handle.putChunks stdout

189

190-------------------------------------------------------------------------------

@@ -203,7 +203,7 @@ putChunks = Handle.putChunks stdout

203--

204{-# INLINE putStringsWith #-}

205putStringsWith :: MonadIO m

206− => (SerialT m Char -> SerialT m Word8) -> SerialT m String -> m ()

206+ => (Stream m Char -> Stream m Word8) -> Stream m String -> m ()

207putStringsWith encode = putChunks . Unicode.encodeStrings encode

208

209-- | Write a stream of strings to standard output using UTF8 encoding. Output

@@ -212,7 +212,7 @@ putStringsWith encode = putChunks . Unicode.encodeStrings encode

212-- /Pre-release/

213--

214{-# INLINE putStrings #-}

215−putStrings :: MonadIO m => SerialT m String -> m ()

215+putStrings :: MonadIO m => Stream m String -> m ()

216putStrings = putStringsWith Unicode.encodeUtf8

217

218-- | Like 'putStrings' but adds a newline at the end of each string.

@@ -222,7 +222,7 @@ putStrings = putStringsWith Unicode.encodeUtf8

222-- /Pre-release/

223--

224{-# INLINE putStringsLn #-}

225−putStringsLn :: MonadIO m => SerialT m String -> m ()

225+putStringsLn :: MonadIO m => Stream m String -> m ()

226putStringsLn =

227 putChunks

228 . 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(..))

68import Streamly.Internal.Data.Array.Stream.Fold.Foreign (ArrayFold(..))

69import Streamly.Internal.Data.Fold.Type (Fold(..))

70import Streamly.Internal.Data.Parser (ParseError(..))

71−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

72import Streamly.Internal.Data.Stream.IsStream.Type

73 (IsStream, fromStreamD, toStreamD)

74import Streamly.Internal.Data.SVar (adaptState, defState)

@@ -221,7 +221,7 @@ lpackArraysChunksOf n fld =

221-- @since 0.7.0

222{-# INLINE compact #-}

223compact :: (MonadIO m, Unboxed a)

224− => Int -> SerialT m (Array a) -> SerialT m (Array a)

224+ => Int -> Stream m (Array a) -> Stream m (Array a)

225compact n xs = fromStreamD $ packArraysChunksOf n (toStreamD xs)

226

227-------------------------------------------------------------------------------

@@ -396,8 +396,8 @@ foldBreakK (Fold fstep initial extract) stream = do

396foldBreak ::

397 (MonadIO m, Unboxed a)

398 => FL.Fold m a b

399− -> SerialT m (A.Array a)

399+ -> Stream m (A.Array a)

400− -> m (b, SerialT m (A.Array a))

400+ -> m (b, Stream m (A.Array a))

401-- foldBreak f s = fmap fromStreamD <$> foldBreakD f (toStreamD s)

402foldBreak f =

403 fmap (fmap Stream.fromStreamK)

@@ -465,14 +465,14 @@ splitAtArrayListRev n ls

465-- stream.

466{-# INLINE spliceArraysLenUnsafe #-}

467spliceArraysLenUnsafe :: (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)

469spliceArraysLenUnsafe len buffered = do

470 arr <- liftIO $ MA.newArray len

471 S.foldlM' MA.spliceUnsafe (return arr) buffered

472

473{-# INLINE _spliceArrays #-}

474_spliceArrays :: (MonadIO m, Unboxed a)

475− => SerialT m (Array a) -> m (Array a)

475+ => Stream m (Array a) -> m (Array a)

476_spliceArrays s = do

477 buffered <- S.foldr S.cons S.nil s

478 len <- S.sum (S.map Array.length buffered)

@@ -486,7 +486,7 @@ _spliceArrays s = do

486

487{-# INLINE _spliceArraysBuffered #-}

488_spliceArraysBuffered :: (MonadIO m, Unboxed a)

489− => SerialT m (Array a) -> m (Array a)

489+ => Stream m (Array a) -> m (Array a)

490_spliceArraysBuffered s = do

491 buffered <- S.foldr S.cons S.nil s

492 len <- S.sum (S.map Array.length buffered)

@@ -494,7 +494,7 @@ _spliceArraysBuffered s = do

494

495{-# INLINE spliceArraysRealloced #-}

496spliceArraysRealloced :: forall m a. (MonadIO m, Unboxed a)

497− => SerialT m (Array a) -> m (Array a)

497+ => Stream m (Array a) -> m (Array a)

498spliceArraysRealloced s = do

499 let n = allocBytesToElemCount (undefined :: a) (4 * 1024)

500 idst = liftIO $ MA.newArray n

@@ -509,7 +509,7 @@ spliceArraysRealloced s = do

509--

510-- @since 0.7.0

511{-# 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)

513toArray = spliceArraysRealloced

514-- spliceArrays = _spliceArraysBuffered

515

@@ -529,7 +529,7 @@ toArraysInRange low high (Fold step initial extract) =

529-- | Fold the input to a pure buffered stream (List) of arrays.

530{-# INLINE _toArraysOf #-}

531_toArraysOf :: (MonadIO m, Unboxed a)

532− => Int -> Fold m a (SerialT Identity (Array a))

532+ => Int -> Fold m a (Stream Identity (Array a))

533_toArraysOf n = FL.chunksOf n (A.writeNF n) FL.toStream

534-}

535

@@ -710,8 +710,8 @@ parseBreakK (PRD.Parser pstep initial extract) stream = do

710parseBreak ::

711 (MonadIO m, MonadThrow m, Unboxed a)

712 => PR.Parser m a b

713− -> SerialT m (A.Array a)

713+ -> Stream m (A.Array a)

714− -> m (b, SerialT m (A.Array a))

714+ -> m (b, Stream m (A.Array a))

715{-

716parseBreak p s =

717 fmap fromStreamD <$> parseBreakD (PRD.fromParserK p) (toStreamD s)

@@ -808,8 +808,8 @@ runArrayParserDBreak

808parseArr ::

809 (MonadIO m, MonadThrow m, Unboxed a)

810 => ASF.Parser m a b

811− -> SerialT m (A.Array a)

811+ -> Stream m (A.Array a)

812− -> m (b, SerialT m (A.Array a))

812+ -> m (b, Stream m (A.Array a))

813parseArr p s = fmap fromStreamD <$> parseBreakD p (toStreamD s)

814-}

815

@@ -819,7 +819,7 @@ parseArr p s = fmap fromStreamD <$> parseBreakD p (toStreamD s)

819--

820{-# INLINE runArrayFold #-}

821runArrayFold :: (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

823runArrayFold (ArrayFold p) s = fst <$> runArrayParserDBreak p (toStreamD s)

824

825-- | Like 'fold' but also returns the remaining stream.

@@ -828,7 +828,7 @@ runArrayFold (ArrayFold p) s = fst <$> runArrayParserDBreak p (toStreamD s)

828--

829{-# INLINE runArrayFoldBreak #-}

830runArrayFoldBreak :: (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))

832runArrayFoldBreak (ArrayFold p) s =

833 second fromStreamD <$> runArrayParserDBreak p (toStreamD s)

834

src/Streamly/Internal/FileSystem/Dir.hs+5−5

@@ -66,7 +66,7 @@ import Streamly.Internal.Data.Unfold.Type (Unfold(..))

66-- import Streamly.Internal.Data.Array.Unboxed.Type

67-- (Array(..), writeNUnsafe, defaultChunkSize, shrinkToFit,

68-- lpackArraysChunksOf)

69−-- import Streamly.Internal.Data.Stream.Serial (SerialT)

69+-- import Streamly.Internal.Data.Stream (Stream)

70import Streamly.Internal.Data.Stream.IsStream.Type (IsStream)

71-- import Streamly.String (encodeUtf8, decodeUtf8, foldLines)

@@ -315,7 +315,7 @@ writeArray h Array{..} = withForeignPtr aStart $ \p -> hPutBuf h p aLen

315-- @since 0.7.0

316{-# INLINE fromChunks #-}

317fromChunks :: (MonadIO m, Storable a)

318− => Handle -> SerialT m (Array a) -> m ()

318+ => Handle -> Stream m (Array a) -> m ()

319fromChunks h m = S.mapM_ (liftIO . writeArray h) m

320

321-- | @fromChunksWithBufferOf bufsize handle stream@ writes a stream of arrays

@@ -326,7 +326,7 @@ fromChunks h m = S.mapM_ (liftIO . writeArray h) m

326-- @since 0.7.0

327{-# INLINE fromChunksWithBufferOf #-}

328fromChunksWithBufferOf :: (MonadIO m, Storable a)

329− => Int -> Handle -> SerialT m (Array a) -> m ()

329+ => Int -> Handle -> Stream m (Array a) -> m ()

330fromChunksWithBufferOf n h xs = fromChunks h $ AS.compact n xs

331

332-- | @fromStreamWithBufferOf bufsize handle stream@ writes @stream@ to @handle@

@@ -335,7 +335,7 @@ fromChunksWithBufferOf n h xs = fromChunks h $ AS.compact n xs

335--

336-- @since 0.7.0

337{-# INLINE fromStreamWithBufferOf #-}

338−fromStreamWithBufferOf :: MonadIO m => Int -> Handle -> SerialT m Word8 -> m ()

338+fromStreamWithBufferOf :: MonadIO m => Int -> Handle -> Stream m Word8 -> m ()

339fromStreamWithBufferOf n h m = fromChunks h $ S.arraysOf n m

340-- fromStreamWithBufferOf n h m = fromChunks h $ AS.arraysOf n m

341

@@ -349,7 +349,7 @@ fromStreamWithBufferOf n h m = fromChunks h $ S.arraysOf n m

349--

350-- @since 0.7.0

351{-# INLINE fromStream #-}

352−fromStream :: MonadIO m => Handle -> SerialT m Word8 -> m ()

352+fromStream :: MonadIO m => Handle -> Stream m Word8 -> m ()

353fromStream = fromStreamWithBufferOf defaultChunkSize

354

355-- | 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

48import Data.List.NonEmpty (NonEmpty)

49import Data.Word (Word8)

50import Streamly.Internal.Data.Array.Unboxed (Array)

51−import Streamly.Prelude (SerialT)

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

53#if defined(CABAL_OS_DARWIN)

54import Streamly.Internal.FileSystem.Event.Darwin (Event)

@@ -115,7 +115,7 @@ import qualified Streamly.Internal.FileSystem.Event.Windows as Event

115--

116-- /Pre-release/

117--

118−watch :: NonEmpty (Array Word8) -> SerialT IO Event

118+watch :: NonEmpty (Array Word8) -> Stream IO Event

119#if defined(CABAL_OS_DARWIN)

120watch = Event.watchRecursive

121#else

@@ -129,7 +129,7 @@ watch = Event.watch

129--

130-- /Pre-release/

131--

132−_watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

132+_watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

133_watchRecursive = Event.watchRecursive

134

135-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Darwin.hs+5−5

@@ -174,7 +174,7 @@ import Foreign.Marshal.Array (withArray)

174import Foreign.Ptr (Ptr, castPtr)

175import Foreign.Storable (Storable(..))

176import GHC.IO.Handle.FD (fdToHandle)

177−import Streamly.Prelude (SerialT)

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

178import Streamly.Internal.Data.Cont (contListMap)

179import Streamly.Internal.Data.Parser (Parser)

180import Streamly.Internal.Data.Array.Unboxed.Type (Array(..))

@@ -510,7 +510,7 @@ readOneEvent = do

510 , eventAbsPath = path

511 }

512

513−watchToStream :: Watch -> SerialT IO Event

513+watchToStream :: Watch -> Stream IO Event

514watchToStream (Watch handle _ _) =

515 S.parseMany readOneEvent $ S.unfold FH.read handle

516

@@ -566,7 +566,7 @@ watchToStream (Watch handle _ _) =

566-- /Pre-release/

567--

568watchWith ::

569− (Config -> Config) -> NonEmpty (Array Word8) -> SerialT IO Event

569+ (Config -> Config) -> NonEmpty (Array Word8) -> Stream IO Event

570watchWith f paths = S.bracket before after watchToStream

571

572 where

@@ -578,14 +578,14 @@ watchWith f paths = S.bracket before after watchToStream

578--

579-- >>> watchRecursive = watchWith id

580--

581−watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

581+watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

582watchRecursive = watchWith id

583

584-- | Same as 'watchWith' using defaultConfig and non-recursive mode.

585--

586-- /Unimplemented/

587--

588−watch :: NonEmpty (Array Word8) -> SerialT IO Event

588+watch :: NonEmpty (Array Word8) -> Stream IO Event

589watch _paths = undefined

590

591-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Linux.hs+5−5

@@ -172,7 +172,7 @@ import Foreign.Storable (peek, peekByteOff, sizeOf)

172import GHC.IO.Device (IODeviceType(Stream))

173import GHC.IO.FD (fdFD, mkFD)

174import GHC.IO.Handle.FD (mkHandleFromFD)

175−import Streamly.Prelude (SerialT)

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

176import Streamly.Internal.Data.Parser (Parser)

177import Streamly.Internal.Data.Array.Unboxed.Type (Array(..), byteLength)

178import System.Directory (doesDirectoryExist)

@@ -865,7 +865,7 @@ readOneEvent cfg wt@(Watch _ wdMap) = do

865 pathLen :: Word32 <- peekByteOff ptr (len + 8)

866 return (ewd, eflags, cookie, fromIntegral pathLen)

867

868−watchToStream :: Config -> Watch -> SerialT IO Event

868+watchToStream :: Config -> Watch -> Stream IO Event

869watchToStream cfg wt@(Watch handle _) = do

870 -- Do not use too small a buffer. As per inotify man page:

871 --

@@ -915,7 +915,7 @@ watchToStream cfg wt@(Watch handle _) = do

915--

916-- /Pre-release/

917--

918−watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> SerialT IO Event

918+watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> Stream IO Event

919watchWith f paths = S.bracket before after (watchToStream cfg)

920

921 where

@@ -932,7 +932,7 @@ watchWith f paths = S.bracket before after (watchToStream cfg)

932--

933-- /Pre-release/

934--

935−watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

935+watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

936watchRecursive = watchWith (setRecursiveMode On)

937

938-- | Same as 'watchWith' using defaultConfig and non-recursive mode.

@@ -941,7 +941,7 @@ watchRecursive = watchWith (setRecursiveMode On)

941--

942-- /Pre-release/

943--

944−watch :: NonEmpty (Array Word8) -> SerialT IO Event

944+watch :: NonEmpty (Array Word8) -> Stream IO Event

945watch = watchWith id

946

947-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Windows.hs+7−7

@@ -100,7 +100,7 @@ import Foreign.C.String (peekCWStringLen)

100import Foreign.Marshal.Alloc (alloca, allocaBytes)

101import Foreign.Storable (peekByteOff)

102import Foreign.Ptr (Ptr, FunPtr, castPtr, nullPtr, nullFunPtr, plusPtr)

103−import Streamly.Prelude (SerialT, parallel)

103+import Streamly.Prelude (Stream, parallel)

104import System.Win32.File

105 ( FileNotificationFlag

106 , LPOVERLAPPED

@@ -411,7 +411,7 @@ fILE_ACTION_RENAMED_OLD_NAME = 4

411fILE_ACTION_RENAMED_NEW_NAME :: FileAction

412fILE_ACTION_RENAMED_NEW_NAME = 5

413

414−eventStreamAggr :: (HANDLE, FilePath, Config) -> SerialT IO Event

414+eventStreamAggr :: (HANDLE, FilePath, Config) -> Stream IO Event

415eventStreamAggr (handle, rootPath, cfg) = do

416 let recMode = getConfigRecMode cfg

417 flagMasks = getConfigFlag cfg

@@ -419,7 +419,7 @@ eventStreamAggr (handle, rootPath, cfg) = do

419 $ readDirectoryChanges rootPath handle recMode flagMasks

420

421pathsToHandles ::

422− NonEmpty FilePath -> Config -> SerialT IO (HANDLE, FilePath, Config)

422+ NonEmpty FilePath -> Config -> Stream IO (HANDLE, FilePath, Config)

423pathsToHandles paths cfg = do

424 let pathStream = S.fromList (NonEmpty.toList paths)

425 st2 = S.mapM getWatchHandle pathStream

@@ -437,7 +437,7 @@ utf8ToStringList = NonEmpty.map utf8ToString

437

438-- | Close a Directory handle.

439--

440−closePathHandleStream :: SerialT IO (HANDLE, FilePath, Config) -> IO ()

440+closePathHandleStream :: Stream IO (HANDLE, FilePath, Config) -> IO ()

441closePathHandleStream = S.mapM_ (\(h, _, _) -> closeHandle h)

442

443-- XXX

@@ -471,7 +471,7 @@ closePathHandleStream = S.mapM_ (\(h, _, _) -> closeHandle h)

471--

472-- /Pre-release/

473--

474−watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> SerialT IO Event

474+watchWith :: (Config -> Config) -> NonEmpty (Array Word8) -> Stream IO Event

475watchWith f paths =

476 S.bracket before after (S.concatMapWith parallel eventStreamAggr)

477

@@ -486,7 +486,7 @@ watchWith f paths =

486--

487-- /Pre-release/

488--

489−watchRecursive :: NonEmpty (Array Word8) -> SerialT IO Event

489+watchRecursive :: NonEmpty (Array Word8) -> Stream IO Event

490watchRecursive = watchWith (setRecursiveMode On)

491

492-- | Same as 'watchWith' using defaultConfig and non-recursive mode.

@@ -495,7 +495,7 @@ watchRecursive = watchWith (setRecursiveMode On)

495--

496-- /Pre-release/

497--

498−watch :: NonEmpty (Array Word8) -> SerialT IO Event

498+watch :: NonEmpty (Array Word8) -> Stream IO Event

499watch = watchWith id

500

501getFlag :: DWORD -> Event -> Bool

src/Streamly/Internal/Network/Inet/TCP.hs+10−10

@@ -108,7 +108,7 @@ import Streamly.Internal.Control.ForkLifted (fork)

108import Streamly.Internal.Data.Array.Unboxed.Type (Array(..), writeNUnsafe)

109import Streamly.Internal.Data.Fold.Type (Fold(..))

110import Streamly.Internal.Data.Stream.IsStream.Type (IsStream)

111−import Streamly.Internal.Data.Stream.Serial (SerialT)

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

112import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

113import Streamly.Internal.Data.Unfold.Type (Unfold(..))

114import Streamly.Internal.Network.Socket (SockSpec(..), accept, connections)

@@ -195,7 +195,7 @@ connectionsOnAddrWith

195 => [(SocketOption, Int)]

196 -> (Word8, Word8, Word8, Word8)

197 -> PortNumber

198− -> SerialT m Socket

198+ -> Stream m Socket

199connectionsOnAddrWith opts addr port =

200 connections maxListenQueue SockSpec

201 { sockFamily = AF_INET

@@ -214,7 +214,7 @@ connectionsOnAddr

214 :: MonadAsync m

215 => (Word8, Word8, Word8, Word8)

216 -> PortNumber

217− -> SerialT m Socket

217+ -> Stream m Socket

218connectionsOnAddr = connectionsOnAddrWith []

219

220-- | Like 'connections' but binds on the IPv4 address @0.0.0.0@ i.e. on all

@@ -225,7 +225,7 @@ connectionsOnAddr = connectionsOnAddrWith []

225--

226-- /Pre-release/

227{-# INLINE connectionsOnPort #-}

228−connectionsOnPort :: MonadAsync m => PortNumber -> SerialT m Socket

228+connectionsOnPort :: MonadAsync m => PortNumber -> Stream m Socket

229connectionsOnPort = connectionsOnAddr (0,0,0,0)

230

231-- | Like 'connections' but binds on the localhost IPv4 address @127.0.0.1@.

@@ -236,7 +236,7 @@ connectionsOnPort = connectionsOnAddr (0,0,0,0)

236--

237-- /Pre-release/

238{-# INLINE connectionsOnLocalHost #-}

239−connectionsOnLocalHost :: MonadAsync m => PortNumber -> SerialT m Socket

239+connectionsOnLocalHost :: MonadAsync m => PortNumber -> Stream m Socket

240connectionsOnLocalHost = connectionsOnAddr (127,0,0,1)

241

242-------------------------------------------------------------------------------

@@ -337,7 +337,7 @@ putChunks

337 :: (MonadCatch m, MonadAsync m)

338 => (Word8, Word8, Word8, Word8)

339 -> PortNumber

340− -> SerialT m (Array Word8)

340+ -> Stream m (Array Word8)

341 -> m ()

342putChunks addr port xs =

343 S.drain $ withConnection addr port (\sk -> S.fromEffect $ ISK.putChunks sk xs)

@@ -380,7 +380,7 @@ putBytesWithBufferOf

380 => Int

381 -> (Word8, Word8, Word8, Word8)

382 -> PortNumber

383− -> SerialT m Word8

383+ -> Stream m Word8

384 -> m ()

385putBytesWithBufferOf n addr port m = putChunks addr port $ AS.arraysOf n m

386

@@ -404,7 +404,7 @@ writeWithBufferOf n addr port =

404-- @since 0.7.0

405{-# INLINE putBytes #-}

406putBytes :: (MonadCatch m, MonadAsync m)

407− => (Word8, Word8, Word8, Word8) -> PortNumber -> SerialT m Word8 -> m ()

407+ => (Word8, Word8, Word8, Word8) -> PortNumber -> Stream m Word8 -> m ()

408putBytes = putBytesWithBufferOf defaultChunkSize

409

410-- | Write a stream to the supplied IPv4 host address and port number.

@@ -424,7 +424,7 @@ withInputConnect

424 :: (IsStream t, MonadCatch m, MonadAsync m)

425 => (Word8, Word8, Word8, Word8)

426 -> PortNumber

427− -> SerialT m Word8

427+ -> Stream m Word8

428 -> (Socket -> t m a)

429 -> t m a

430withInputConnect addr port input f = S.bracket pre post handler

@@ -452,6 +452,6 @@ processBytes

452 :: (IsStream t, MonadAsync m, MonadCatch m)

453 => (Word8, Word8, Word8, Word8)

454 -> PortNumber

455− -> SerialT m Word8

455+ -> Stream m Word8

456 -> t m Word8

457processBytes 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)

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

107import Streamly.Internal.Data.Stream.IsStream.Type

108 (IsStream, fromStreamD, toStreamD, adapt)

109−import Streamly.Internal.Data.Stream.Serial (SerialT)

109+import Streamly.Internal.Data.Stream (Stream)

110−import Streamly.Internal.Data.Stream.StreamD (Stream(..), Step (..))

110+import Streamly.Internal.Data.Stream.StreamD (Step (..))

111import Streamly.Internal.Data.SVar (adaptState)

112import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

113import Streamly.Internal.Data.Unboxed (peekWith)

@@ -349,14 +349,14 @@ resumeDecodeUtf8EitherD

349 :: Monad m

350 => DecodeState

351 -> CodePoint

352− -> Stream m Word8

352+ -> D.Stream m Word8

353− -> Stream m (Either DecodeError Char)

353+ -> D.Stream m (Either DecodeError Char)

354−resumeDecodeUtf8EitherD dst codep (Stream step state) =

354+resumeDecodeUtf8EitherD dst codep (D.Stream step state) =

355 let stt =

356 if dst == 0

357 then UTF8DecodeInit state

358 else UTF8Decoding state dst codep

359− in Stream (step' utf8d) stt

359+ in D.Stream (step' utf8d) stt

360 where

361 {-# INLINE_LATE step' #-}

362 step' _ gst (UTF8DecodeInit st) = do

@@ -420,7 +420,7 @@ resumeDecodeUtf8EitherD dst codep (Stream step state) =

420--

421{-# INLINE_NORMAL decodeUtf8EitherD #-}

422decodeUtf8EitherD :: Monad m

423− => Stream m Word8 -> Stream m (Either DecodeError Char)

423+ => D.Stream m Word8 -> D.Stream m (Either DecodeError Char)

424decodeUtf8EitherD = resumeDecodeUtf8EitherD 0 0

425

426-- |

@@ -563,9 +563,9 @@ parseCharUtf8With = ParserD.toParserK . parseCharUtf8WithD

563--

564{-# INLINE_NORMAL decodeUtf8WithD #-}

565decodeUtf8WithD :: Monad m

566− => CodingFailureMode -> Stream m Word8 -> Stream m Char

566+ => CodingFailureMode -> D.Stream m Word8 -> D.Stream m Char

567−decodeUtf8WithD cfm (Stream step state) =

567+decodeUtf8WithD cfm (D.Stream step state) =

568− Stream (step' utf8d) (UTF8DecodeInit state)

568+ D.Stream (step' utf8d) (UTF8DecodeInit state)

569

570 where

571

@@ -648,7 +648,7 @@ decodeUtf8WithD cfm (Stream step state) =

648 step' _ _ Done = return Stop

649

650{-# INLINE decodeUtf8D #-}

651−decodeUtf8D :: Monad m => Stream m Word8 -> Stream m Char

651+decodeUtf8D :: Monad m => D.Stream m Word8 -> D.Stream m Char

652decodeUtf8D = decodeUtf8WithD TransliterateCodingFailure

653

654-- | 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

663decodeUtf8 = fromStreamD . decodeUtf8D . toStreamD

664

665{-# INLINE decodeUtf8D' #-}

666−decodeUtf8D' :: Monad m => Stream m Word8 -> Stream m Char

666+decodeUtf8D' :: Monad m => D.Stream m Word8 -> D.Stream m Char

667decodeUtf8D' = decodeUtf8WithD ErrorOnCodingFailure

668

669-- | 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

675decodeUtf8' = fromStreamD . decodeUtf8D' . toStreamD

676

677{-# INLINE decodeUtf8D_ #-}

678−decodeUtf8D_ :: Monad m => Stream m Word8 -> Stream m Char

678+decodeUtf8D_ :: Monad m => D.Stream m Word8 -> D.Stream m Char

679decodeUtf8D_ = decodeUtf8WithD DropOnCodingFailure

680

681-- | Decode a UTF-8 encoded bytestream to a stream of Unicode characters.

@@ -722,10 +722,10 @@ data FlattenState s a

722decodeUtf8ArraysWithD ::

723 MonadIO m

724 => CodingFailureMode

725− -> Stream m (A.Array Word8)

725+ -> D.Stream m (A.Array Word8)

726− -> Stream m Char

726+ -> D.Stream m Char

727−decodeUtf8ArraysWithD cfm (Stream step state) =

727+decodeUtf8ArraysWithD cfm (D.Stream step state) =

728− Stream (step' utf8d) (OuterLoop state Nothing)

728+ D.Stream (step' utf8d) (OuterLoop state Nothing)

729 where

730 {-# INLINE transliterateOrError #-}

731 transliterateOrError e s =

@@ -824,8 +824,8 @@ decodeUtf8ArraysWithD cfm (Stream step state) =

824{-# INLINE decodeUtf8ArraysD #-}

825decodeUtf8ArraysD ::

826 MonadIO m

827− => Stream m (A.Array Word8)

827+ => D.Stream m (A.Array Word8)

828− -> Stream m Char

828+ -> D.Stream m Char

829decodeUtf8ArraysD = decodeUtf8ArraysWithD TransliterateCodingFailure

830

831-- |

@@ -840,8 +840,8 @@ decodeUtf8Arrays =

840{-# INLINE decodeUtf8ArraysD' #-}

841decodeUtf8ArraysD' ::

842 MonadIO m

843− => Stream m (A.Array Word8)

843+ => D.Stream m (A.Array Word8)

844− -> Stream m Char

844+ -> D.Stream m Char

845decodeUtf8ArraysD' = decodeUtf8ArraysWithD ErrorOnCodingFailure

846

847-- |

@@ -854,8 +854,8 @@ decodeUtf8Arrays' = fromStreamD . decodeUtf8ArraysD' . toStreamD

854{-# INLINE decodeUtf8ArraysD_ #-}

855decodeUtf8ArraysD_ ::

856 MonadIO m

857− => Stream m (A.Array Word8)

857+ => D.Stream m (A.Array Word8)

858− -> Stream m Char

858+ -> D.Stream m Char

859decodeUtf8ArraysD_ = decodeUtf8ArraysWithD DropOnCodingFailure

860

861-- |

@@ -930,7 +930,7 @@ readCharUtf8' =

930-- points for now, one for the ascii chars (fast path) and one for all other

931-- paths (slow path).

932{-# 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

934encodeUtf8D' = D.unfoldMany readCharUtf8'

935

936-- | 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))

950-- https://www.unicode.org/versions/Unicode13.0.0/UnicodeStandard-13.0.pdf

951--

952{-# 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

954encodeUtf8D = D.unfoldMany readCharUtf8

955

956-- | Encode a stream of Unicode characters to a UTF-8 encoded bytestream. Any

@@ -969,7 +969,7 @@ readCharUtf8_ :: Monad m => Unfold m Char Word8

969readCharUtf8_ = readCharUtf8With WNil

970

971{-# 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

973encodeUtf8D_ = D.unfoldMany readCharUtf8_

974

975-- | Encode a stream of Unicode characters to a UTF-8 encoded bytestream. Any

@@ -1003,7 +1003,7 @@ encodeUtf8Lax = encodeUtf8

1003-- "Haskell"

1004--

1005{-# INLINE fromStr# #-}

1006−fromStr# :: MonadIO m => Addr# -> SerialT m Char

1006+fromStr# :: MonadIO m => Addr# -> Stream m Char

1007fromStr# addr = decodeUtf8 $ Stream.fromByteStr# addr

1008

1009-------------------------------------------------------------------------------

@@ -1016,7 +1016,7 @@ fromStr# addr = decodeUtf8 $ Stream.fromByteStr# addr

1016-- /Internal/

1017{-# INLINE encodeObject #-}

1018encodeObject :: MonadIO m =>

1019− (SerialT m Char -> SerialT m Word8)

1019+ (Stream m Char -> Stream m Word8)

1020 -> Unfold m a Char

1021 -> a

1022 -> m (Array Word8)

@@ -1028,7 +1028,7 @@ encodeObject encode u = S.fold Array.write . encode . S.unfold u

1028-- /Internal/

1029{-# INLINE encodeObjects #-}

1030encodeObjects :: (MonadIO m, IsStream t) =>

1031− (SerialT m Char -> SerialT m Word8)

1031+ (Stream m Char -> Stream m Word8)

1032 -> Unfold m a Char

1033 -> t m a

1034 -> t m (Array Word8)

@@ -1040,7 +1040,7 @@ encodeObjects encode u = adapt . Serial.mapM (encodeObject encode u) . adapt

1040-- @since 0.8.0

1041{-# INLINE encodeStrings #-}

1042encodeStrings :: (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)

1044encodeStrings encode = encodeObjects encode Unfold.fromList

1045

1046{-

src/Streamly/Network/Socket.hs+2−2

@@ -52,11 +52,11 @@

52-- server spec addr =

53-- Stream.unfold Socket.accept (maxListenQueue, spec, addr) -- ParallelT IO Socket

54-- & Stream.mapM (Socket.forSocketM echo) -- ParallelT IO ()

55−-- & Stream.fromParallel -- SerialT IO ()

55+-- & Stream.fromParallel -- Stream IO ()

56-- & Stream.drain -- IO ()

57--

58-- echo sk =

59−-- Stream.unfold Socket.readChunks sk -- SerialT IO (Array Word8)

59+-- Stream.unfold Socket.readChunks sk -- Stream IO (Array Word8)

60-- & Stream.fold (Socket.writeChunks sk) -- IO ()

61-- @

62--

src/Streamly/Unicode/Stream.hs+1−1

@@ -38,7 +38,7 @@

38--

39-- = String Literals

40--

41−-- @SerialT Identity Char@ and @Array Char@ are instances of 'IsString' and

41+-- @Stream Identity Char@ and @Array Char@ are instances of 'IsString' and

42-- 'IsList', therefore, 'OverloadedStrings' and 'OverloadedLists' extensions

43-- can be used for convenience when specifying unicode strings literals using

44-- these types.

test/Streamly/Test/Data/Array/Common.hs+3−3

@@ -22,7 +22,7 @@ maxArrLen :: Int

22maxArrLen = defaultChunkSize * 8

24genericTestFrom ::

25− (Int -> SerialT IO Int -> IO (Array Int))

25+ (Int -> Stream IO Int -> IO (Array Int))

26 -> Property

27genericTestFrom arrFold =

28 forAll (choose (0, maxArrLen)) $ \len ->

@@ -38,8 +38,8 @@ testLengthFromStreamN :: Property

38testLengthFromStreamN = genericTestFrom A.fromStreamN

40genericTestFromTo ::

41− (Int -> SerialT IO Int -> IO (Array Int))

41+ (Int -> Stream IO Int -> IO (Array Int))

42− -> (Array Int -> SerialT IO Int)

42+ -> (Array Int -> Stream IO Int)

43 -> ([Int] -> [Int] -> Bool)

44 -> Property

45genericTestFromTo arrFold arrUnfold listEq =

test/Streamly/Test/Data/Array/CommonImports.hs+1−1

@@ -7,7 +7,7 @@ import Test.QuickCheck.Monadic (monadicIO, assert, run)

7import Test.Hspec as H

9import Streamly.Data.Fold (Fold)

10−import Streamly.Prelude (SerialT)

10+import Streamly.Internal.Data.Stream (Stream)

11import Streamly.Test.Common (listEquals)

13import qualified Streamly.Prelude as S

test/Streamly/Test/FileSystem/Handle.hs+15−12

@@ -11,7 +11,7 @@ module Streamly.Test.FileSystem.Handle (main) where

11import Data.Functor.Identity (runIdentity)

12import Data.Word (Word8)

13import Streamly.Internal.Data.Unboxed (sizeOf)

14−import Streamly.Internal.Data.Stream.IsStream (IsStream, SerialT)

14+import Streamly.Internal.Data.Stream (Stream)

15import System.FilePath ((</>))

16import System.IO

17 ( Handle

@@ -28,7 +28,7 @@ import Test.QuickCheck.Monadic (monadicIO, assert, run)

29import qualified Streamly.Data.Fold as Fold

30import 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

32import qualified Streamly.Internal.Data.Array.Unboxed as Array

33import qualified Streamly.Internal.Unicode.Stream as Unicode

@@ -51,9 +51,12 @@ maxTestCount = 10

51chooseWord8 :: (Word8, Word8) -> Gen Word8

52chooseWord8 = choose

54+toList :: Monad m => Stream m a -> m [a]

55+toList = Stream.fold Fold.toList

56+

54utf8ToString :: Array.Array Word8 -> String

57utf8ToString :: Array.Array Word8 -> String

55utf8ToString =

58utf8ToString =

56− runIdentity . Stream.toList . Unicode.decodeUtf8' . Array.toStream

59+ runIdentity . toList . Unicode.decodeUtf8' . Array.toStream

58testData :: String

61testData :: String

59testData = "This is the test data for FileSystem.Handle ??`!@#$%^&*~~))`]"

62testData = "This is the test data for FileSystem.Handle ??`!@#$%^&*~~))`]"

@@ -64,7 +67,7 @@ testDataLarge = concat $ replicate 6000 testData

64testBinData :: String

67testBinData :: String

65testBinData = "01234567890123456789012345678901234567890123456789"

68testBinData = "01234567890123456789012345678901234567890123456789"

67−executor :: (Handle -> SerialT IO Char) -> IO (SerialT IO Char)

70+executor :: (Handle -> Stream IO Char) -> IO (Stream IO Char)

68executor f =

71executor f =

69 withSystemTempDirectory "fs_handle" $ \fp -> do

72 withSystemTempDirectory "fs_handle" $ \fp -> do

70 let fpath = fp </> "tmp_read.txt"

73 let fpath = fp </> "tmp_read.txt"

@@ -72,25 +75,25 @@ executor f =

72 h <- openFile fpath ReadMode

75 h <- openFile fpath ReadMode

73 return $ f h

76 return $ f h

75−readFromHandle :: IO (SerialT IO Char)

78+readFromHandle :: IO (Stream IO Char)

76readFromHandle =

79readFromHandle =

77 let f = Unicode.decodeUtf8 . Stream.unfold Handle.read

80 let f = Unicode.decodeUtf8 . Stream.unfold Handle.read

78 in executor f

81 in executor f

80−readWithBufferFromHandle :: IO (SerialT IO Char)

83+readWithBufferFromHandle :: IO (Stream IO Char)

81readWithBufferFromHandle =

84readWithBufferFromHandle =

82 let f1 = (\h -> (1024, h))

85 let f1 = (\h -> (1024, h))

83 f2 = Unicode.decodeUtf8 . Stream.unfold Handle.readWith . f1

86 f2 = Unicode.decodeUtf8 . Stream.unfold Handle.readWith . f1

84 in executor f2

87 in executor f2

86−readChunksFromHandle :: IO (SerialT IO Char)

89+readChunksFromHandle :: IO (Stream IO Char)

87readChunksFromHandle =

90readChunksFromHandle =

88 let f = Unicode.decodeUtf8

91 let f = Unicode.decodeUtf8

89 . Stream.concatMap Array.toStream

92 . Stream.concatMap Array.toStream

90 . Stream.unfold Handle.readChunks

93 . Stream.unfold Handle.readChunks

91 in executor f

94 in executor f

93−readChunksWithBuffer :: IO (SerialT IO Char)

96+readChunksWithBuffer :: IO (Stream IO Char)

94readChunksWithBuffer =

97readChunksWithBuffer =

95 let f1 = (\h -> (1024, h))

98 let f1 = (\h -> (1024, h))

96 f2 =

99 f2 =

@@ -100,7 +103,7 @@ readChunksWithBuffer =

100 . f1

103 . f1

101 in executor f2

104 in executor f2

102

105

103−testRead :: (IsStream t) => IO (t IO Char) -> Property

106+testRead :: IO (Stream IO Char) -> Property

104testRead fn = monadicIO $ do

107testRead fn = monadicIO $ do

105 let v2 = Stream.fromList testDataLarge

108 let v2 = Stream.fromList testDataLarge

106 v1 <- run fn

109 v1 <- run fn

@@ -126,7 +129,7 @@ testWrite hfold =

126 _ <- Stream.fold (hfold h) $ Stream.fromList list

129 _ <- Stream.fold (hfold h) $ Stream.fromList list

127 hFlush h

130 hFlush h

128 hSeek h AbsoluteSeek 0

131 hSeek h AbsoluteSeek 0

129− ls <- Stream.toList $ Stream.unfold Handle.read h

132+ ls <- toList $ Stream.unfold Handle.read h

130 hClose h

133 hClose h

131 return (ls == list)

134 return (ls == list)

132

135

@@ -151,7 +154,7 @@ testWriteWithChunk =

151 $ Stream.unfold Handle.readChunksWith (1024, hr)

154 $ Stream.unfold Handle.readChunksWith (1024, hr)

152 hFlush hw

155 hFlush hw

153 hSeek hw AbsoluteSeek 0

156 hSeek hw AbsoluteSeek 0

154− ls <- Stream.toList $ Stream.unfold Handle.read hw

157+ ls <- toList $ Stream.unfold Handle.read hw

155 let arr = Array.fromList ls

158 let arr = Array.fromList ls

156 return (testDataLarge == utf8ToString arr)

159 return (testDataLarge == utf8ToString arr)

157

160

@@ -166,7 +169,7 @@ testReadChunksFromToWith from to buffSize res = monadicIO $ run go

166 writeFile fpathRead testBinData

169 writeFile fpathRead testBinData

167 h <- openFile fpathRead ReadMode

170 h <- openFile fpathRead ReadMode

168 ls <-

171 ls <-

169− Stream.toList

172+ toList

170 $ Stream.unfold

173 $ Stream.unfold

171 Handle.readChunksFromToWith (from, to, buffSize, h)

174 Handle.readChunksFromToWith (from, to, buffSize, h)

172 return (res `shouldBe` fmap Array.toList ls)

175 return (res `shouldBe` fmap Array.toList ls)

test/Streamly/Test/Network/Inet/TCP.hs+8−8

@@ -16,7 +16,7 @@ import Data.Word (Word8)

16import Network.Socket (Socket, PortNumber)

17import Streamly.Internal.Control.Monad (discard)

18import Streamly.Internal.System.IO (defaultChunkSize)

19−import Streamly.Prelude (SerialT)

19+import Streamly.Internal.Data.Stream (Stream)

20import Test.QuickCheck (Property)

21import Test.QuickCheck.Monadic (monadicIO, assert, run)

@@ -78,22 +78,22 @@ server listener port sem handler = do

78remoteAddr :: (Word8,Word8,Word8,Word8)

79remoteAddr = (127, 0, 0, 1)

81−sender :: PortNumber -> MVar () -> SerialT IO Char

81+sender :: PortNumber -> MVar () -> Stream IO Char

82sender port sem = do

83 _ <- liftIO $ takeMVar sem

84 liftIO $ threadDelay 1000000 -- wait for server

85− Stream.replicate 1000 testData -- SerialT IO String

85+ Stream.replicate 1000 testData -- Stream IO String

86− & Stream.concatMap Stream.fromList -- SerialT IO Char

86+ & Stream.concatMap Stream.fromList -- Stream IO Char

87− & Unicode.encodeLatin1 -- SerialT IO Word8

87+ & Unicode.encodeLatin1 -- Stream IO Word8

88− & TCP.processBytes remoteAddr port -- SerialT IO Word8

88+ & TCP.processBytes remoteAddr port -- Stream IO Word8

89− & Unicode.decodeLatin1 -- SerialT IO Char

89+ & Unicode.decodeLatin1 -- Stream IO Char

91execute

92 :: Unfold.Unfold IO PortNumber Socket

93 -> PortNumber

94 -> Int

95 -> (Socket -> IO ())

96− -> IO (SerialT IO Char)

96+ -> IO (Stream IO Char)

97execute listener port size handler = do

98 sem <- newEmptyMVar

99 tid <- forkIO $ server listener port sem handler

test/Streamly/Test/Network/Socket.hs+8−8

@@ -16,7 +16,7 @@ import Data.Word (Word8)

16import Network.Socket (Socket, PortNumber)

17import Streamly.Internal.Control.Monad (discard)

18import Streamly.Internal.System.IO (defaultChunkSize)

19−import Streamly.Prelude (SerialT)

19+import Streamly.Internal.Data.Stream (Stream)

20import Test.QuickCheck (Property)

21import Test.QuickCheck.Monadic (monadicIO, assert, run)

@@ -89,17 +89,17 @@ server port sem handler = do

89remoteAddr :: (Word8,Word8,Word8,Word8)

90remoteAddr = (127, 0, 0, 1)

92−sender :: PortNumber -> MVar () -> SerialT IO Char

92+sender :: PortNumber -> MVar () -> Stream IO Char

93sender port sem = do

94 _ <- liftIO $ takeMVar sem

95 liftIO $ threadDelay 1000000 -- wait for server

96− Stream.replicate 1000 testData -- SerialT IO String

96+ Stream.replicate 1000 testData -- Stream IO String

97− & Stream.concatMap Stream.fromList -- SerialT IO Char

97+ & Stream.concatMap Stream.fromList -- Stream IO Char

98− & Unicode.encodeLatin1 -- SerialT IO Word8

98+ & Unicode.encodeLatin1 -- Stream IO Word8

99− & TCP.processBytes remoteAddr port -- SerialT IO Word8

99+ & TCP.processBytes remoteAddr port -- Stream IO Word8

100− & Unicode.decodeLatin1 -- SerialT IO Char

100+ & Unicode.decodeLatin1 -- Stream IO Char

101

102−execute :: PortNumber -> Int -> (Socket -> IO ()) -> IO (SerialT IO Char)

102+execute :: PortNumber -> Int -> (Socket -> IO ()) -> IO (Stream IO Char)

103execute port size handler = do

104 sem <- newEmptyMVar

105 tid <- forkIO $ server port sem handler

test/Streamly/Test/Unicode/Char.hs+3−3

@@ -21,11 +21,11 @@ import Streamly.Internal.Unicode.Char

21 ( NormalizationMode(NFC, NFD, NFKC, NFKD)

22 , normalize

23 )

24−import Streamly.Internal.Data.Stream.IsStream (SerialT)

24+import Streamly.Internal.Data.Stream (Stream)

25import Text.Printf (printf)

26import System.FilePath.Posix ((</>))

28−import qualified Streamly.Internal.Data.Stream.IsStream as S

28+import qualified Streamly.Internal.Data.Stream as S

29import qualified Streamly.Internal.Data.Fold as FL

30import qualified System.Directory as Dir

@@ -35,7 +35,7 @@ chrToHex = map toUpper . printf "%.4x" . ord

35strToHex :: [Char] -> String

36strToHex = unwords . map chrToHex

38−type Text = SerialT IO Char

38+type Text = Stream IO Char

40checkEqual :: String -> (Text -> Text) -> (Text, Text) -> IO Bool

41checkEqual opName op (mc1, mc2) = do