Modulelinear-base-0.8.1

Streaming.Linear.Internal.Process

Synopsis

value break
value breakWhen
value breakWhen'
value breaks
value catMaybes
value chain
value composeToSum
value cons
value copy
value delay
value destroyExposed
value distinguish
value drop
value dropWhile
value duplicate
value eitherToSum
value filter
value filterM
value for
value group
value groupBy
value hoist
value intersperse
value map
value mapM
value mapMaybe
value mapMaybeM
value mapped
value mappedPost
value maps
value mapsMPost
value mapsPost
value next
value nubInt
value nubIntOn
value nubOrd
value nubOrdOn
value partition
value partitionEithers
value read
value scan
value scanM
value scanned
value separate
value sequence
value show
value slidingWindow
value span
value split
value splitAt
value store
value subst
value sumToCompose
value sumToEither
value switch
value uncons
value unseparate
value with
value wrapEffect

Packagelinear-base-0.8.1
Exports59
LicenceMIT

valuebreak

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Of a) m (Stream (Of a) m r)

valuebreakWhen

:: Monad m
=> x -> a -> x
-> x
-> x -> b
-> b -> Bool
-> Stream (Of a) m r
-> Stream (Of a) m (Stream (Of a) m r)

valuebreakWhen'

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Of a) m (Stream (Of a) m r)

valuebreaks

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Stream (Of a) m) m r

valuecatMaybes :: Monad m => Stream (Of (Maybe a)) m r %1 -> Stream (Of a) m r

valuechain

:: (Monad m, Consumable y)
=> a -> m y
-> Stream (Of a) m r
-> Stream (Of a) m r

valuecomposeToSum :: Compose (Of Bool) f r -> Sum f f r

valuecons :: Monad m => a -> Stream (Of a) m r %1 -> Stream (Of a) m r

valuecopy :: Monad m => Stream (Of a) m r %1 -> Stream (Of a) (Stream (Of a) m) r

valuedelay :: Double -> Stream (Of a) IO r %1 -> Stream (Of a) IO r

valuedestroyExposed

:: (Functor f, Monad m)
=> Stream f m r
-> f b %1 -> b
-> m b %1 -> b
-> r %1 -> b
-> b

valuedistinguish :: (a -> Bool) -> Of a r -> Sum (Of a) (Of a) r

valuedrop

:: (HasCallStack, Monad m)
=> Int
-> Stream (Of a) m r
-> Stream (Of a) m r

valuedropWhile

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Of a) m r

valueduplicate

:: Monad m
=> Stream (Of a) m r
-> Stream (Of a) (Stream (Of a) m) r

valueeitherToSum :: Of (Either a b) r -> Sum (Of a) (Of b) r

valuefilter

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Of a) m r

valuefilterM

:: Monad m
=> a -> m Bool
-> Stream (Of a) m r
-> Stream (Of a) m r

valuefor

:: (Monad m, Functor f, Consumable x)
=> Stream (Of a) m r
-> a -> Stream f m x
-> Stream f m r

valuegroup

:: (Monad m, Eq a)
=> Stream (Of a) m r
-> Stream (Stream (Of a) m) m r

valuegroupBy

:: Monad m
=> a -> a -> Bool
-> Stream (Of a) m r
-> Stream (Stream (Of a) m) m r

valuehoist

:: (Monad m, Functor f)
=> forall a. m a %1 -> n a
-> Stream f m r
-> Stream f n r

valueintersperse :: Monad m => a -> Stream (Of a) m r %1 -> Stream (Of a) m r

valuemap :: Monad m => (a -> b) -> Stream (Of a) m r %1 -> Stream (Of b) m r

valuemapM

:: Monad m
=> a -> m (Ur b)
-> Stream (Of a) m r
-> Stream (Of b) m r

valuemapMaybe

:: Monad m
=> a -> Maybe b
-> Stream (Of a) m r
-> Stream (Of b) m r

valuemapMaybeM

:: Monad m
=> a -> m (Maybe (Ur b))
-> Stream (Of a) m r
-> Stream (Of b) m r

valuemapped

