Data.Stream.Monadic · vector-stream-0.1.0.1

Box monad

2 declarations

datadata Box a

#

Box monad

Constructors

Box
- unBox :: a

Instances3Monad, Functor, Applicative

Monad BoxDefined in vector-stream-0.1.0.1 · Data.Stream.Monadic
Functor BoxDefined in vector-stream-0.1.0.1 · Data.Stream.Monadic
Applicative BoxDefined in vector-stream-0.1.0.1 · Data.Stream.Monadic

valueliftBox :: Monad m => Box a -> m a

#

Stream

3 declarations

datadata Stream (m :: Type -> Type) a

#

Monadic streams

Constructors

forall s. Stream (s -> m (Step s a)) s

Instances1Functor

Monad m => Functor (Stream m)Defined in vector-stream-0.1.0.1 · Data.Stream.Monadic

datadata Step s a where

#

Result of taking a single step in a stream

Constructors

Yield :: a -> s -> Step s a
Skip :: s -> Step s a
Done :: Step s a

Instances1Functor

Functor (Step s)Defined in vector-stream-0.1.0.1 · Data.Stream.Monadic

datadata SPEC

#

SPEC is used by GHC in the SpecConstr pass in order to inform the compiler when to be particularly aggressive. In particular, it tells GHC to specialize regardless of size or the number of specializations. However, not all loops fall into this category.

Libraries can specify this by using SPEC data type to inform which loops should be aggressively specialized. For example, instead of

loop x where loop arg = ...

write

loop SPEC x where loop !_ arg = ...

There is no semantic difference between SPEC and SPEC2, we just need a type with two constructors lest it is optimised away before SpecConstr.

This type is reexported from GHC.Exts since GHC 9.0 and base-4.15. For compatibility with earlier releases import it from GHC.Types in ghc-prim package.

SPEC SPEC2

Length

valuelength :: Monad m => Stream m a -> m Int

#

Length of a Stream

valuenull :: Monad m => Stream m a -> m Bool

#

Check if a Stream is empty

Construction

valueempty :: Monad m => Stream m a

#

Empty Stream

valuesingleton :: Monad m => a -> Stream m a

#

Singleton Stream

valuecons :: Monad m => a -> Stream m a -> Stream m a

#

Prepend an element

valuesnoc :: Monad m => Stream m a -> a -> Stream m a

#

Append an element

valuereplicate :: Monad m => Int -> a -> Stream m a

#

Replicate a value to a given length

valuereplicateM :: Monad m => Int -> m a -> Stream m a

#

Yield a Stream of values obtained by performing the monadic action the given number of times

valuegenerate :: Monad m => Int -> (Int -> a) -> Stream m a

#

valuegenerateM :: Monad m => Int -> (Int -> m a) -> Stream m a

#

Generate a stream from its indices

value(++) :: Monad m => Stream m a -> Stream m a -> Stream m a

#

Concatenate two Streams

Accessing elements

valuehead :: (HasCallStack, Monad m) => Stream m a -> m a

#

First element of the Stream or error if empty

valuelast :: (HasCallStack, Monad m) => Stream m a -> m a

#

Last element of the Stream or error if empty

value(!!) :: (HasCallStack, Monad m) => Stream m a -> Int -> m a

#

Element at the given position

value(!?) :: Monad m => Stream m a -> Int -> m (Maybe a)

#

Element at the given position or Nothing if out of bounds

Substreams

valueslice

:: Monad m
=> Int
starting index
-> Int
length
-> Stream m a
-> Stream m a

#

Extract a substream of the given length starting at the given position.

valueinit :: (HasCallStack, Monad m) => Stream m a -> Stream m a

#

All but the last element

valuetail :: (HasCallStack, Monad m) => Stream m a -> Stream m a

#

All but the first element

valuetake :: Monad m => Int -> Stream m a -> Stream m a

#

The first n elements

valuedrop :: Monad m => Int -> Stream m a -> Stream m a

#

All but the first n elements

Mapping

valuemap :: Monad m => (a -> b) -> Stream m a -> Stream m b

#

Map a function over a Stream

valuemapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b

#

Map a monadic function over a Stream

valuemapM_ :: Monad m => (a -> m b) -> Stream m a -> m ()

#

Execute a monadic action for each element of the Stream

valuetrans

:: (Monad m, Monad m')
=> forall z. m z -> m' z
-> Stream m a
-> Stream m' a

#

Transform a Stream to use a different monad

valueunbox :: Monad m => Stream m (Box a) -> Stream m a

#

valueconcatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b

#

valueflatten

:: Monad m
=> a -> m s
-> s -> m (Step s b)
-> Stream m a
-> Stream m b

#

Create a Stream of values from a Stream of streamable things

Zipping

valueindexed :: Monad m => Stream m a -> Stream m (Int, a)

#

Pair each element in a Stream with its index

valueindexedR :: Monad m => Int -> Stream m a -> Stream m (Int, a)

#

Pair each element in a Stream with its index, starting from the right and counting down

valuezipWithM_ :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> m ()

#

valuezipWithM

:: Monad m
=> a -> b -> m c
-> Stream m a
-> Stream m b
-> Stream m c

#

Zip two Streams with the given monadic function

valuezipWith3M

:: Monad m
=> a -> b -> c -> m d
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d

#

valuezipWith4M

:: Monad m
=> a -> b -> c -> d -> m e
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e

#

valuezipWith5M

:: Monad m
=> a -> b -> c -> d -> e -> m f
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e
-> Stream m f

#

valuezipWith6M

:: Monad m
=> a -> b -> c -> d -> e -> f -> m g
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e
-> Stream m f
-> Stream m g

#

valuezipWith

:: Monad m
=> a -> b -> c
-> Stream m a
-> Stream m b
-> Stream m c

#

valuezipWith3

:: Monad m
=> a -> b -> c -> d
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d

#

valuezipWith4

:: Monad m
=> a -> b -> c -> d -> e
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e

#

valuezipWith5

:: Monad m
=> a -> b -> c -> d -> e -> f
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e
-> Stream m f

#

valuezipWith6

:: Monad m
=> a -> b -> c -> d -> e -> f -> g
-> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e
-> Stream m f
-> Stream m g

#

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

#

valuezip3

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

#

valuezip4

:: Monad m
=> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m (a, b, c, d)

#

valuezip5

:: Monad m
=> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e
-> Stream m (a, b, c, d, e)

#

valuezip6

:: Monad m
=> Stream m a
-> Stream m b
-> Stream m c
-> Stream m d
-> Stream m e
-> Stream m f
-> Stream m (a, b, c, d, e, f)

#

Comparisons

valueeqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool

#

Check if two Streams are equal

valuecmpBy

:: Monad m
=> a -> b -> Ordering
-> Stream m a
-> Stream m b
-> m Ordering

#

Lexicographically compare two Streams

Filtering

valuefilter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

#

Drop elements which do not satisfy the predicate

valuefilterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

#

Drop elements which do not satisfy the monadic predicate

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

#

Drop repeated adjacent elements.

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

#

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

#

Apply monadic function to each element and drop all Nothings

valuecatMaybes :: Monad m => Stream m (Maybe a) -> Stream m a

#

valuetakeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

#

Longest prefix of elements that satisfy the predicate

valuetakeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

#

Longest prefix of elements that satisfy the monadic predicate

valuedropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

#

Drop the longest prefix of elements that satisfy the predicate

valuedropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

#

Drop the longest prefix of elements that satisfy the monadic predicate

Searching

valueelem :: (Monad m, Eq a) => a -> Stream m a -> m Bool

#

Check whether the Stream contains an element

valuenotElem :: (Monad m, Eq a) => a -> Stream m a -> m Bool

#

Inverse of elem

valuefind :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)

#

Yield Just the first element that satisfies the predicate or Nothing if no such element exists.

valuefindM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a)

#

Yield Just the first element that satisfies the monadic predicate or Nothing if no such element exists.

valuefindIndex :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe Int)

#

Yield Just the index of the first element that satisfies the predicate or Nothing if no such element exists.

