d33f389 · streamly · git.iko.soy

147-- using the 'lift' combinator. Some examples of streams with a single element:

148--

149-- @

150−-- return 1 :: StreamT IO Int

150+-- return 1 :: 'StreamT' IO Int

151-- @

152-- @

153−-- liftIO $ putStrLn "Hello world!" :: StreamT IO ()

153+-- liftIO $ putStrLn "Hello world!" :: 'StreamT' IO ()

154-- @

155--

156-- We can combine streams using '<>' to create streams of many elements:

157--

158-- @

159−-- return 1 <> return 2 <> return 3 :: StreamT IO Int

159+-- return 1 <> return 2 <> return 3 :: 'StreamT' IO Int

160-- @

161--

162-- For more ways to construct or generate a stream see the module

168-- the underlying monad and discarding the result stream:

169--

170-- @

171−-- import Streamly

171+-- import "Streamly"

172--

173−-- main = runStreamT $ liftIO $ putStrLn "Hello world!"

173+-- main = 'runStreamT' $ liftIO $ putStrLn "Hello world!"

174-- @

175--

176-- 'toList' runs a stream computation and collects the result stream in a list

182-- StreamT@.

183--

184-- @

185−-- import Streamly

185+-- import "Streamly"

186--

187-- main = do

188−-- xs \<- toList $ serially $ return 1 <> return 2

188+-- xs \<- 'toList' $ 'serially' $ return 1 <> return 2

189-- print xs

190-- @

191--

202-- function to introduce a delay specified in seconds.

203--

204-- @

205−-- import Streamly

205+-- import "Streamly"

206-- import Control.Concurrent

207--

208-- delay n = liftIO $ do

219-- total of 6 seconds because everything is serial:

220--

221-- @

222−-- main = runStreamT $ delay 3 <> delay 2 <> delay 1

222+-- main = 'runStreamT' $ delay 3 <> delay 2 <> delay 1

223-- @

224-- @

225-- ThreadId 36: Delay 3

234-- 3, 2, 4 and takes a total of 10 seconds because everything is serial:

235--

236-- @

237−-- main = runStreamT $ (delay 1 <> delay 2) \<=> (delay 3 <> delay 4)

237+-- main = 'runStreamT' $ (delay 1 <> delay 2) '<=>' (delay 3 <> delay 4)

238-- @

239-- @

240-- ThreadId 36: Delay 1

253-- next one in a separate thread and so on:

254--

255-- @

256−-- main = runStreamT $ delay 3 <| delay 2 <| delay 1

256+-- main = 'runStreamT' $ delay 3 '<|' delay 2 '<|' delay 1

257-- @

258-- @

259-- ThreadId 42: Delay 1

267-- traversed in DFS style just like '<>'.

268--

269-- @

270−-- main = runStreamT $ (p 1 <| p 2) <| (p 3 <| p 4)

270+-- main = 'runStreamT' $ (p 1 '<|' p 2) '<|' (p 3 '<|' p 4)

271-- where p = liftIO . print

272-- @

273-- @

290-- of them blocks:

291--

292-- @

293−-- main = runStreamT $ traced (sqrt 9) <| traced (sqrt 16) <| traced (sqrt 25)

293+-- main = 'runStreamT' $ traced (sqrt 9) '<|' traced (sqrt 16) '<|' traced (sqrt 25)

294-- @

295-- @

296-- ThreadId 40

328-- prints the name of the search engine as a response arrives:

329--

330-- @

331−-- import Streamly

331+-- import "Streamly"

332-- import Network.HTTP.Simple

333--

334−-- main = runStreamT $ google \<|> bing \<|> duckduckgo

334+-- main = 'runStreamT' $ google \<|> bing \<|> duckduckgo

335-- where

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

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

369-- All of the following are equivalent:

370--

371-- @

372−-- import Streamly

372+-- import "Streamly"

373--

374-- main = do

375−-- toList . serially $ foldWith (<>) (map return [1..10]) >>= print

375+-- 'toList' . 'serially' $ 'foldWith' (<>) (map return [1..10]) >>= print

376−-- toList . serially $ foldMapWith (<>) return [1..10] >>= print

376+-- 'toList' . 'serially' $ 'foldMapWith' (<>) return [1..10] >>= print

377−-- toList . serially $ forEachWith (<>) [1..10] return >>= print

377+-- 'toList' . 'serially' $ 'forEachWith' (<>) [1..10] return >>= print

378−-- toList . serially $ each [1..10] >>= print

378+-- 'toList' . 'serially' $ 'each' [1..10] >>= print

379-- @

380

381-- $transforming

409-- list transformer like serial composition.

410--

411-- @

412−-- main = runStreamT $ do

412+-- main = 'runStreamT' $ do

413−-- x <- each [3,2,1]

413+-- x <- 'each' [3,2,1]

414-- delay x

415-- @

416-- @

430-- loops in imperative programming.

431--

432-- @

433−-- main = runStreamT $ do

433+-- main = 'runStreamT' $ do

434−-- x <- each [1,2]

434+-- x <- 'each' [1,2]

435−-- y <- each [3,4]

