HORIZON HASKELLDocslts/ghc-9.10.x248f8f02026-10-05Search names, modules, packages, or :: a typeCtrl K

GHC 9.10.3 · lts/ghc-9.10.x · 248f8f0 · 2026-10-05

Modulestreamly-0.10.1Haskell2010

Streamly.Internal.Data.Stream.Ahead

Deprecated. Please use Streamly.Internal.Data.Stream.Concurrent from streamly package instead.

To run examples in this module:

Example3 expressions
import qualified Streamly.Prelude as Streamimport Control.Concurrent (threadDelay):{ delay n = do     threadDelay (n * 1000000)   -- sleep for n seconds     putStrLn (show n ++ " sec") -- print "n sec"     return n                    -- IO Int:}
  • 2 types
  • 2 values
  • Packagestreamly-0.10.1
  • Exports4
  • LanguageHaskell2010
  • LicenceBSD-3-Clause
  • SourceAhead.hs
newtypenewtype AheadT (m :: Type -> Type) a
#

For AheadT streams:

(<>) = Streamly.Prelude.ahead
(>>=) = flip . Streamly.Prelude.concatMapWith Streamly.Prelude.ahead

A single Monad bind behaves like a for loop with iterations executed concurrently, ahead of time, producing side effects of iterations out of order, but results in order:

Example1 expression
:{Stream.toList $ Stream.fromAhead $ do     x <- Stream.fromList [2,1] -- foreach x in stream     Stream.fromEffect $ delay x:}1 sec2 sec[2,1]

Nested monad binds behave like nested for loops with nested iterations executed concurrently, ahead of time:

Example1 expression
:{Stream.toList $ Stream.fromAhead $ do    x <- Stream.fromList [1,2] -- foreach x in stream    y <- Stream.fromList [2,4] -- foreach y in stream    Stream.fromEffect $ delay (x + y):}3 sec4 sec5 sec6 sec[3,5,4,6]

The behavior can be explained as follows. All the iterations corresponding to the element 1 in the first stream constitute one output stream and all the iterations corresponding to 2 constitute another output stream and these two output streams are merged using ahead.

Since: 0.3.0 (Streamly)

Constructors

Instances10IsStream, MonadReader, MonadState, Monad, Functor, Applicative, …
typetype Ahead = AheadT IO
#

A serial IO stream of elements of type a with concurrent lookahead. See AheadT documentation for more details.

Since: 0.3.0 (Streamly)

valueconsM :: MonadAsync m => m a -> AheadT m a -> AheadT m a
#

XXX we can implement it more efficienty by directly implementing instead of combining streams using ahead.