67600c0 · streamly · git.iko.soy

git.iko.soy/streamly

Add some convenient runner functions

commit67600c03b003dbe8ec061366049bb3e308da5ae3 authorHarendra Kumar <harendra.kumar@gmail.com> dateFri 21 Dec 2018, 00:20 (8 years ago) parentd08c057

5 files changed+76−30

compare with master

unifiedsplit

Changelog.md+1 examples/AcidRain.hs+13−9 src/Streamly.hs+10−21 src/Streamly/Prelude.hs+34 src/Streamly/Streams/Prelude.hs+18

Changelog.md+1

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

1212 * Generation: `replicate`, `fromIndices`, `fromIndicesM`

1313 * Enumeration: `Enumerable`, `enumerateFrom`, `enumerateFromTo`,

1414 `enumerateFromThen`, `enumerateFromThenTo`, `enumerate`

15+ * Running: `runIters`, `runWhile`

1516 * Folds: `(!!)`, `maximumBy`, `minimumBy`, `the`

1617 * Scans: `scanl1'`, `scanl1M'

1718 * Filters: `uniq`, `insertBy`, `deleteBy`, `findM`

examples/AcidRain.hs+13−9

@@ -25,27 +25,31 @@ userAction = S.repeatM $ liftIO askUser

2525acidRain :: MonadAsync m => SerialT m Event

2626acidRain = asyncly $ constRate 1 $ S.repeatM $ liftIO $ return $ Harm 1

2727

28−data Status = Check | Done

28+data Result = Check | Done

2929

30−processEvents :: (MonadAsync m, MonadState Int m) => SerialT m Status

31−processEvents = do

30+runEvents :: (MonadAsync m, MonadState Int m) => SerialT m Result

31+runEvents = do

3232 event <- userAction `parallel` acidRain

3333 case event of

3434 Harm n -> modify (\h -> h - n) >> return Check

3535 Heal n -> modify (\h -> h + n) >> return Check

3636 Quit -> return Done

3737

38−checkStatus status =

39− case status of

40− Done -> liftIO $ putStrLn "You quit!" >> return False

38+data Status = Alive | GameOver deriving Eq

39+

40+getStatus :: (MonadAsync m, MonadState Int m) => Result -> m Status

41+getStatus result =

42+ case result of

43+ Done -> liftIO $ putStrLn "You quit!" >> return GameOver

4144 Check -> do

4245 h <- get

4346 liftIO $ if (h <= 0)

44− then putStrLn "You die!" >> return False

45− else putStrLn ("Health = " <> show h) >> return True

47+ then putStrLn "You die!" >> return GameOver

48+ else putStrLn ("Health = " <> show h) >> return Alive

4649

4750main :: IO ()

4851main = do

4952 putStrLn "Your health is deteriorating due to acid rain,\

5053 \ type \"potion\" or \"quit\""

51− void $ runStateT (S.any (== False) $ S.mapM checkStatus $ processEvents) 60

54+ let runGame = S.runWhile (== Alive) $ S.mapM getStatus runEvents

55+ void $ runStateT runGame 60

src/Streamly.hs+10−21

@@ -89,8 +89,7 @@ module Streamly

8989 , ZipAsyncM

9090

9191 -- * Running Streams

92− , runStream

93−

92+ , P.runStream

9493 -- * Parallel Function Application

9594 -- $application

9695 , (|$)

@@ -153,6 +152,7 @@ module Streamly

153152

154153 -- * Re-exports

155154 , Semigroup (..)

155+

156156 -- * Deprecated

157157 , Streaming

158158 , runStreaming

@@ -184,7 +184,7 @@ import Streamly.Streams.Serial

184184import Streamly.Streams.StreamK hiding (runStream, serial)

185185import Streamly.Streams.Zip

186186

187−import qualified Streamly.Streams.StreamD as D

187+import qualified Streamly.Prelude as P

188188import qualified Streamly.Streams.StreamK as K

189189

190190-- XXX This should perhaps be moved to Prelude.

@@ -193,65 +193,54 @@ import qualified Streamly.Streams.StreamK as K

193193-- Eliminating a stream

194194------------------------------------------------------------------------------

195195

196−-- | Run a streaming composition, discard the results. By default it interprets

197−-- the stream as 'SerialT', to run other types of streams use the type adapting

198−-- combinators for example @runStream . 'asyncly'@.

199−--

200−-- @since 0.2.0

201−{-# INLINE_EARLY runStream #-}

202−runStream :: Monad m => SerialT m a -> m ()

203−runStream m = D.runStream $ D.fromStreamK (toStream m)

204−{-# RULES "runStream fallback to CPS" [1]

205− forall a. D.runStream (D.fromStreamK a) = K.runStream a #-}

206−

207196-- | Same as 'runStream'

208197--

209198-- @since 0.1.0

210199{-# DEPRECATED runStreaming "Please use runStream instead." #-}

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

212−runStreaming = runStream . K.adapt

201+runStreaming = P.runStream . K.adapt

213202

214203-- | Same as @runStream@.

215204--

216205-- @since 0.1.0

217206{-# DEPRECATED runStreamT "Please use runStream instead." #-}

218207runStreamT :: Monad m => SerialT m a -> m ()

219−runStreamT = runStream

208+runStreamT = P.runStream

220209

221210-- | Same as @runStream . wSerially@.

222211--

223212-- @since 0.1.0

224213{-# DEPRECATED runInterleavedT "Please use 'runStream . interleaving' instead." #-}

225214runInterleavedT :: Monad m => WSerialT m a -> m ()

226−runInterleavedT = runStream . K.adapt

215+runInterleavedT = P.runStream . K.adapt

227216

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

229218--

230219-- @since 0.1.0

231220{-# DEPRECATED runParallelT "Please use 'runStream . parallely' instead." #-}

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

233−runParallelT = runStream . K.adapt

222+runParallelT = P.runStream . K.adapt

234223

235224-- | Same as @runStream . asyncly@.

236225--

237226-- @since 0.1.0

238227{-# DEPRECATED runAsyncT "Please use 'runStream . asyncly' instead." #-}

239228runAsyncT :: Monad m => AsyncT m a -> m ()

240−runAsyncT = runStream . K.adapt

229+runAsyncT = P.runStream . K.adapt

241230

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

243232--

244233-- @since 0.1.0

245234{-# DEPRECATED runZipStream "Please use 'runStream . zipSerially instead." #-}

246235runZipStream :: Monad m => ZipSerialM m a -> m ()

247−runZipStream = runStream . K.adapt

236+runZipStream = P.runStream . K.adapt

248237

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

250239--

251240-- @since 0.1.0

252241{-# DEPRECATED runZipAsync "Please use 'runStream . zipAsyncly instead." #-}

253242runZipAsync :: Monad m => ZipAsyncM m a -> m ()

254−runZipAsync = runStream . K.adapt

243+runZipAsync = P.runStream . K.adapt

255244

256245------------------------------------------------------------------------------

257246-- Documentation

src/Streamly/Prelude.hs+34

@@ -180,6 +180,11 @@ module Streamly.Prelude

180180 , foldx

181181 , foldxM

182182

183+ -- ** Run Effects

184+ , runStream

185+ , runN

186+ , runWhile

187+

183188 -- ** To Elements

184189 -- | Folds that extract selected elements of a stream or their properties.

185190 , (!!)

@@ -1346,6 +1351,35 @@ foldlM' step begin m = S.foldlM' step begin $ toStreamS m

13461351-- Specialized folds

13471352------------------------------------------------------------------------------

13481353

1354+-- | Run a stream, discarding the results. By default it interprets the stream

1355+-- as 'SerialT', to run other types of streams use the type adapting

1356+-- combinators for example @runStream . 'asyncly'@.

1357+--

1358+-- @since 0.2.0

1359+{-# INLINE runStream #-}

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

1361+runStream = P.runStream

1362+

1363+-- |

1364+-- > runN n = runStream . take n

1365+--

1366+-- Run maximum up to @n@ iterations of a stream.

1367+--

1368+-- @since 0.6.0

1369+{-# INLINE runN #-}

1370+runN :: Monad m => Int -> SerialT m a -> m ()

1371+runN n = runStream . take n

1372+

1373+-- |

1374+-- > runWhile p = runStream . takeWhile p

1375+--

1376+-- Run a stream as long as the predicate holds true.

1377+--

1378+-- @since 0.6.0

1379+{-# INLINE runWhile #-}

1380+runWhile :: Monad m => (a -> Bool) -> SerialT m a -> m ()

1381+runWhile p = runStream . takeWhile p

1382+

13491383-- | Determine whether the stream is empty.

13501384--

13511385-- @since 0.1.1

src/Streamly/Streams/Prelude.hs+18

@@ -22,6 +22,9 @@ module Streamly.Streams.Prelude

2222 fromStreamS

2323 , toStreamS

2424

25+ -- * Running Effects

26+ , runStream

27+

2528 -- * Conversion operations

2629 , fromList

2730 , toList

@@ -72,6 +75,21 @@ toStreamS = S.fromStreamK . toStream

7275-- Conversions

7376------------------------------------------------------------------------------

7477

78+-- | Run a streaming composition, discard the results. By default it interprets

79+-- the stream as 'SerialT', to run other types of streams use the type adapting

80+-- combinators for example @run . 'asyncly'@.

81+--

82+-- @since 0.6.0

83+{-# INLINE_EARLY runStream #-}

84+runStream :: (IsStream t, Monad m) => t m a -> m ()

85+runStream m = D.runStream $ D.fromStreamK (toStream m)

86+{-# RULES "run fallback to CPS" [1]

87+ forall a. D.runStream (D.fromStreamK a) = K.runStream a #-}

88+

89+------------------------------------------------------------------------------

90+-- Conversions

91+------------------------------------------------------------------------------

92+

7593-- |

7694-- @

7795-- fromList = 'Prelude.foldr' 'K.cons' 'K.nil'