435+-- y <- 'each' [3,4]

436-- liftIO $ putStrLn $ show (x, y)

437-- @

438-- @

455-- This is the concurrent version of 'StreamT'.

456--

457-- @

458−-- main = runAsyncT $ do

458+-- main = 'runAsyncT' $ do

459−-- x <- each [3,2,1]

459+-- x <- 'each' [3,2,1]

460-- delay x

461-- @

462-- @

479-- demand from the consumer.

480--

481-- @

482−-- main = runAsyncT $ do

482+-- main = 'runAsyncT' $ do

483−-- x <- each [1,2]

483+-- x <- 'each' [1,2]

484−-- y <- each [3,4]

484+-- y <- 'each' [3,4]

485-- liftIO $ putStrLn $ show (x, y)

486-- @

487-- @

502-- the continuations or iterations of the inner loop.

503--

504-- @

505−-- main = runInterleavedT $ do

505+-- main = 'runInterleavedT' $ do

506−-- x <- each [1,2]

506+-- x <- 'each' [1,2]

507−-- y <- each [3,4]

507+-- y <- 'each' [3,4]

508-- liftIO $ putStrLn $ show (x, y)

509-- @

510-- @

525-- concurrently instead of the demand driven concurrency of 'AsyncT'.

526--

527-- @

528−-- main = runParallelT $ do

528+-- main = 'runParallelT' $ do

529−-- x <- each [3,2,1]

529+-- x <- 'each' [3,2,1]

530-- delay x

531-- @

532-- @

546-- specific mode of composition. For example look at the following code.

547--

548-- @

549−-- import Streamly

549+-- import "Streamly"

550--

551−-- composed :: Streaming t => t m a

551+-- composed :: 'Streaming' t => t m a

552-- composed = do

553-- sz <- sizes

554-- cl <- colors

557--

558-- where

559--

560−-- sizes = each [1, 2, 3]

560+-- sizes = 'each' [1, 2, 3]

561−-- colors = each ["red", "green", "blue"]

561+-- colors = 'each' ["red", "green", "blue"]

562−-- shapes = each ["triangle", "square", "circle"]

562+-- shapes = 'each' ["triangle", "square", "circle"]

563-- @

564--

565-- Now we can interpret this in whatever way we want:

566--

567-- @

568−-- main = runStreamT composed

568+-- main = 'runStreamT' composed

569−-- main = runAsyncT composed

569+-- main = 'runAsyncT' composed

570−-- main = runInterleavedT composed

570+-- main = 'runInterleavedT' composed

571−-- main = runParallelT composed

571+-- main = 'runParallelT' composed

572-- @

573--

574-- Equivalently, we can also write it using the type adapter combinators, like

575-- this:

576--

577-- @

578−-- main = runStreaming $ serially $ composed

578+-- main = 'runStreaming' $ 'serially' $ composed

579−-- main = runStreaming $ asyncly $ composed

579+-- main = 'runStreaming' $ 'asyncly' $ composed

580−-- main = runStreaming $ interleaving $ composed

580+-- main = 'runStreaming' $ 'interleaving' $ composed

581−-- main = runStreaming $ parallely $ composed

581+-- main = 'runStreaming' $ 'parallely' $ composed

582-- @

583--

584-- As an exercise try to figure out the output of this code for each mode of

593-- 'fmap', namely, 'asyncMap' and 'parMap' are provided.

594--

595-- @

596−-- import Streamly

596+-- import "Streamly"

597--

598−-- main = (toList $ serially $ fmap show $ each [1..10]) >>= print

598+-- main = ('toList' $ 'serially' $ fmap show $ 'each' [1..10]) >>= print

599-- @

600--

601-- Also see the 'mapM' and 'sequence' functions for mapping actions, in the

611-- seconds (1 + 3 + 4 + 2 + 3 + 4):

612--

613-- @

614−-- import Streamly

614+-- import "Streamly"

615−-- import Streamly.Prelude

615+-- import "Streamly.Prelude"

616-- import Control.Concurrent

617--

618-- s1 = d 1 <> d 2

619-- s2 = d 3 <> d 4

620-- d n = delay n >> return n

621--

622−-- main = (toList . serially $ (,) \<$> s1 \<*> s2) >>= print

622+-- main = ('toList' . 'serially' $ (,) \<$> s1 \<*> s2) >>= print

623-- @

624-- @

625-- ThreadId 36: Delay 1

635-- since it is serial it takes a total of 17 seconds:

636--

637-- @

638−-- main = (toList . interleaving $ (,) \<$> s1 \<*> s2) >>= print

638+-- main = ('toList' . 'interleaving' $ (,) \<$> s1 \<*> s2) >>= print

639-- @

640-- @

641-- ThreadId 36: Delay 1

651-- of 10 seconds (1 + 2 + 3 + 4):

652--

653-- @

654−-- main = (toList . asyncly $ (,) \<$> s1 \<*> s2) >>= print

654+-- main = ('toList' . 'asyncly' $ (,) \<$> s1 \<*> s2) >>= print

655-- @

656-- @

657-- ThreadId 34: Delay 1

667-- therefore takes a total of 10 seconds (1 + 2 + 3 + 4):