:: (Monad m, Functor f)
=> forall x. f x %1 -> m (g x)
-> Stream f m r
-> Stream g m r

valuemappedPost

:: (Monad m, Functor g)
=> forall x. f x %1 -> m (g x)
-> Stream f m r
-> Stream g m r

valuemaps

:: (Monad m, Functor f)
=> forall x. f x %1 -> g x
-> Stream f m r
-> Stream g m r

valuemapsMPost

:: (Monad m, Functor g)
=> forall x. f x %1 -> m (g x)
-> Stream f m r
-> Stream g m r

valuemapsPost

:: (Monad m, Functor g)
=> forall x. f x %1 -> g x
-> Stream f m r
-> Stream g m r

valuenext

:: Monad m
=> Stream (Of a) m r
-> m (Either r (Ur a, Stream (Of a) m r))

valuenubInt :: Monad m => Stream (Of Int) m r %1 -> Stream (Of Int) m r

valuenubIntOn

:: Monad m
=> a -> Int
-> Stream (Of a) m r
-> Stream (Of a) m r

valuenubOrd :: (Monad m, Ord a) => Stream (Of a) m r %1 -> Stream (Of a) m r

valuenubOrdOn

:: (Monad m, Ord b)
=> a -> b
-> Stream (Of a) m r
-> Stream (Of a) m r

valuepartition

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Of a) (Stream (Of a) m) r

valuepartitionEithers

:: Monad m
=> Stream (Of (Either a b)) m r
-> Stream (Of a) (Stream (Of b) m) r

valueread :: (Monad m, Read a) => Stream (Of String) m r %1 -> Stream (Of a) m r

valuescan

:: Monad m
=> x -> a -> x
-> x
-> x -> b
-> Stream (Of a) m r
-> Stream (Of b) m r

valuescanM

:: Monad m
=> x %1 -> a -> m (Ur x)
-> m (Ur x)
-> x %1 -> m (Ur b)
-> Stream (Of a) m r
-> Stream (Of b) m r

valuescanned

:: Monad m
=> x -> a -> x
-> x
-> x -> b
-> Stream (Of a) m r
-> Stream (Of (a, b)) m r

valueseparate

:: (Monad m, Functor f, Functor g)
=> Stream (Sum f g) m r
-> Stream f (Stream g m) r

valuesequence :: Monad m => Stream (Of (m (Ur a))) m r %1 -> Stream (Of a) m r

valueshow :: (Monad m, Show a) => Stream (Of a) m r %1 -> Stream (Of String) m r

valueslidingWindow

:: Monad m
=> Int
-> Stream (Of a) m b
-> Stream (Of (Seq a)) m b

valuespan

:: Monad m
=> a -> Bool
-> Stream (Of a) m r
-> Stream (Of a) m (Stream (Of a) m r)

valuesplit

:: (Eq a, Monad m)
=> a
-> Stream (Of a) m r
-> Stream (Stream (Of a) m) m r

valuesplitAt

:: (Monad m, Functor f)
=> Int
-> Stream f m r
-> Stream f m (Stream f m r)

valuestore

:: Monad m
=> Stream (Of a) (Stream (Of a) m) r %1 -> t
-> Stream (Of a) m r
-> t

valuesubst

:: (Monad m, Functor f, Consumable x)
=> a -> f x
-> Stream (Of a) m r
-> Stream f m r

valuesumToCompose :: Sum f f r -> Compose (Of Bool) f r

valuesumToEither :: Sum (Of a) (Of b) r -> Of (Either a b) r

valueswitch :: Sum f g r -> Sum g f r

valueuncons

:: (Consumable r, Monad m)
=> Stream (Of a) m r
-> m (Maybe (a, Stream (Of a) m r))

valueunseparate

:: (Monad m, Functor f, Functor g)
=> Stream f (Stream g m) r
-> Stream (Sum f g) m r

valuewith

:: (Monad m, Functor f, Consumable x)
=> Stream (Of a) m r
-> a -> f x
-> Stream f m r

valuewrapEffect

:: (Monad m, Functor f, Consumable y)
=> m a
-> a %1 -> m y
-> Stream f m r
-> Stream f m r