-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Efficient Streams
--   
--   Simple yet powerful monadic streams that are used as a backbone for
--   vector package fusion functionality.
@package vector-stream
@version 0.1.0.1

-- | Monadic stream combinators.
module Data.Stream.Monadic

-- | Box monad
data Box a
Box :: a -> Box a
[unBox] :: Box a -> a
liftBox :: Monad m => Box a -> m a

-- | Monadic streams
data Stream (m :: Type -> Type) a
Stream :: (s -> m (Step s a)) -> s -> Stream (m :: Type -> Type) a

-- | Result of taking a single step in a stream
data Step s a
[Yield] :: forall a s. a -> s -> Step s a
[Skip] :: forall s a. s -> Step s a
[Done] :: forall s a. Step s a

-- | 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.
data SPEC
SPEC :: SPEC
SPEC2 :: SPEC

-- | Length of a Stream
length :: Monad m => Stream m a -> m Int

-- | Check if a Stream is empty
null :: Monad m => Stream m a -> m Bool

-- | Empty Stream
empty :: forall (m :: Type -> Type) a. Monad m => Stream m a

-- | Singleton Stream
singleton :: forall (m :: Type -> Type) a. Monad m => a -> Stream m a

-- | Prepend an element
cons :: forall (m :: Type -> Type) a. Monad m => a -> Stream m a -> Stream m a

-- | Append an element
snoc :: forall (m :: Type -> Type) a. Monad m => Stream m a -> a -> Stream m a

-- | Replicate a value to a given length
replicate :: forall (m :: Type -> Type) a. Monad m => Int -> a -> Stream m a

-- | Yield a Stream of values obtained by performing the monadic
--   action the given number of times
replicateM :: Monad m => Int -> m a -> Stream m a
generate :: forall (m :: Type -> Type) a. Monad m => Int -> (Int -> a) -> Stream m a

-- | Generate a stream from its indices
generateM :: Monad m => Int -> (Int -> m a) -> Stream m a

-- | Concatenate two Streams
(++) :: forall (m :: Type -> Type) a. Monad m => Stream m a -> Stream m a -> Stream m a
infixr 5 ++

-- | First element of the Stream or error if empty
head :: (HasCallStack, Monad m) => Stream m a -> m a

-- | Last element of the Stream or error if empty
last :: (HasCallStack, Monad m) => Stream m a -> m a

-- | Element at the given position
(!!) :: (HasCallStack, Monad m) => Stream m a -> Int -> m a
infixl 9 !!

-- | Element at the given position or Nothing if out of bounds
(!?) :: Monad m => Stream m a -> Int -> m (Maybe a)
infixl 9 !?

-- | Extract a substream of the given length starting at the given
--   position.
slice :: forall (m :: Type -> Type) a. Monad m => Int -> Int -> Stream m a -> Stream m a

-- | All but the last element
init :: forall (m :: Type -> Type) a. (HasCallStack, Monad m) => Stream m a -> Stream m a

-- | All but the first element
tail :: forall (m :: Type -> Type) a. (HasCallStack, Monad m) => Stream m a -> Stream m a

-- | The first n elements
take :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m a

-- | All but the first n elements
drop :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m a

-- | Map a function over a Stream
map :: forall (m :: Type -> Type) a b. Monad m => (a -> b) -> Stream m a -> Stream m b

-- | Map a monadic function over a Stream
mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b

-- | Execute a monadic action for each element of the Stream
mapM_ :: Monad m => (a -> m b) -> Stream m a -> m ()

-- | Transform a Stream to use a different monad
trans :: (Monad m, Monad m') => (forall z. () => m z -> m' z) -> Stream m a -> Stream m' a
unbox :: forall (m :: Type -> Type) a. Monad m => Stream m (Box a) -> Stream m a
concatMap :: forall (m :: Type -> Type) a b. Monad m => (a -> Stream m b) -> Stream m a -> Stream m b

-- | Create a Stream of values from a Stream of streamable
--   things
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b

