38d21d5 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Fix the default stream type to SerialT

38d21d5Harendra Kumar9 years ago

Changelog.md+8

compare with master

unifiedsplit

@@ -16,6 +16,14 @@

16 different behavior for each type. See the documentation for more details. To

17 adapt to this change replace any usage of `<|>` with `parallel` and

18 `empty` with `nil`.

19+* Streams now default to the `SerialT` type unless explicitly specified using a

20+ type combinator. This also means that you do not have to explicitly specify a

21+ stream type now, the default will be used. This changes reduces puzzling type

22+ errors for beginners. It includes the following two changes:

23+ * Change the type of all stream elimination functions to `SerialT`. This

24+ makes sure that the stream type is always fixed at all exits.

25+ * Change the type combinators to only fix the argument stream type and

26+ the resulting stream type remains polymorphic.

19* Change the type of `foldrM` to make it consistent with `foldrM` in base.

27* Change the type of `foldrM` to make it consistent with `foldrM` in base.

21### Deprecations

29### Deprecations

src/Streamly/Examples/SearchEngineQuery.hs+1−1

@@ -15,7 +15,7 @@ searchEngineQuery = do

15 where

16 get :: IsStream t => String -> t IO ()

17 google, bing, duckduckgo :: IsStream t => t IO ()

18− get s = adapt . serially $ liftIO (httpNoBody (parseRequest_ s) >> putStrLn (show s))

18+ get s = serially $ liftIO (httpNoBody (parseRequest_ s) >> putStrLn (show s))

19 google = get "https://www.google.com/search?q=haskell"

20 bing = get "https://www.bing.com/search?q=haskell"

21 duckduckgo = get "https://www.duckduckgo.com/?q=haskell"

src/Streamly/Prelude.hs+1−1

@@ -313,7 +313,7 @@ toHandle h m = go (toStream m)

313

314-- | Convert a stream into a list in the underlying monad.

