Skip to content

HORIZON HASKELL Docs lts/ghc-10.0.xc7d136e2026-10-12Search names, modules, packages, or :: a typeCtrl K

GHC 10.0.0.20260917 · lts/ghc-10.0.x · c7d136e · 2026-10-12

Modulevector-stream-0.1.0.1

Data.Stream.Monadic

4 types
113 values

Packagevector-stream-0.1.0.1
Exports117
LicenceBSD-3-Clause
SourceTypes.hs

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

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

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

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

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

valuecmpBy

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

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

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

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

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

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

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

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

valueempty :: Monad m => Stream m a

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

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

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

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

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

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

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

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

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

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

valueflatten

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

valuetrans

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

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

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

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

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

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

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

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

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)

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

valuezipWith3M

:: Monad m
=> a -> b -> c -> m 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

valuezipWith4M

:: Monad m
=> a -> b -> c -> d -> m 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

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

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

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

valuezipWithM

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

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

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.Internal.Types in ghc-internal package.

datadata Box a

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

datadata Step s a where

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 Stream (m :: Type -> Type) a

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