Copyright	(c) 2017 Composewell Technologies
License	BSD3
Maintainer	streamly@composewell.com
Stability	experimental
Portability	GHC
Safe Haskell	None
Language	Haskell2010

Streamly.Internal.Data.Stream.Serial

Contents

Serial appending stream
Serial interleaving stream
Construction
Elimination
Transformation

Description

Deprecated: Please use Streamly.Internal.Data.Stream from streamly-core package instead.

To run examples in this module:

>>> import qualified Streamly.Prelude as Stream

Synopsis

newtype SerialT (m :: Type -> Type) a = SerialT {
- getSerialT :: Stream m a
}
toStreamK :: forall (m :: Type -> Type) a. SerialT m a -> Stream m a
fromStreamK :: forall (m :: Type -> Type) a. Stream m a -> SerialT m a
type Serial = SerialT IO
serial :: forall (m :: Type -> Type) a. SerialT m a -> SerialT m a -> SerialT m a
newtype WSerialT (m :: Type -> Type) a = WSerialT {
- getWSerialT :: Stream m a
}
type WSerial = WSerialT IO
wSerial :: forall (m :: Type -> Type) a. WSerialT m a -> WSerialT m a -> WSerialT m a
wSerialFst :: forall (m :: Type -> Type) a. WSerialT m a -> WSerialT m a -> WSerialT m a
wSerialMin :: forall (m :: Type -> Type) a. WSerialT m a -> WSerialT m a -> WSerialT m a
consMWSerial :: Monad m => m a -> WSerialT m a -> WSerialT m a
cons :: forall a (m :: Type -> Type). a -> SerialT m a -> SerialT m a
consM :: Monad m => m a -> SerialT m a -> SerialT m a
repeat :: forall (m :: Type -> Type) a. Monad m => a -> SerialT m a
unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> SerialT m a
fromList :: IsList l => [Item l] -> l
toList :: IsList l => l -> [Item l]
map :: forall (m :: Type -> Type) a b. Monad m => (a -> b) -> SerialT m a -> SerialT m b
mapM :: Monad m => (a -> m b) -> SerialT m a -> SerialT m b

Serial appending stream

newtype SerialT (m :: Type -> Type) a Source #

For SerialT streams:

(<>) = serial                       -- Semigroup
(>>=) = flip . concatMapWith serial -- Monad

A single Monad bind behaves like a for loop:

>>> :{
IsStream.toList $ do
     x <- IsStream.fromList [1,2] -- foreach x in stream
     return x
:}
[1,2]

Nested monad binds behave like nested for loops:

>>> :{
IsStream.toList $ do
    x <- IsStream.fromList [1,2] -- foreach x in stream
    y <- IsStream.fromList [3,4] -- foreach y in stream
    return (x, y)
:}
[(1,3),(1,4),(2,3),(2,4)]

Since: 0.2.0 (Streamly)

Since: 0.8.0

Constructors

SerialT
Fields getSerialT :: Stream m a

Instances

Instances details

IsStream SerialT Source #

Instance details

Defined in Streamly.Internal.Data.Stream.IsStream.Type

Methods

toStream :: forall (m :: Type -> Type) a. SerialT m a -> StreamK m a

fromStream :: forall (m :: Type -> Type) a. StreamK m a -> SerialT m a

consM :: MonadAsync m => m a -> SerialT m a -> SerialT m a Source #

(|:) :: MonadAsync m => m a -> SerialT m a -> SerialT m a Source #

MonadTrans SerialT Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

lift :: Monad m => m a -> SerialT m a #