315{-# INLINABLE toList #-}

316−toList :: (IsStream t, Monad m) => t m a -> m [a]

316+toList :: Monad m => SerialT m a -> m [a]

317toList = foldrM (\a xs -> return (a : xs)) []

318

319-- | Take first 'n' elements from the stream and discard the rest.

src/Streamly/Streams.hs+20−20

@@ -220,7 +220,7 @@ streamFold sv step blank m =

220 in (S.runStream (toStream m)) sv blank yield

221

222-- | Run a streaming composition, discard the results.

223−runStream :: (Monad m, IsStream t) => t m a -> m ()

223+runStream :: Monad m => SerialT m a -> m ()

224runStream m = go (toStream m)

225 where

226 go m1 =

@@ -232,7 +232,7 @@ runStream m = go (toStream m)

232-- | Same as 'runStream'

233{-# Deprecated runStreaming "Please use runStream instead." #-}

234runStreaming :: (Monad m, IsStream t) => t m a -> m ()

235−runStreaming = runStream

235+runStreaming = runStream . adapt

236

237-- | Write a stream to an 'SVar' in a non-blocking manner. The stream can then

238-- be read back from the SVar using 'fromSVar'.

@@ -1071,33 +1071,33 @@ adapt :: (IsStream t1, IsStream t2) => t1 m a -> t2 m a

1071adapt = fromStream . toStream

1072

1073-- | Interpret an ambiguously typed stream as 'SerialT'.

1074−serially :: SerialT m a -> SerialT m a

1074+serially :: IsStream t => SerialT m a -> t m a

1075−serially x = x

1075+serially = adapt

1076

1077-- | Interpret an ambiguously typed stream as 'InterleavedT'.

1078−interleaving :: InterleavedT m a -> InterleavedT m a

1078+interleaving :: IsStream t => InterleavedT m a -> t m a

1079−interleaving x = x

1079+interleaving = adapt

1080

1081-- | Interpret an ambiguously typed stream as 'AParallelT'.

1082−aparallely :: AParallelT m a -> AParallelT m a

1082+aparallely :: IsStream t => AParallelT m a -> t m a

1083−aparallely x = x

1083+aparallely = adapt

1084

1085-- | Same as 'aparallely'.

1086{-# DEPRECATED asyncly "Please use aparallely instead." #-}

1087−asyncly :: AParallelT m a -> AParallelT m a

1087+asyncly :: IsStream t => AParallelT m a -> t m a

1088asyncly = aparallely

1089

1090-- | Interpret an ambiguously typed stream as 'ParallelT'.

1091−parallely :: ParallelT m a -> ParallelT m a

1091+parallely :: IsStream t => ParallelT m a -> t m a

1092−parallely x = x

1092+parallely = adapt

1093

1094-- | Interpret an ambiguously typed stream as 'ZipSerial'.

1095−zipping :: ZipSerial m a -> ZipSerial m a

1095+zipping :: IsStream t => ZipSerial m a -> t m a

1096−zipping x = x

1096+zipping = adapt

1097

1098-- | Interpret an ambiguously typed stream as 'ZipAsync'.

1099−zippingAsync :: ZipAsync m a -> ZipAsync m a

1099+zippingAsync :: IsStream t => ZipAsync m a -> t m a

1100−zippingAsync x = x

1100+zippingAsync = adapt

1101

1102-------------------------------------------------------------------------------

1103-- Running Streams, convenience functions specialized to types

@@ -1114,11 +1114,11 @@ runStreamT = runSerialT

1114

1115-- | Same as @runStream . interleaving@.

1116runInterleavedT :: Monad m => InterleavedT m a -> m ()

1117−runInterleavedT = runStream

1117+runInterleavedT = runStream . interleaving

1118

1119-- | Same as @runStream . aparallely@.

1120runAParallelT :: Monad m => AParallelT m a -> m ()

1121−runAParallelT = runStream

1121+runAParallelT = runStream . aparallely

1122

1123-- | Same as @runAParallelT@.

1124{-# Deprecated runAsyncT "Please use runAParallelT instead." #-}

@@ -1127,11 +1127,11 @@ runAsyncT = runAParallelT

1127

1128-- | Same as @runStream . parallely@.

1129runParallelT :: Monad m => ParallelT m a -> m ()

1130−runParallelT = runStream

1130+runParallelT = runStream . parallely

1131

1132-- | Same as @runStream . zipping@.

1133runZipSerial :: Monad m => ZipSerial m a -> m ()

1134−runZipSerial = runStream

1134+runZipSerial = runStream . zipping

1135

1136{-# Deprecated runZipStream "Please use runZipSerial instead." #-}

1137-- | Same as ZipSerial.

@@ -1140,7 +1140,7 @@ runZipStream = runZipSerial

1140

1141-- | Same as @runStream . zippingAsync@.

1142runZipAsync :: Monad m => ZipAsync m a -> m ()

1143−runZipAsync = runStream

1143+runZipAsync = runStream . zippingAsync

1144

1145------------------------------------------------------------------------------

1146-- Fold Utilities

test/Main.hs+16−16

@@ -139,8 +139,8 @@ main = hspec $ do

139

140 describe "Nested parallel and serial compositions" $ do

141 let t = timed

142− p = adapt . parallely

142+ p = parallely

143− s = adapt . serially

143+ s = serially

144 {-

145 -- This is not correct, the result can also be [4,4,8,0,8,0,2,2]

146 -- because of parallelism of [8,0] and [8,0].

@@ -375,14 +375,14 @@ timed :: MonadIO (t IO) => Int -> t IO Int

375timed x = liftIO (threadDelay (x * 100000)) >> return x

376

377interleaveCheck :: (IsStream t, Semigroup (t IO Int))

378− => (t IO Int -> t IO Int) -> Spec

378+ => (t IO Int -> SerialT IO Int) -> Spec

379interleaveCheck t =

380 it "Interleave four" $

381 (A.toList . t) ((singleton 0 <> singleton 1) <> (singleton 100 <> singleton 101))

382 `shouldReturn` ([0, 100, 1, 101])

383

384−parallelCheck :: (IsStream t, Semigroup (t IO Int), MonadIO (t IO))

384+parallelCheck :: (Semigroup (t IO Int), MonadIO (t IO))

385− => (t IO Int -> t IO Int) -> Spec

385+ => (t IO Int -> SerialT IO Int) -> Spec

386parallelCheck t = do

387 it "Parallel ordering left associated" $

388 (A.toList . t) (((event 4 <> event 3) <> event 2) <> event 1)

@@ -395,7 +395,7 @@ parallelCheck t = do

395 where event n = (liftIO $ threadDelay (n * 100000)) >> (return n)

396

397compose :: (IsStream t, Semigroup (t IO Int))

398− => (t IO Int -> t IO Int) -> t IO Int -> ([Int] -> [Int]) -> Spec

398+ => (t IO Int -> SerialT IO Int) -> t IO Int -> ([Int] -> [Int]) -> Spec

399compose t z srt = do

400 -- XXX these should get covered by the property tests

401 it "Compose mempty, mempty" $

@@ -434,13 +434,13 @@ composeAndComposeSimple

434 , Semigroup (t2 IO Int)

435#endif

436 )

437− => (t1 IO Int -> t1 IO Int)

437+ => (t1 IO Int -> SerialT IO Int)

438 -> (t2 IO Int -> t2 IO Int)

439 -> [[Int]] -> Spec

440composeAndComposeSimple t1 t2 answer = do

441 let rfold = adapt . t2 . foldMapWith (<>) return

442 it "Compose right associated outer expr, right folded inner" $

443− ((A.toList. t1) (rfold [1,2,3] <> (rfold [4,5,6] <> rfold [7,8,9])))

443+ ((A.toList . t1) (rfold [1,2,3] <> (rfold [4,5,6] <> rfold [7,8,9])))

444 `shouldReturn` (answer !! 0)

445

446 it "Compose left associated outer expr, right folded inner" $

@@ -463,10 +463,10 @@ loops

463 -> ([Int] -> [Int])

464 -> Spec

465loops t tsrt hsrt = do

466− it "Tail recursive loop" $ (A.toList (loopTail 0) >>= return . tsrt)

466+ it "Tail recursive loop" $ ((A.toList . adapt) (loopTail 0) >>= return . tsrt)

467 `shouldReturn` [0..3]

468

469− it "Head recursive loop" $ (A.toList (loopHead 0) >>= return . hsrt)

469+ it "Head recursive loop" $ ((A.toList . adapt) (loopHead 0) >>= return . hsrt)

470 `shouldReturn` [0..3]

471

472 where

@@ -482,7 +482,7 @@ loops t tsrt hsrt = do

482

483bindAndComposeSimple

484 :: ( IsStream t1, IsStream t2, Semigroup (t2 IO Int), Monad (t2 IO))

485− => (t1 IO Int -> t1 IO Int)

485+ => (t1 IO Int -> SerialT IO Int)

486 -> (t2 IO Int -> t2 IO Int)

487 -> Spec

488bindAndComposeSimple t1 t2 = do

@@ -499,7 +499,7 @@ bindAndComposeSimple t1 t2 = do

499bindAndComposeHierarchy

500 :: ( IsStream t1, Monad (t1 IO)

501 , IsStream t2, Monad (t2 IO))

502− => (t1 IO Int -> t1 IO Int)

502+ => (t1 IO Int -> SerialT IO Int)

503 -> (t2 IO Int -> t2 IO Int)

504 -> ([t2 IO Int] -> t2 IO Int)

505 -> Spec

@@ -550,14 +550,14 @@ mixedOps = do

550 x <- return 1

551 y <- return 2

552 z <- do

553− x1 <- adapt . parallely $ return 1 <> return 2

553+ x1 <- parallely $ return 1 <> return 2

554 liftIO $ return ()

555 liftIO $ putStr ""

556− y1 <- adapt . aparallely $ return 1 <> return 2

556+ y1 <- aparallely $ return 1 <> return 2

557 z1 <- do

558 x11 <- return 1 <> return 2

559− y11 <- adapt . aparallely $ return 1 <> return 2

559+ y11 <- aparallely $ return 1 <> return 2

560− z11 <- adapt . interleaving $ return 1 <> return 2

560+ z11 <- interleaving $ return 1 <> return 2

561 liftIO $ return ()

562 liftIO $ putStr ""

563 return (x11 + y11 + z11)

test/Prop.hs+20−23

@@ -36,7 +36,7 @@ equals eq stream list = do

37constructWithReplicateM

38 :: IsStream t

39− => (t IO Int -> t IO Int)

39+ => (t IO Int -> SerialT IO Int)

40 -> Word8

41 -> Property

42constructWithReplicateM op len =

@@ -47,11 +47,10 @@ constructWithReplicateM op len =

47 equals (==) stream list

49transformFromList

50− :: IsStream t

51− => ([Int] -> t IO Int)

50+ :: ([Int] -> t IO Int)

52 -> ([Int] -> [Int] -> Bool)

51 -> ([Int] -> [Int] -> Bool)

53 -> ([Int] -> [Int])

52 -> ([Int] -> [Int])

54− -> (t IO Int -> t IO Int)

53+ -> (t IO Int -> SerialT IO Int)

55 -> [Int]

54 -> [Int]

56 -> Property

55 -> Property

57transformFromList constr eq listOp op a =

56transformFromList constr eq listOp op a =

@@ -61,9 +60,8 @@ transformFromList constr eq listOp op a =

61 equals eq stream list

60 equals eq stream list

63foldFromList

62foldFromList

64− :: IsStream t

65− => ([Int] -> t IO Int)

63+ :: ([Int] -> t IO Int)

66− -> (t IO Int -> t IO Int)

64+ -> (t IO Int -> SerialT IO Int)

67 -> ([Int] -> [Int] -> Bool)

65 -> ([Int] -> [Int] -> Bool)

68 -> [Int]

66 -> [Int]

69 -> Property

67 -> Property

@@ -96,10 +94,10 @@ elemOp constr op streamOp listOp (x, xs) =

96 equals (==) stream list

94 equals (==) stream list

98functorOps

96functorOps

99− :: (IsStream t, Functor (t IO))

97+ :: Functor (t IO)

100 => ([Int] -> t IO Int)

98 => ([Int] -> t IO Int)

101 -> String

99 -> String

102− -> (t IO Int -> t IO Int)

100+ -> (t IO Int -> SerialT IO Int)

103 -> ([Int] -> [Int] -> Bool)

101 -> ([Int] -> [Int] -> Bool)

104 -> Spec

102 -> Spec

105functorOps constr desc t eq = do

103functorOps constr desc t eq = do

@@ -110,7 +108,7 @@ transformOps

110 :: IsStream t

108 :: IsStream t

111 => ([Int] -> t IO Int)

109 => ([Int] -> t IO Int)

112 -> String

110 -> String

113− -> (t IO Int -> t IO Int)

111+ -> (t IO Int -> SerialT IO Int)

114 -> ([Int] -> [Int] -> Bool)

112 -> ([Int] -> [Int] -> Bool)

115 -> Spec

113 -> Spec

116transformOps constr desc t eq = do

114transformOps constr desc t eq = do

@@ -181,10 +179,9 @@ eliminationOps constr desc t = do

181-- head/tail/last may depend on the order in case of parallel streams

179-- head/tail/last may depend on the order in case of parallel streams

182-- so we test these only for serial streams.

180-- so we test these only for serial streams.

183serialEliminationOps

181serialEliminationOps

184− :: IsStream t

185− => ([Int] -> t IO Int)

182+ :: ([Int] -> t IO Int)

186 -> String

183 -> String

187− -> (t IO Int -> t IO Int)

184+ -> (t IO Int -> SerialT IO Int)

188 -> Spec

185 -> Spec

189serialEliminationOps constr desc t = do

186serialEliminationOps constr desc t = do

190 prop (desc ++ " head") $ eliminateOp constr (wrapMaybe head) $ A.head . t

187 prop (desc ++ " head") $ eliminateOp constr (wrapMaybe head) $ A.head . t

@@ -214,7 +211,7 @@ semigroupOps

214#endif

211#endif

215 , Monoid (t IO Int))

212 , Monoid (t IO Int))

216 => String

213 => String

217− -> (t IO Int -> t IO Int)

214+ -> (t IO Int -> SerialT IO Int)

218 -> ([Int] -> [Int] -> Bool)

215 -> ([Int] -> [Int] -> Bool)

219 -> Spec

216 -> Spec

220semigroupOps desc t eq = do

217semigroupOps desc t eq = do

@@ -222,9 +219,9 @@ semigroupOps desc t eq = do

222 prop (desc ++ " mappend") $ foldFromList (foldMapWith mappend singleton) t eq

219 prop (desc ++ " mappend") $ foldFromList (foldMapWith mappend singleton) t eq

223

220

224applicativeOps

221applicativeOps

225− :: (IsStream t, Applicative (t IO))

222+ :: Applicative (t IO)

226 => ([Int] -> t IO Int)

223 => ([Int] -> t IO Int)

227− -> (t IO (Int, Int) -> t IO (Int, Int))

224+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))

228 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)

