Modulelinear-base-0.8.1

Streaming.Prelude.Linear

Synopsis

value all
value all_
value any
value any_
value drained
value effects
value elem
value elem_
value erase
value fold
value foldM
value foldM_
value fold_
value foldrM
value foldrT
value head
value head_
value last
value last_
value length
value length_
value mapM_
value maximum
value maximum_
value mconcat
value mconcat_
value minimum
value minimum_
value notElem
value notElem_
value print
value product
value product_
value stdoutLn
value stdoutLn'
value sum
value sum_
value toHandle
value toList
value toList_
value writeFile
value reread
value merge
value mergeBy
value mergeOn
value unzip
value zip
value zip3
value zip3R
value zipR
value zipWith
value zipWith3
value zipWith3R
value zipWithR
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
value cycleN
value cycleZip
value each'
value enumFromN
value enumFromThenN
value enumFromThenZip
value enumFromZip
value fromHandle
value iterateMN
value iterateMZip
value iterateN
value iterateZip
value readFile
value readLnN
value readLnUntil
value readLnUntilM
value readLnZip
value replicate
value replicateM
value replicateZip
value stdinLnN
value stdinLnUntil
value stdinLnUntilM
value stdinLnZip
value unfoldr
value untilRight
value yield
data Either3
type ZipResidual
type ZipResidual3
data Of
data Stream

Packagelinear-base-0.8.1
Exports145
LicenceMIT

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

valueall_

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

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

valueany_

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

valuedrained

:: (Monad m, Monad (t m), Functor (t m), MonadTrans t)
=> t m (Stream (Of a) m r)
-> t m r

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

valueelem :: (Monad m, Eq a) => a -> Stream (Of a) m r %1 -> m (Of Bool r)

valueelem_

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

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

valuefold

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

valuefoldM

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

valuefoldM_

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

valuefold_

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

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

valuefoldrT

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

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

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

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

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

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

valuelength_ :: (Consumable r, Monad m) => Stream (Of a) m r %1 -> m Int

valuemapM_

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

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

valuemaximum_

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

valuemconcat :: (Monad m, Monoid w) => Stream (Of w) m r %1 -> m (Of w r)

valuemconcat_ :: (Consumable r, Monad m, Monoid w) => Stream (Of w) m r %1 -> m w

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

valueminimum_

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

valuenotElem :: (Monad m, Eq a) => a -> Stream (Of a) m r %1 -> m (Of Bool r)

valuenotElem_

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

valueprint :: Show a => Stream (Of a) IO r %1 -> IO r

valueproduct :: (Monad m, Num a) => Stream (Of a) m r %1 -> m (Of a r)

valueproduct_ :: (Monad m, Num a) => Stream (Of a) m () %1 -> m a

valuestdoutLn :: Stream (Of Text) IO () %1 -> IO ()

valuestdoutLn' :: Stream (Of Text) IO r %1 -> IO r

valuesum :: (Monad m, Num a) => Stream (Of a) m r %1 -> m (Of a r)

valuesum_ :: (Monad m, Num a) => Stream (Of a) m () %1 -> m a

valuetoHandle :: Handle %1 -> Stream (Of Text) RIO r %1 -> RIO (r, Handle)

valuetoList :: Monad m => Stream (Of a) m r %1 -> m (Of [a] r)

valuetoList_ :: Monad m => Stream (Of a) m () %1 -> m [a]

valuewriteFile :: FilePath -> Stream (Of Text) RIO r %1 -> RIO r

valuereread :: Monad m => (s -> m (Ur (Maybe a))) -> s -> Stream (Of a) m ()

valuemerge

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

valuemergeBy

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

valuemergeOn

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

valueunzip

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

valuezip

:: Monad m
=> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of (a, b)) m (r1, r2)

valuezip3

:: Monad m
=> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of c) m r3
-> Stream (Of (a, b, c)) m (r1, r2, r3)

