Hoogle Search

Within LTS Haskell 24.28 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. fromList :: forall (m :: Type -> Type) t a . (Monad m, IsStream t) => [a] -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   fromList = foldr cons nil
   

   Construct a stream from a list of pure values. This is more efficient than fromFoldable for serial streams.

2. fromListM :: (MonadAsync m, IsStream t) => [m a] -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   >>> fromListM = Stream.fromFoldableM
   
   >>> fromListM = Stream.sequence . Stream.fromList
   
   >>> fromListM = Stream.mapM id . Stream.fromList
   
   >>> fromListM = Prelude.foldr Stream.consM Stream.nil
   

   Construct a stream from a list of monadic actions. This is more efficient than fromFoldableM for serial streams.

3. toList :: Monad m => SerialT m a -> m [a]

   streamly	Streamly.Internal.Data.Stream.IsStream

   toList = Stream.foldr (:) []
   

   Convert a stream into a list in the underlying monad. The list can be consumed lazily in a lazy monad (e.g. Identity). In a strict monad (e.g. IO) the whole list is generated and buffered before it can be consumed. Warning! working on large lists accumulated as buffers in memory could be very inefficient, consider using Streamly.Array instead.

4. toListRev :: Monad m => SerialT m a -> m [a]

   streamly	Streamly.Internal.Data.Stream.IsStream

   toListRev = Stream.foldl' (flip (:)) []
   

   Convert a stream into a list in reverse order in the underlying monad. Warning! working on large lists accumulated as buffers in memory could be very inefficient, consider using Streamly.Array instead. Pre-release

5. parList :: forall (m :: Type -> Type) a . MonadAsync m => (Config -> Config) -> [Stream m a] -> Stream m a

   streamly	Streamly.Internal.Data.Stream.Prelude

   Like parConcat but works on a list of streams.

   >>> parList modifier = Stream.parConcat modifier . Stream.fromList
   

6. parListEager :: forall (m :: Type -> Type) a . MonadAsync m => [Stream m a] -> Stream m a

   streamly	Streamly.Internal.Data.Stream.Prelude

   Like parListLazy but with eager on.

   >>> parListEager = Stream.parList (Stream.eager True)
   

7. parListEagerFst :: forall (m :: Type -> Type) a . MonadAsync m => [Stream m a] -> Stream m a

   streamly	Streamly.Internal.Data.Stream.Prelude

   Like parListEager but stops the output as soon as the first stream stops.

   >>> parListEagerFst = Stream.parList (Stream.eager True . Stream.stopWhen Stream.FirstStops)
   

8. parListEagerMin :: forall (m :: Type -> Type) a . MonadAsync m => [Stream m a] -> Stream m a

   streamly	Streamly.Internal.Data.Stream.Prelude

   Like parListEager but stops the output as soon as any of the two streams stops. Definition:

   >>> parListEagerMin = Stream.parList (Stream.eager True . Stream.stopWhen Stream.AnyStops)
   

9. parListInterleaved :: forall (m :: Type -> Type) a . MonadAsync m => [Stream m a] -> Stream m a

   streamly	Streamly.Internal.Data.Stream.Prelude

   Like parListLazy but interleaves the streams fairly instead of prioritizing the left stream. This schedules all streams in a round robin fashion over limited number of threads.

   >>> parListInterleaved = Stream.parList (Stream.interleaved True)
   

10. parListLazy :: forall (m :: Type -> Type) a . MonadAsync m => [Stream m a] -> Stream m a

    streamly	Streamly.Internal.Data.Stream.Prelude

    Like concat but works on a list of streams.

    >>> parListLazy = Stream.parList id
    

Page 225 of many | Previous | Next