Copyright	(c) Roman Leshchinskiy 2008-2010 Alexey Kuleshevich 2020-2022 Aleksey Khudyakov 2020-2022 Andrew Lelechenko 2020-2022
License	BSD-style
Maintainer	Haskell Libraries Team <libraries@haskell.org>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Vector.Fusion.Stream.Monadic

Description

Monadic stream combinators.

Synopsis

foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b
foldl :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a
mapMaybe :: forall (m :: Type -> Type) a b. Monad m => (a -> Maybe b) -> Stream m a -> Stream m b
(!?) :: Monad m => Stream m a -> Int -> m (Maybe a)
length :: Monad m => Stream m a -> m Int
head :: (HasCallStack, Monad m) => Stream m a -> m a
foldl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a
foldl1 :: Monad m => (a -> a -> a) -> Stream m a -> m a
mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
mapM_ :: Monad m => (a -> m b) -> Stream m a -> m ()
filter :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a
unfoldr :: forall (m :: Type -> Type) s a. Monad m => (s -> Maybe (a, s)) -> s -> Stream m a
(++) :: forall (m :: Type -> Type) a. Monad m => Stream m a -> Stream m a -> Stream m a
zip :: forall (m :: Type -> Type) a b. Monad m => Stream m a -> Stream m b -> Stream m (a, b)
map :: forall (m :: Type -> Type) a b. Monad m => (a -> b) -> Stream m a -> Stream m b
enumFromTo :: forall a (m :: Type -> Type). (Enum a, Monad m) => a -> a -> Stream m a
enumFromThenTo :: forall a (m :: Type -> Type). (Enum a, Monad m) => a -> a -> a -> Stream m a
fromList :: forall (m :: Type -> Type) a. Monad m => [a] -> Stream m a
fromListN :: forall (m :: Type -> Type) a. Monad m => Int -> [a] -> Stream m a
toList :: Monad m => Stream m a -> m [a]
data SPEC
- = SPEC
- | SPEC2
empty :: forall (m :: Type -> Type) a. Monad m => Stream m a
catMaybes :: forall (m :: Type -> Type) a. Monad m => Stream m (Maybe a) -> Stream m a
tail :: forall (m :: Type -> Type) a. (HasCallStack, Monad m) => Stream m a -> Stream m a
last :: (HasCallStack, Monad m) => Stream m a -> m a
init :: forall (m :: Type -> Type) a. (HasCallStack, Monad m) => Stream m a -> Stream m a
null :: Monad m => Stream m a -> m Bool
foldl1' :: Monad m => (a -> a -> a) -> Stream m a -> m a
scanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
scanl1 :: forall (m :: Type -> Type) a. Monad m => (a -> a -> a) -> Stream m a -> Stream m a
scanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m a
replicate :: forall (m :: Type -> Type) a. Monad m => Int -> a -> Stream m a
takeWhile :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a
dropWhile :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a
take :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m a
drop :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m a
and :: Monad m => Stream m Bool -> m Bool
or :: Monad m => Stream m Bool -> m Bool
elem :: (Monad m, Eq a) => a -> Stream m a -> m Bool
notElem :: (Monad m, Eq a) => a -> Stream m a -> m Bool
concatMap :: forall (m :: Type -> Type) a b. Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
(!!) :: (HasCallStack, Monad m) => Stream m a -> Int -> m a
zip3 :: forall (m :: Type -> Type) a b c. Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m (a, b, c)
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
trans :: (Monad m, Monad m') => (forall z. m z -> m' z) -> Stream m a -> Stream m' a
foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b
foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)
findIndex :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe Int)
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)
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
singleton :: forall (m :: Type -> Type) a. Monad m => a -> Stream m a
data Stream (m :: Type -> Type) a = Stream (s -> m (Step s a)) s
filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
zipWithM_ :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> m ()
foldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
replicateM :: Monad m => Int -> m a -> Stream m a
cons :: forall (m :: Type -> Type) a. Monad m => a -> Stream m a -> Stream m a
snoc :: forall (m :: Type -> Type) a. Monad m => Stream m a -> a -> Stream m a
data Box a = Box {
- unBox :: a
}
liftBox :: Monad m => Box a -> m a
generate :: forall (m :: Type -> Type) a. Monad m => Int -> (Int -> a) -> Stream m a
generateM :: Monad m => Int -> (Int -> m a) -> Stream m a
slice :: forall (m :: Type -> Type) a. Monad m => Int -> Int -> Stream m a -> Stream m a
unbox :: forall (m :: Type -> Type) a. Monad m => Stream m (Box a) -> Stream m a
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b
indexed :: forall (m :: Type -> Type) a. Monad m => Stream m a -> Stream m (Int, a)
indexedR :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m (Int, a)
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
eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a)
findIndexM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe Int)
foldl1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
fold1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a
foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
foldl1M' :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
foldM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
fold1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a
foldr1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
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
unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a
unfoldrExactN :: forall (m :: Type -> Type) s a. Monad m => Int -> (s -> (a, s)) -> s -> Stream m a
unfoldrExactNM :: Monad m => Int -> (s -> m (a, s)) -> s -> Stream m a
iterateN :: forall (m :: Type -> Type) a. Monad m => Int -> (a -> a) -> a -> Stream m a
iterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a
prescanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
prescanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
prescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
postscanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
postscanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
postscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
scanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
scanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a
scanl1' :: forall (m :: Type -> Type) a. Monad m => (a -> a -> a) -> Stream m a -> Stream m a
scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a
enumFromStepN :: forall a (m :: Type -> Type). (Num a, Monad m) => a -> a -> Int -> Stream m a
data Step s a where
- Yield :: forall a s. a -> s -> Step s a
- Skip :: forall s a. s -> Step s a
- Done :: forall s a. Step s a
uniq :: forall a (m :: Type -> Type). (Eq a, Monad m) => Stream m a -> Stream m a

