Modulevector-0.13.2.0

Data.Vector.Fusion.Stream.Monadic

Synopsis

value !!
value !?
value ++
value and
value catMaybes
value cmpBy
value concatMap
value concatMapM
value cons
value drop
value dropWhile
value dropWhileM
value elem
value empty
value enumFromStepN
value enumFromThenTo
value enumFromTo
value eqBy
value filter
value filterM
value find
value findIndex
value findIndexM
value findM
value flatten
value fold1M
value fold1M'
value foldM
value foldM'
value foldl
value foldl'
value foldl1
value foldl1'
value foldl1M
value foldl1M'
value foldlM
value foldlM'
value foldr
value foldr1
value foldr1M
value foldrM
value fromList
value fromListN
value generate
value generateM
value head
value indexed
value indexedR
value init
value iterateN
value iterateNM
value last
value length
value liftBox
value map
value mapM
value mapM_
value mapMaybe
value mapMaybeM
value notElem
value null
value or
value postscanl
value postscanl'
value postscanlM
value postscanlM'
value prescanl
value prescanl'
value prescanlM
value prescanlM'
value replicate
value replicateM
value scanl
value scanl'
value scanl1
value scanl1'
value scanl1M
value scanl1M'
value scanlM
value scanlM'
value singleton
value slice
value snoc
value tail
value take
value takeWhile
value takeWhileM
value toList
value trans
value unbox
value unfoldr
value unfoldrExactN
value unfoldrExactNM
value unfoldrM
value unfoldrN
value unfoldrNM
value uniq
value zip
value zip3
value zip4
value zip5
value zip6
value zipWith
value zipWith3
value zipWith3M
value zipWith4
value zipWith4M
value zipWith5
value zipWith5M
value zipWith6
value zipWith6M
value zipWithM
value zipWithM_
data SPEC
data Box
data Step
data Stream

Packagevector-0.13.2.0
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

Source#

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.

SPEC SPEC2

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