225 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)

229 -> ([Int], [Int])

226 -> ([Int], [Int])

230 -> Property

227 -> Property

@@ -236,7 +233,7 @@ applicativeOps constr t eq (a, b) = monadicIO $ do

236zipApplicative

233zipApplicative

237 :: (IsStream t, Applicative (t IO))

234 :: (IsStream t, Applicative (t IO))

238 => ([Int] -> t IO Int)

235 => ([Int] -> t IO Int)

239− -> (t IO (Int, Int) -> t IO (Int, Int))

236+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))

240 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)

237 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)

241 -> ([Int], [Int])

238 -> ([Int], [Int])

242 -> Property

239 -> Property

@@ -252,7 +249,7 @@ zipApplicative constr t eq (a, b) = monadicIO $ do

252zipMonadic

249zipMonadic

253 :: (IsStream t, Monad (t IO))

250 :: (IsStream t, Monad (t IO))

254 => ([Int] -> t IO Int)

251 => ([Int] -> t IO Int)

255− -> (t IO (Int, Int) -> t IO (Int, Int))

252+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))

256 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)

253 -> ([(Int, Int)] -> [(Int, Int)] -> Bool)

257 -> ([Int], [Int])

254 -> ([Int], [Int])

258 -> Property

255 -> Property

@@ -271,9 +268,9 @@ zipMonadic constr t eq (a, b) =