Documentation

foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b #

foldl :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a #

mapMaybe :: forall (m :: Type -> Type) a b. Monad m => (a -> Maybe b) -> Stream m a -> Stream m b #

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

length :: Monad m => Stream m a -> m Int #

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

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

foldl1 :: Monad m => (a -> a -> a) -> Stream m a -> m a #

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

mapM_ :: Monad m => (a -> m b) -> Stream m a -> m () #

filter :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a #

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

(++) :: forall (m :: Type -> Type) a. Monad m => Stream m a -> Stream m a -> Stream m a #

zip :: forall (m :: Type -> Type) a b. Monad m => Stream m a -> Stream m b -> Stream m (a, b) #

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

enumFromTo :: forall a (m :: Type -> Type). (Enum a, Monad m) => a -> a -> Stream m a #

enumFromThenTo :: forall a (m :: Type -> Type). (Enum a, Monad m) => a -> a -> a -> Stream m a #

fromList :: forall (m :: Type -> Type) a. Monad m => [a] -> Stream m a #

fromListN :: forall (m :: Type -> Type) a. Monad m => Int -> [a] -> Stream m a #

toList :: Monad m => Stream m a -> m [a] #

data 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 contructors 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.

Since: ghc-prim-0.3.1.0

Constructors

SPEC
SPEC2

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

catMaybes :: forall (m :: Type -> Type) a. Monad m => Stream m (Maybe a) -> Stream m a #

tail :: forall (m :: Type -> Type) a. (HasCallStack, Monad m) => Stream m a -> Stream m a #

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

init :: forall (m :: Type -> Type) a. (HasCallStack, Monad m) => Stream m a -> Stream m a #

null :: Monad m => Stream m a -> m Bool #

foldl1' :: Monad m => (a -> a -> a) -> Stream m a -> m a #

scanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

scanl1 :: forall (m :: Type -> Type) a. Monad m => (a -> a -> a) -> Stream m a -> Stream m a #

scanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m a #

replicate :: forall (m :: Type -> Type) a. Monad m => Int -> a -> Stream m a #