-- | Pair each element in a Stream with its index
indexed :: forall (m :: Type -> Type) a. Monad m => Stream m a -> Stream m (Int, a)

-- | Pair each element in a Stream with its index, starting from the
--   right and counting down
indexedR :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m (Int, a)
zipWithM_ :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> m ()

-- | Zip two Streams with the given monadic function
zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
zipWith3M :: Monad m => (a -> b -> c -> m d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d
zipWith4M :: Monad m => (a -> b -> c -> d -> m e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
zipWith5M :: 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
zipWith6M :: 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
zipWith :: forall (m :: Type -> Type) a b c. Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
zipWith3 :: forall (m :: Type -> Type) a b c d. Monad m => (a -> b -> c -> d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d
zipWith4 :: forall (m :: Type -> Type) a b c d e. Monad m => (a -> b -> c -> d -> e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
zipWith5 :: forall (m :: Type -> Type) a b c d e f. 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
zipWith6 :: forall (m :: Type -> Type) a b c d e f g. 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
zip :: forall (m :: Type -> Type) a b. Monad m => Stream m a -> Stream m b -> Stream m (a, b)
zip3 :: forall (m :: Type -> Type) a b c. Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m (a, b, c)
zip4 :: forall (m :: Type -> Type) a b c d. Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m (a, b, c, d)
zip5 :: forall (m :: Type -> Type) a b c d e. Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m (a, b, c, d, e)
zip6 :: forall (m :: Type -> Type) a b c d e f. 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)

-- | Check if two Streams are equal
eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool

-- | Lexicographically compare two Streams
cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering

-- | Drop elements which do not satisfy the predicate
filter :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a

-- | Drop elements which do not satisfy the monadic predicate
filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

-- | Drop repeated adjacent elements.
uniq :: forall a (m :: Type -> Type). (Eq a, Monad m) => Stream m a -> Stream m a
mapMaybe :: forall (m :: Type -> Type) a b. Monad m => (a -> Maybe b) -> Stream m a -> Stream m b

-- | Apply monadic function to each element and drop all Nothings
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
catMaybes :: forall (m :: Type -> Type) a. Monad m => Stream m (Maybe a) -> Stream m a

-- | Longest prefix of elements that satisfy the predicate
takeWhile :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a

-- | Longest prefix of elements that satisfy the monadic predicate
takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

-- | Drop the longest prefix of elements that satisfy the predicate
dropWhile :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a

-- | Drop the longest prefix of elements that satisfy the monadic predicate
dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

-- | Check whether the Stream contains an element
elem :: (Monad m, Eq a) => a -> Stream m a -> m Bool
infix 4 `elem`

-- | Inverse of elem
notElem :: (Monad m, Eq a) => a -> Stream m a -> m Bool
infix 4 `notElem`

-- | Yield Just the first element that satisfies the predicate or
--   Nothing if no such element exists.
find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)

-- | Yield Just the first element that satisfies the monadic
--   predicate or Nothing if no such element exists.
findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a)

-- | Yield Just the index of the first element that satisfies the
--   predicate or Nothing if no such element exists.
findIndex :: Monad m => (a -> 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.
findIndexM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe Int)

-- | Left fold
foldl :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a

-- | Left fold with a monadic operator
foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

-- | Left fold over a non-empty Stream
foldl1 :: Monad m => (a -> a -> a) -> Stream m a -> m a

-- | Left fold over a non-empty Stream with a monadic operator
foldl1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a

-- | Same as foldlM
foldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

-- | Same as foldl1M
fold1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a

-- | Left fold with a strict accumulator
foldl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a

-- | Left fold with a strict accumulator and a monadic operator
foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

-- | Left fold over a non-empty Stream with a strict accumulator
foldl1' :: Monad m => (a -> a -> a) -> Stream m a -> m a

-- | Left fold over a non-empty Stream with a strict accumulator and
--   a monadic operator
foldl1M' :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a

-- | Same as foldlM'
foldM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a

-- | Same as foldl1M'
fold1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a

-- | Right fold
foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b

-- | Right fold with a monadic operator
foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b

-- | Right fold over a non-empty stream
foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m a

-- | Right fold over a non-empty stream with a monadic operator
foldr1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
and :: Monad m => Stream m Bool -> m Bool
or :: Monad m => Stream m Bool -> m Bool
concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b

-- | Unfold
unfoldr :: forall (m :: Type -> Type) s a. Monad m => (s -> Maybe (a, s)) -> s -> Stream m a

-- | Unfold with a monadic function
unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
unfoldrN :: forall (m :: Type -> Type) s a. Monad m => Int -> (s -> Maybe (a, s)) -> s -> Stream m a

-- | Unfold at most n elements with a monadic function.
unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a

-- | Unfold exactly n elements
unfoldrExactN :: forall (m :: Type -> Type) s a. Monad m => Int -> (s -> (a, s)) -> s -> Stream m a

-- | Unfold exactly n elements with a monadic function.
unfoldrExactNM :: Monad m => Int -> (s -> m (a, s)) -> s -> Stream m a

-- | O(n) Apply function <math> times to an initial value,
--   producing a stream of <math> values.
iterateN :: forall (m :: Type -> Type) a. Monad m => Int -> (a -> a) -> a -> Stream m a

-- | O(n) Apply monadic function <math> times to an initial
--   value, producing a stream of <math> values.
iterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a

-- | Prefix scan
prescanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

-- | Prefix scan with a monadic operator
prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

-- | Prefix scan with strict accumulator
prescanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

-- | Prefix scan with strict accumulator and a monadic operator
prescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

-- | Suffix scan
postscanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

-- | Suffix scan with a monadic operator
postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

-- | Suffix scan with strict accumulator
postscanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

-- | Suffix scan with strict acccumulator and a monadic operator
postscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

-- | Haskell-style scan
scanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

-- | Haskell-style scan with a monadic operator
scanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

-- | Haskell-style scan with strict accumulator
scanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a

-- | Haskell-style scan with strict accumulator and a monadic operator
scanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a

-- | Initial-value free scan over a Stream
scanl1 :: forall (m :: Type -> Type) a. Monad m => (a -> a -> a) -> Stream m a -> Stream m a

-- | Initial-value free scan over a Stream with a monadic operator
scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a

-- | Initial-value free scan over a Stream with a strict accumulator
scanl1' :: forall (m :: Type -> Type) a. Monad m => (a -> a -> a) -> Stream m a -> Stream m a

-- | Initial-value free scan over a Stream with a strict accumulator
--   and a monadic operator
scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a

-- | Yield a Stream of the given length containing the values
--   x, x+y, x+y+y etc.
enumFromStepN :: forall a (m :: Type -> Type). (Num a, Monad m) => a -> a -> Int -> Stream m a

-- | Enumerate values
--   
--   WARNING: This operation can be very inefficient. If at all
--   possible, use enumFromStepN instead.
enumFromTo :: forall a (m :: Type -> Type). (Enum a, Monad m) => a -> a -> Stream m a

-- | Enumerate values with a given step.
--   
--   WARNING: This operation is very inefficient. If at all
--   possible, use enumFromStepN instead.
enumFromThenTo :: forall a (m :: Type -> Type). (Enum a, Monad m) => a -> a -> a -> Stream m a

-- | Convert a Stream to a list
toList :: Monad m => Stream m a -> m [a]

-- | Convert a list to a Stream
fromList :: forall (m :: Type -> Type) a. Monad m => [a] -> Stream m a

-- | Convert the first n elements of a list to a Bundle
fromListN :: forall (m :: Type -> Type) a. Monad m => Int -> [a] -> Stream m a
instance GHC.Internal.Base.Applicative Data.Stream.Monadic.Box
instance GHC.Internal.Base.Functor Data.Stream.Monadic.Box
instance GHC.Internal.Base.Functor (Data.Stream.Monadic.Step s)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Functor (Data.Stream.Monadic.Stream m)
instance GHC.Internal.Base.Monad Data.Stream.Monadic.Box