MonadReader r m => MonadReader r (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

ask :: SerialT m r #

local :: (r -> r) -> SerialT m a -> SerialT m a #

reader :: (r -> a) -> SerialT m a #

MonadState s m => MonadState s (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

get :: SerialT m s #

put :: s -> SerialT m () #

state :: (s -> (a, s)) -> SerialT m a #

MonadIO m => MonadIO (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

liftIO :: IO a -> SerialT m a #

(Foldable m, Monad m) => Foldable (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

fold :: Monoid m0 => SerialT m m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> SerialT m a -> m0 #

foldMap' :: Monoid m0 => (a -> m0) -> SerialT m a -> m0 #

foldr :: (a -> b -> b) -> b -> SerialT m a -> b #

foldr' :: (a -> b -> b) -> b -> SerialT m a -> b #

foldl :: (b -> a -> b) -> b -> SerialT m a -> b #

foldl' :: (b -> a -> b) -> b -> SerialT m a -> b #

foldr1 :: (a -> a -> a) -> SerialT m a -> a #

foldl1 :: (a -> a -> a) -> SerialT m a -> a #

toList :: SerialT m a -> [a] #

null :: SerialT m a -> Bool #

length :: SerialT m a -> Int #

elem :: Eq a => a -> SerialT m a -> Bool #

maximum :: Ord a => SerialT m a -> a #

minimum :: Ord a => SerialT m a -> a #

sum :: Num a => SerialT m a -> a #

product :: Num a => SerialT m a -> a #

Traversable (SerialT Identity) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

traverse :: Applicative f => (a -> f b) -> SerialT Identity a -> f (SerialT Identity b) #

sequenceA :: Applicative f => SerialT Identity (f a) -> f (SerialT Identity a) #

mapM :: Monad m => (a -> m b) -> SerialT Identity a -> m (SerialT Identity b) #

sequence :: Monad m => SerialT Identity (m a) -> m (SerialT Identity a) #

Monad m => Applicative (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

pure :: a -> SerialT m a #

(<*>) :: SerialT m (a -> b) -> SerialT m a -> SerialT m b #

liftA2 :: (a -> b -> c) -> SerialT m a -> SerialT m b -> SerialT m c #

(*>) :: SerialT m a -> SerialT m b -> SerialT m b #

(<*) :: SerialT m a -> SerialT m b -> SerialT m a #

Monad m => Functor (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

fmap :: (a -> b) -> SerialT m a -> SerialT m b #

(<$) :: a -> SerialT m b -> SerialT m a #

Monad m => Monad (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

(>>=) :: SerialT m a -> (a -> SerialT m b) -> SerialT m b #

(>>) :: SerialT m a -> SerialT m b -> SerialT m b #

return :: a -> SerialT m a #

NFData1 (SerialT Identity) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

liftRnf :: (a -> ()) -> SerialT Identity a -> () #

MonadThrow m => MonadThrow (SerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

throwM :: (HasCallStack, Exception e) => e -> SerialT m a #

a ~ Char => IsString (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

fromString :: String -> SerialT Identity a #

Monoid (SerialT m a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

mempty :: SerialT m a #

mappend :: SerialT m a -> SerialT m a -> SerialT m a #

mconcat :: [SerialT m a] -> SerialT m a #

Semigroup (SerialT m a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

(<>) :: SerialT m a -> SerialT m a -> SerialT m a #

sconcat :: NonEmpty (SerialT m a) -> SerialT m a #

stimes :: Integral b => b -> SerialT m a -> SerialT m a #

IsList (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Associated Types

type Item (SerialT Identity a)
Instance details Defined in Streamly.Internal.Data.Stream.Serial type Item (SerialT Identity a) = a

Methods

fromList :: [Item (SerialT Identity a)] -> SerialT Identity a #

fromListN :: Int -> [Item (SerialT Identity a)] -> SerialT Identity a #

toList :: SerialT Identity a -> [Item (SerialT Identity a)] #

Read a => Read (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

readsPrec :: Int -> ReadS (SerialT Identity a) #

readList :: ReadS [SerialT Identity a] #

readPrec :: ReadPrec (SerialT Identity a) #

readListPrec :: ReadPrec [SerialT Identity a] #

Show a => Show (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

showsPrec :: Int -> SerialT Identity a -> ShowS #

show :: SerialT Identity a -> String #

showList :: [SerialT Identity a] -> ShowS #

NFData a => NFData (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

rnf :: SerialT Identity a -> () #

Eq a => Eq (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

(==) :: SerialT Identity a -> SerialT Identity a -> Bool #

(/=) :: SerialT Identity a -> SerialT Identity a -> Bool #

Ord a => Ord (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

compare :: SerialT Identity a -> SerialT Identity a -> Ordering #

(<) :: SerialT Identity a -> SerialT Identity a -> Bool #

(<=) :: SerialT Identity a -> SerialT Identity a -> Bool #

(>) :: SerialT Identity a -> SerialT Identity a -> Bool #

(>=) :: SerialT Identity a -> SerialT Identity a -> Bool #

max :: SerialT Identity a -> SerialT Identity a -> SerialT Identity a #

min :: SerialT Identity a -> SerialT Identity a -> SerialT Identity a #

type Item (SerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

type Item (SerialT Identity a) = a

toStreamK :: forall (m :: Type -> Type) a. SerialT m a -> Stream m a Source #

fromStreamK :: forall (m :: Type -> Type) a. Stream m a -> SerialT m a Source #

type Serial = SerialT IO Source #

A serial IO stream of elements of type a. See SerialT documentation for more details.

Since: 0.2.0 (Streamly)

Since: 0.8.0

serial :: forall (m :: Type -> Type) a. SerialT m a -> SerialT m a -> SerialT m a Source #

Serial interleaving stream

newtype WSerialT (m :: Type -> Type) a Source #

For WSerialT streams:

(<>) = wSerial                       -- Semigroup
(>>=) = flip . concatMapWith wSerial -- Monad

Note that <> is associative only if we disregard the ordering of elements in the resulting stream.

A single Monad bind behaves like a for loop:

>>> :{
IsStream.toList $ IsStream.fromWSerial $ do
     x <- IsStream.fromList [1,2] -- foreach x in stream
     return x
:}
[1,2]

Nested monad binds behave like interleaved nested for loops:

>>> :{
IsStream.toList $ IsStream.fromWSerial $ do
    x <- IsStream.fromList [1,2] -- foreach x in stream
    y <- IsStream.fromList [3,4] -- foreach y in stream
    return (x, y)
:}
[(1,3),(2,3),(1,4),(2,4)]

It is a result of interleaving all the nested iterations corresponding to element 1 in the first stream with all the nested iterations of element 2:

>>> import Streamly.Prelude (wSerial)
>>> IsStream.toList $ IsStream.fromList [(1,3),(1,4)] `IsStream.wSerial` IsStream.fromList [(2,3),(2,4)]
[(1,3),(2,3),(1,4),(2,4)]

The W in the name stands for wide or breadth wise scheduling in contrast to the depth wise scheduling behavior of SerialT.

Since: 0.2.0 (Streamly)

Since: 0.8.0

Constructors

WSerialT
Fields getWSerialT :: Stream m a

Instances

Instances details

IsStream WSerialT Source #

Instance details

Defined in Streamly.Internal.Data.Stream.IsStream.Type

Methods

toStream :: forall (m :: Type -> Type) a. WSerialT m a -> StreamK m a

fromStream :: forall (m :: Type -> Type) a. StreamK m a -> WSerialT m a

consM :: MonadAsync m => m a -> WSerialT m a -> WSerialT m a Source #

(|:) :: MonadAsync m => m a -> WSerialT m a -> WSerialT m a Source #

MonadTrans WSerialT Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

lift :: Monad m => m a -> WSerialT m a #

MonadReader r m => MonadReader r (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

ask :: WSerialT m r #

local :: (r -> r) -> WSerialT m a -> WSerialT m a #

reader :: (r -> a) -> WSerialT m a #

MonadState s m => MonadState s (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

get :: WSerialT m s #

put :: s -> WSerialT m () #

state :: (s -> (a, s)) -> WSerialT m a #

MonadIO m => MonadIO (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

liftIO :: IO a -> WSerialT m a #

(Foldable m, Monad m) => Foldable (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

fold :: Monoid m0 => WSerialT m m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> WSerialT m a -> m0 #

foldMap' :: Monoid m0 => (a -> m0) -> WSerialT m a -> m0 #

foldr :: (a -> b -> b) -> b -> WSerialT m a -> b #

foldr' :: (a -> b -> b) -> b -> WSerialT m a -> b #

foldl :: (b -> a -> b) -> b -> WSerialT m a -> b #

foldl' :: (b -> a -> b) -> b -> WSerialT m a -> b #

foldr1 :: (a -> a -> a) -> WSerialT m a -> a #

foldl1 :: (a -> a -> a) -> WSerialT m a -> a #

toList :: WSerialT m a -> [a] #

null :: WSerialT m a -> Bool #

length :: WSerialT m a -> Int #

elem :: Eq a => a -> WSerialT m a -> Bool #

maximum :: Ord a => WSerialT m a -> a #

minimum :: Ord a => WSerialT m a -> a #

sum :: Num a => WSerialT m a -> a #

product :: Num a => WSerialT m a -> a #

Traversable (WSerialT Identity) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

traverse :: Applicative f => (a -> f b) -> WSerialT Identity a -> f (WSerialT Identity b) #

sequenceA :: Applicative f => WSerialT Identity (f a) -> f (WSerialT Identity a) #

mapM :: Monad m => (a -> m b) -> WSerialT Identity a -> m (WSerialT Identity b) #

sequence :: Monad m => WSerialT Identity (m a) -> m (WSerialT Identity a) #

Monad m => Applicative (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

pure :: a -> WSerialT m a #

(<*>) :: WSerialT m (a -> b) -> WSerialT m a -> WSerialT m b #

liftA2 :: (a -> b -> c) -> WSerialT m a -> WSerialT m b -> WSerialT m c #

(*>) :: WSerialT m a -> WSerialT m b -> WSerialT m b #

(<*) :: WSerialT m a -> WSerialT m b -> WSerialT m a #

Monad m => Functor (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

fmap :: (a -> b) -> WSerialT m a -> WSerialT m b #

(<$) :: a -> WSerialT m b -> WSerialT m a #

Monad m => Monad (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

(>>=) :: WSerialT m a -> (a -> WSerialT m b) -> WSerialT m b #

(>>) :: WSerialT m a -> WSerialT m b -> WSerialT m b #

return :: a -> WSerialT m a #

NFData1 (WSerialT Identity) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

liftRnf :: (a -> ()) -> WSerialT Identity a -> () #

MonadThrow m => MonadThrow (WSerialT m) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

throwM :: (HasCallStack, Exception e) => e -> WSerialT m a #

a ~ Char => IsString (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

fromString :: String -> WSerialT Identity a #

Monoid (WSerialT m a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

mempty :: WSerialT m a #

mappend :: WSerialT m a -> WSerialT m a -> WSerialT m a #

mconcat :: [WSerialT m a] -> WSerialT m a #

Semigroup (WSerialT m a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

(<>) :: WSerialT m a -> WSerialT m a -> WSerialT m a #

sconcat :: NonEmpty (WSerialT m a) -> WSerialT m a #

stimes :: Integral b => b -> WSerialT m a -> WSerialT m a #

IsList (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Associated Types

type Item (WSerialT Identity a)
Instance details Defined in Streamly.Internal.Data.Stream.Serial type Item (WSerialT Identity a) = a

Methods

fromList :: [Item (WSerialT Identity a)] -> WSerialT Identity a #

fromListN :: Int -> [Item (WSerialT Identity a)] -> WSerialT Identity a #

toList :: WSerialT Identity a -> [Item (WSerialT Identity a)] #

Read a => Read (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

readsPrec :: Int -> ReadS (WSerialT Identity a) #

readList :: ReadS [WSerialT Identity a] #

readPrec :: ReadPrec (WSerialT Identity a) #

readListPrec :: ReadPrec [WSerialT Identity a] #

Show a => Show (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

showsPrec :: Int -> WSerialT Identity a -> ShowS #

show :: WSerialT Identity a -> String #

showList :: [WSerialT Identity a] -> ShowS #

NFData a => NFData (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

rnf :: WSerialT Identity a -> () #

Eq a => Eq (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

(==) :: WSerialT Identity a -> WSerialT Identity a -> Bool #

(/=) :: WSerialT Identity a -> WSerialT Identity a -> Bool #

Ord a => Ord (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

Methods

compare :: WSerialT Identity a -> WSerialT Identity a -> Ordering #

(<) :: WSerialT Identity a -> WSerialT Identity a -> Bool #

(<=) :: WSerialT Identity a -> WSerialT Identity a -> Bool #

(>) :: WSerialT Identity a -> WSerialT Identity a -> Bool #

(>=) :: WSerialT Identity a -> WSerialT Identity a -> Bool #

max :: WSerialT Identity a -> WSerialT Identity a -> WSerialT Identity a #

min :: WSerialT Identity a -> WSerialT Identity a -> WSerialT Identity a #

type Item (WSerialT Identity a) Source #

Instance details

Defined in Streamly.Internal.Data.Stream.Serial

type Item (WSerialT Identity a) = a

type WSerial = WSerialT IO Source #

An interleaving serial IO stream of elements of type a. See WSerialT documentation for more details.

Since: 0.2.0 (Streamly)

Since: 0.8.0

wSerial :: forall (m :: Type -> Type) a. WSerialT m a -> WSerialT m a -> WSerialT m a infixr 6 Source #

Interleaves two streams, yielding one element from each stream alternately. When one stream stops the rest of the other stream is used in the output stream.

This gives exponential priority to earlier streams than the ones joining later. Because of exponential weighting it can be used with concatMapWith.

Not fused

wSerialFst :: forall (m :: Type -> Type) a. WSerialT m a -> WSerialT m a -> WSerialT m a Source #

wSerialMin :: forall (m :: Type -> Type) a. WSerialT m a -> WSerialT m a -> WSerialT m a Source #

consMWSerial :: Monad m => m a -> WSerialT m a -> WSerialT m a Source #

Construction

cons :: forall a (m :: Type -> Type). a -> SerialT m a -> SerialT m a infixr 5 Source #

consM :: Monad m => m a -> SerialT m a -> SerialT m a infixr 5 Source #

repeat :: forall (m :: Type -> Type) a. Monad m => a -> SerialT m a Source #

Generate an infinite stream by repeating a pure value.

unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> SerialT m a Source #

Build a stream by unfolding a monadic step function starting from a seed. The step function returns the next element in the stream and the next seed value. When it is done it returns Nothing and the stream ends. For example,

let f b =
        if b > 3
        then return Nothing
        else print b >> return (Just (b, b + 1))
in drain $ unfoldrM f 0

Pre-release

fromList :: IsList l => [Item l] -> l #

The fromList function constructs the structure l from the given list of Item l

Elimination

toList :: IsList l => l -> [Item l] #

The toList function extracts a list of Item l from the structure l. It should satisfy fromList . toList = id.

Transformation

map :: forall (m :: Type -> Type) a b. Monad m => (a -> b) -> SerialT m a -> SerialT m b Source #

map = fmap

Same as fmap.

> S.toList $ S.map (+1) $ S.fromList [1,2,3]
[2,3,4]

Since: 0.4.0

mapM :: Monad m => (a -> m b) -> SerialT m a -> SerialT m b Source #