valuezip3R

:: Monad m
=> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of c) m r3
-> Stream (Of (a, b, c)) m (ZipResidual3 a b c m r1 r2 r3)

valuezipR

:: Monad m
=> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of (a, b)) m (ZipResidual a b m r1 r2)

valuezipWith

:: Monad m
=> a -> b -> c
-> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of c) m (r1, r2)

valuezipWith3

:: Monad m
=> a -> b -> c -> d
-> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of c) m r3
-> Stream (Of d) m (r1, r2, r3)

valuezipWith3R

:: Monad m
=> a -> b -> c -> d
-> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of c) m r3
-> Stream (Of d) m (ZipResidual3 a b c m r1 r2 r3)

valuezipWithR

:: Monad m
=> a -> b -> c
-> Stream (Of a) m r1
-> Stream (Of b) m r2
-> Stream (Of c) m (ZipResidual a b m r1 r2)

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

valuecycleN

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

valuecycleZip

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

valueeach' :: Monad m => [a] -> Stream (Of a) m ()

valueenumFromN :: (Monad m, Enum e) => Int -> e -> Stream (Of e) m ()

valueenumFromThenN :: (Monad m, Enum e) => Int -> e -> e -> Stream (Of e) m ()

valueenumFromThenZip

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

valueenumFromZip

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

valuefromHandle :: Handle %1 -> Stream (Of Text) RIO ()

valueiterateMN

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

valueiterateMZip

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

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

valueiterateZip

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

valuereadFile :: FilePath -> Stream (Of Text) RIO ()

valuereadLnN :: Read a => Int -> Stream (Of a) IO ()

valuereadLnUntil :: Read a => (a -> Bool) -> Stream (Of a) IO ()

valuereadLnUntilM :: Read a => (a -> IO Bool) -> Stream (Of a) IO ()

valuereadLnZip :: Read a => Stream (Of x) IO r %1 -> Stream (Of (x, a)) IO r

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

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

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

valuestdinLnN :: Int -> Stream (Of Text) IO ()

valuestdinLnUntil :: (Text -> Bool) -> Stream (Of Text) IO ()

valuestdinLnUntilM :: (Text -> IO Bool) -> Stream (Of Text) IO ()

valuestdinLnZip :: Stream (Of x) IO r %1 -> Stream (Of (x, Text)) IO r

valueunfoldr

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

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

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

datadata Either3 a b c where

Constructors

Left3 :: a -> Either3 a b c
Middle3 :: b -> Either3 a b c
Right3 :: c -> Either3 a b c

typetype ZipResidual a b (m :: Type -> Type) r1 r2 = Either3 (r1, r2) (r1, Stream (Of b) m r2) (Stream (Of a) m r1, r2)

type

type ZipResidual3 a b c (m :: Type -> Type) r1 r2 r3 = (Either r1 (Stream (Of a) m r1), Either r2 (Stream (Of b) m r2), Either r3 (Stream (Of c) m r3))

datadata Of a b where

Constructors

(:>) :: !a -> b -> Of a binfixr 5

Instances2Functor

Functor (Of a)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type
Functor (Of a)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type

datadata Stream (f :: Type -> Type) (m :: Type -> Type) r where

Constructors

Step :: !f (Stream f m r) -> Stream f m r
Effect :: m (Stream f m r) -> Stream f m r
Return :: r -> Stream f m r

Instances6MonadTrans, Monad, Functor, Applicative

Functor f => MonadTrans (Stream f)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type
(Functor m, Functor f) => Applicative (Stream f m)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type
(Functor m, Functor f) => Functor (Stream f m)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type
(Functor m, Functor f) => Monad (Stream f m)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type
(Functor m, Functor f) => Functor (Stream f m)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type
(Functor m, Functor f) => Applicative (Stream f m)Defined in linear-base-0.8.1 · Streaming.Linear.Internal.Type