valuefindIndexM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe Int)

#

Yield Just the index of the first element that satisfies the monadic predicate or Nothing if no such element exists.

Folding

valuefoldl :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a

#

Left fold

valuefoldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

#

Left fold with a monadic operator

valuefoldl1 :: Monad m => (a -> a -> a) -> Stream m a -> m a

#

Left fold over a non-empty Stream

valuefoldl1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a

#

Left fold over a non-empty Stream with a monadic operator

valuefoldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

#

Same as foldlM

valuefold1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a

#

Same as foldl1M

valuefoldl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a

#

Left fold with a strict accumulator

valuefoldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

#

Left fold with a strict accumulator and a monadic operator

valuefoldl1' :: Monad m => (a -> a -> a) -> Stream m a -> m a

#

Left fold over a non-empty Stream with a strict accumulator

valuefoldl1M' :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a

#

Left fold over a non-empty Stream with a strict accumulator and a monadic operator

valuefoldM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

#

Same as foldlM'

valuefold1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a

#

Same as foldl1M'

valuefoldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b

#

Right fold

valuefoldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b

#

Right fold with a monadic operator

valuefoldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m a

#

Right fold over a non-empty stream

valuefoldr1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a

#

Right fold over a non-empty stream with a monadic operator

Specialised folds

valueand :: Monad m => Stream m Bool -> m Bool

#

valueor :: Monad m => Stream m Bool -> m Bool

#

valueconcatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b

#

Unfolding

valueunfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a

#

Unfold

valueunfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a

#

Unfold with a monadic function

valueunfoldrN :: Monad m => Int -> (s -> Maybe (a, s)) -> s -> Stream m a

#

valueunfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a

#

Unfold at most n elements with a monadic function.

valueunfoldrExactN :: Monad m => Int -> (s -> (a, s)) -> s -> Stream m a

#

Unfold exactly n elements

valueunfoldrExactNM :: Monad m => Int -> (s -> m (a, s)) -> s -> Stream m a

#

Unfold exactly n elements with a monadic function.

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

#

O(n) Apply function \max(n - 1, 0) times to an initial value, producing a stream of \max(n, 0) values.

valueiterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a

#

O(n) Apply monadic function \max(n - 1, 0) times to an initial value, producing a stream of \max(n, 0) values.

Scans

valueprescanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

#

Prefix scan

valueprescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

#

Prefix scan with a monadic operator

valueprescanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

#

Prefix scan with strict accumulator

valueprescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

#

Prefix scan with strict accumulator and a monadic operator

valuepostscanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

#

Suffix scan

valuepostscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

#

Suffix scan with a monadic operator

valuepostscanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

#

Suffix scan with strict accumulator

valuepostscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

#

Suffix scan with strict acccumulator and a monadic operator

valuescanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

#

Haskell-style scan

valuescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

#

Haskell-style scan with a monadic operator

valuescanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

#

Haskell-style scan with strict accumulator

valuescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

#

Haskell-style scan with strict accumulator and a monadic operator

valuescanl1 :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a

#

Initial-value free scan over a Stream

valuescanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a

#

Initial-value free scan over a Stream with a monadic operator

valuescanl1' :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a

#

Initial-value free scan over a Stream with a strict accumulator

valuescanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a

#

Initial-value free scan over a Stream with a strict accumulator and a monadic operator

Enumerations

valueenumFromStepN :: (Num a, Monad m) => a -> a -> Int -> Stream m a

#

Yield a Stream of the given length containing the values x, x+y, x+y+y etc.

valueenumFromTo :: (Enum a, Monad m) => a -> a -> Stream m a

#

Enumerate values

WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

valueenumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Stream m a

#

Enumerate values with a given step.

WARNING: This operation is very inefficient. If at all possible, use enumFromStepN instead.

Conversions

valuetoList :: Monad m => Stream m a -> m [a]

#

Convert a Stream to a list

valuefromList :: Monad m => [a] -> Stream m a

#

Convert a list to a Stream

valuefromListN :: Monad m => Int -> [a] -> Stream m a

#

Convert the first n elements of a list to a Bundle