takeWhile :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a #

dropWhile :: forall (m :: Type -> Type) a. Monad m => (a -> Bool) -> Stream m a -> Stream m a #

take :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m a #

drop :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m a #

and :: Monad m => Stream m Bool -> m Bool #

or :: Monad m => Stream m Bool -> m Bool #

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

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

concatMap :: forall (m :: Type -> Type) a b. Monad m => (a -> Stream m b) -> Stream m a -> Stream m b #

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

zip3 :: forall (m :: Type -> Type) a b c. Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m (a, b, c) #

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 #

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

foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b #

foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a #

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

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

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) #

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 #

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

data Stream (m :: Type -> Type) a #

Constructors

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

Instances

Instances details

Monad m => Functor (Stream m)
Instance details Defined in Data.Stream.Monadic Methods fmap :: (a -> b) -> Stream m a -> Stream m b # (<$) :: a -> Stream m b -> Stream m a #

filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a #

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

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

foldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a #

replicateM :: Monad m => Int -> m a -> Stream m a #

cons :: forall (m :: Type -> Type) a. Monad m => a -> Stream m a -> Stream m a #

snoc :: forall (m :: Type -> Type) a. Monad m => Stream m a -> a -> Stream m a #

data Box a #

Constructors

Box
Fields unBox :: a

Instances

Instances details

Applicative Box
Instance details Defined in Data.Stream.Monadic Methods pure :: a -> Box a # (<>) :: Box (a -> b) -> Box a -> Box b # liftA2 :: (a -> b -> c) -> Box a -> Box b -> Box c # (>) :: Box a -> Box b -> Box b # (<*) :: Box a -> Box b -> Box a #
Functor Box
Instance details Defined in Data.Stream.Monadic Methods fmap :: (a -> b) -> Box a -> Box b # (<$) :: a -> Box b -> Box a #
Monad Box
Instance details Defined in Data.Stream.Monadic Methods (>>=) :: Box a -> (a -> Box b) -> Box b # (>>) :: Box a -> Box b -> Box b # return :: a -> Box a #

liftBox :: Monad m => Box a -> m a #

generate :: forall (m :: Type -> Type) a. Monad m => Int -> (Int -> a) -> Stream m a #

generateM :: Monad m => Int -> (Int -> m a) -> Stream m a #

slice :: forall (m :: Type -> Type) a. Monad m => Int -> Int -> Stream m a -> Stream m a #

unbox :: forall (m :: Type -> Type) a. Monad m => Stream m (Box a) -> Stream m a #

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

indexed :: forall (m :: Type -> Type) a. Monad m => Stream m a -> Stream m (Int, a) #

indexedR :: forall (m :: Type -> Type) a. Monad m => Int -> Stream m a -> Stream m (Int, a) #

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 #

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

cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering #

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

takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a #

dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a #

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

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

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

fold1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a #

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

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

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

fold1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a #

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

concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b #

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 #

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

unfoldrExactN :: forall (m :: Type -> Type) s a. Monad m => Int -> (s -> (a, s)) -> s -> Stream m a #

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

iterateN :: forall (m :: Type -> Type) a. Monad m => Int -> (a -> a) -> a -> Stream m a #

iterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a #

prescanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a #

prescanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

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

postscanl :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a #

postscanl' :: forall (m :: Type -> Type) a b. Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

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

scanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a #

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

scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a #

scanl1' :: forall (m :: Type -> Type) a. Monad m => (a -> a -> a) -> Stream m a -> Stream m a #

scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a #

enumFromStepN :: forall a (m :: Type -> Type). (Num a, Monad m) => a -> a -> Int -> Stream m a #

data Step s a where #

Constructors

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

Instances

Instances details

Functor (Step s)
Instance details Defined in Data.Stream.Monadic Methods fmap :: (a -> b) -> Step s a -> Step s b # (<$) :: a -> Step s b -> Step s a #

uniq :: forall a (m :: Type -> Type). (Eq a, Monad m) => Stream m a -> Stream m a #