271 equals eq stream2 list

268 equals eq stream2 list

272

269

273monadThen

270monadThen

274− :: (IsStream t, Monad (t IO))

271+ :: Monad (t IO)

275 => ([Int] -> t IO Int)

272 => ([Int] -> t IO Int)

276− -> (t IO Int -> t IO Int)

273+ -> (t IO Int -> SerialT IO Int)

277 -> ([Int] -> [Int] -> Bool)

274 -> ([Int] -> [Int] -> Bool)

278 -> ([Int], [Int])

275 -> ([Int], [Int])

279 -> Property

276 -> Property

@@ -283,9 +280,9 @@ monadThen constr t eq (a, b) = monadicIO $ do

283 equals eq stream list

280 equals eq stream list

284

281

285monadBind

282monadBind

286− :: (IsStream t, Monad (t IO))

283+ :: Monad (t IO)

287 => ([Int] -> t IO Int)

284 => ([Int] -> t IO Int)

288− -> (t IO Int -> t IO Int)

285+ -> (t IO Int -> SerialT IO Int)

289 -> ([Int] -> [Int] -> Bool)

286 -> ([Int] -> [Int] -> Bool)

290 -> ([Int], [Int])

287 -> ([Int], [Int])

291 -> Property

288 -> Property

@@ -313,7 +310,7 @@ main = hspec $ do

313 `shouldReturn` (take 100 $ iterate (+ 1) 0)

310 `shouldReturn` (take 100 $ iterate (+ 1) 0)

314

311

315 let folded :: IsStream t => [a] -> t IO a

312 let folded :: IsStream t => [a] -> t IO a

316− folded = adapt . serially . (\xs ->

313+ folded = serially . (\xs ->

317 case xs of

314 case xs of

318 [x] -> return x -- singleton stream case

315 [x] -> return x -- singleton stream case

319 _ -> foldMapWith (<>) return xs

316 _ -> foldMapWith (<>) return xs