668--

669-- @

670−-- main = (toList . parallely $ (,) \<$> s1 \<*> s2) >>= print

670+-- main = ('toList' . 'parallely' $ (,) \<$> s1 \<*> s2) >>= print

671-- @

672-- @

673-- ThreadId 34: Delay 1

712-- 'ZipStream' zips streams serially:

713--

714-- @

715−-- import Streamly

715+-- import "Streamly"

716−-- import Streamly.Prelude

716+-- import "Streamly.Prelude"

717-- import Control.Concurrent

718--

719-- d n = delay n >> return n

720−-- s1 = adapt . serially $ d 1 <> d 2

720+-- s1 = 'adapt' . 'serially' $ d 1 <> d 2

721−-- s2 = adapt . serially $ d 3 <> d 4

721+-- s2 = 'adapt' . 'serially' $ d 3 <> d 4

722--

723−-- main = (toList . zipping $ (,) \<$> s1 \<*> s2) >>= print

723+-- main = ('toList' . 'zipping' $ (,) \<$> s1 \<*> s2) >>= print

724-- @

725--

726-- This takes total 10 seconds to zip, which is (1 + 2 + 3 + 4) since

739-- 'ZipAsync' zips streams concurrently:

740--

741-- @

742−-- import Streamly

742+-- import "Streamly"

743−-- import Streamly.Prelude

743+-- import "Streamly.Prelude"

744-- import Control.Concurrent

745-- import System.IO (stdout, hSetBuffering, BufferMode(LineBuffering))

746--

747-- d n = delay n >> return n

748−-- s1 = adapt . serially $ d 1 <> d 2

748+-- s1 = 'adapt' . 'serially' $ d 1 <> d 2

749−-- s2 = adapt . serially $ d 3 <> d 4

749+-- s2 = 'adapt' . 'serially' $ d 3 <> d 4

750--

751-- main = do

752-- liftIO $ hSetBuffering stdout LineBuffering

753−-- (toList . zippingAsync $ (,) \<$> s1 \<*> s2) >>= print

753+-- ('toList' . 'zippingAsync' $ (,) \<$> s1 \<*> s2) >>= print

754-- @

755--

756-- This takes 7 seconds to zip, which is max (1,3) + max (2,4) because 1 and 3

774-- sum and print them serially:

775--

776-- @

777−-- import Streamly

777+-- import "Streamly"

778−-- import Streamly.Prelude (toList)

778+-- import "Streamly.Prelude" (toList)

779-- import Data.List (sum)

780--

781-- main = do

782−-- squares \<- toList $ serially $ forEachWith (<|) [1..100] $ \\x -\> return $ x * x

782+-- squares \<- 'toList' $ 'serially' $ 'forEachWith' ('<|') [1..100] $ \\x -\> return $ x * x

783-- print $ sum squares

784-- @

785--

788-- monadic bind.

789--

790-- @

791−-- import Streamly

791+-- import "Streamly"

792−-- import Streamly.Prelude (toList)

792+-- import "Streamly.Prelude" (toList)

793-- import Data.List (sum)

794--

795-- main = do

796−-- z \<- toList $ asyncly $ do

796+-- z \<- 'toList' $ 'asyncly' $ do

797−-- xsq \<- forEachWith (\<|) [1..100] $ \\x -> return $ x * x

797+-- xsq \<- 'forEachWith' ('<|') [1..100] $ \\x -> return $ x * x

798−-- ysq \<- forEachWith (\<|) [1..100] $ \\x -> return $ x * x

798+-- ysq \<- 'forEachWith' ('<|') [1..100] $ \\x -> return $ x * x

799-- return $ sqrt (xsq + ysq)

800-- print $ sum z

801-- @

807-- @

808-- {-\# LANGUAGE FlexibleContexts #-}

809--

810−-- import Streamly

810+-- import "Streamly"

811-- import Control.Concurrent (threadDelay)

812-- import Control.Monad (when)

813-- import Control.Monad.State

815--

816-- data Event = Harm Int | Heal Int | Quit deriving (Show)

817--

818−-- userAction :: MonadIO m => StreamT m Event

818+-- userAction :: MonadIO m => 'StreamT' m Event

819-- userAction = cycle1 $ liftIO askUser

820-- where

821-- askUser = do

825-- "quit" -> return Quit

826-- _ -> putStrLn "What?" >> askUser

827--

828−-- acidRain :: MonadIO m => StreamT m Event

828+-- acidRain :: MonadIO m => 'StreamT' m Event

829-- acidRain = cycle1 $ liftIO (threadDelay 1000000) >> return (Harm 1)

830--

831−-- game :: (MonadAsync m, MonadState Int m) => StreamT m ()

831+-- game :: ('MonadAsync' m, MonadState Int m) => 'StreamT' m ()

832-- game = do

833-- event \<- userAction \<|> acidRain

834-- case event of

843-- main = do

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

845-- \\ type \\"potion\\" or \\"quit\\""

846−-- _ <- runStateT (runStreamT game) 60

846+-- _ <- runStateT ('runStreamT' game) 60

847-- return ()

848-- @

849