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.Bundle

Contents

Types
In-place markers
Size hints
Length information
Construction
Accessing individual elements
Substreams
Mapping
Zipping
Filtering
Searching
Folding
Specialised folds
Unfolding
Scans
Enumerations
Conversions
Monadic combinators
Orphan instances

Description

Bundles for stream fusion

Synopsis

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
data Chunk v a = Chunk Int (forall m. (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m ())
type Bundle = Bundle Id
type MBundle = Bundle
inplace :: (forall m. Monad m => Stream m a -> Stream m b) -> (Size -> Size) -> Bundle v a -> Bundle v b
size :: Bundle v a -> Size
sized :: Bundle v a -> Size -> Bundle v a
length :: Bundle v a -> Int
null :: Bundle v a -> Bool
empty :: Bundle v a
singleton :: a -> Bundle v a
cons :: a -> Bundle v a -> Bundle v a
snoc :: Bundle v a -> a -> Bundle v a
replicate :: Int -> a -> Bundle v a
generate :: Int -> (Int -> a) -> Bundle v a
(++) :: Bundle v a -> Bundle v a -> Bundle v a
head :: Bundle v a -> a
last :: Bundle v a -> a
(!!) :: Bundle v a -> Int -> a
(!?) :: Bundle v a -> Int -> Maybe a
slice :: Int -> Int -> Bundle v a -> Bundle v a
init :: Bundle v a -> Bundle v a
tail :: Bundle v a -> Bundle v a
take :: Int -> Bundle v a -> Bundle v a
drop :: Int -> Bundle v a -> Bundle v a
map :: (a -> b) -> Bundle v a -> Bundle v b
concatMap :: (a -> Bundle v b) -> Bundle v a -> Bundle v b
flatten :: (a -> s) -> (s -> Step s b) -> Size -> Bundle v a -> Bundle v b
unbox :: Bundle v (Box a) -> Bundle v a
indexed :: Bundle v a -> Bundle v (Int, a)
indexedR :: Int -> Bundle v a -> Bundle v (Int, a)
zipWith :: (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
zipWith3 :: (a -> b -> c -> d) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d
zipWith4 :: (a -> b -> c -> d -> e) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e
zipWith5 :: (a -> b -> c -> d -> e -> f) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v f
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v f -> Bundle v g
zip :: Bundle v a -> Bundle v b -> Bundle v (a, b)
zip3 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v (a, b, c)
zip4 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v (a, b, c, d)
zip5 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v (a, b, c, d, e)
zip6 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v f -> Bundle v (a, b, c, d, e, f)
filter :: (a -> Bool) -> Bundle v a -> Bundle v a
takeWhile :: (a -> Bool) -> Bundle v a -> Bundle v a
dropWhile :: (a -> Bool) -> Bundle v a -> Bundle v a
elem :: Eq a => a -> Bundle v a -> Bool
notElem :: Eq a => a -> Bundle v a -> Bool
find :: (a -> Bool) -> Bundle v a -> Maybe a
findIndex :: (a -> Bool) -> Bundle v a -> Maybe Int
foldl :: (a -> b -> a) -> a -> Bundle v b -> a
foldl1 :: (a -> a -> a) -> Bundle v a -> a
foldl' :: (a -> b -> a) -> a -> Bundle v b -> a
foldl1' :: (a -> a -> a) -> Bundle v a -> a
foldr :: (a -> b -> b) -> b -> Bundle v a -> b
foldr1 :: (a -> a -> a) -> Bundle v a -> a
and :: Bundle v Bool -> Bool
or :: Bundle v Bool -> Bool
unfoldr :: (s -> Maybe (a, s)) -> s -> Bundle v a
unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Bundle v a
unfoldrExactN :: Int -> (s -> (a, s)) -> s -> Bundle v a
iterateN :: Int -> (a -> a) -> a -> Bundle v a
prescanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a
prescanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a
postscanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a
postscanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a
scanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a
scanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a
scanl1 :: (a -> a -> a) -> Bundle v a -> Bundle v a
scanl1' :: (a -> a -> a) -> Bundle v a -> Bundle v a
enumFromStepN :: Num a => a -> a -> Int -> Bundle v a
enumFromTo :: Enum a => a -> a -> Bundle v a
enumFromThenTo :: Enum a => a -> a -> a -> Bundle v a
toList :: Bundle v a -> [a]
fromList :: [a] -> Bundle v a
fromListN :: Int -> [a] -> Bundle v a
unsafeFromList :: Size -> [a] -> Bundle v a
lift :: Monad m => Bundle Id v a -> Bundle m v a
fromVector :: Vector v a => v a -> Bundle v a
reVector :: Bundle u a -> Bundle v a
fromVectors :: Vector v a => [v a] -> Bundle v a
concatVectors :: Vector v a => Bundle u (v a) -> Bundle v a
mapM :: Monad m => (a -> m b) -> Bundle v a -> Bundle m v b
mapM_ :: Monad m => (a -> m b) -> Bundle v a -> m ()
zipWithM :: Monad m => (a -> b -> m c) -> Bundle v a -> Bundle v b -> Bundle m v c
zipWithM_ :: Monad m => (a -> b -> m c) -> Bundle v a -> Bundle v b -> m ()
filterM :: Monad m => (a -> m Bool) -> Bundle v a -> Bundle m v a
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Bundle v a -> Bundle m v b
foldM :: Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a
fold1M :: Monad m => (a -> a -> m a) -> Bundle v a -> m a
foldM' :: Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a
fold1M' :: Monad m => (a -> a -> m a) -> Bundle v a -> m a
eq :: Eq a => Bundle v a -> Bundle v a -> Bool
cmp :: Ord a => Bundle v a -> Bundle v a -> Ordering
eqBy :: (a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
cmpBy :: (a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering

Types

data Step s a where #

Result of taking a single step in a stream

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 #

data Chunk v a Source #

Constructors

Chunk Int (forall m. (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m ())

type Bundle = Bundle Id Source #

The type of pure streams

type MBundle = Bundle Source #

Alternative name for monadic streams

In-place markers

inplace :: (forall m. Monad m => Stream m a -> Stream m b) -> (Size -> Size) -> Bundle v a -> Bundle v b Source #

Size hints

size :: Bundle v a -> Size Source #

Size hint of a Bundle

sized :: Bundle v a -> Size -> Bundle v a Source #

Attach a Size hint to a Bundle

Length information

length :: Bundle v a -> Int Source #

Length of a Bundle

null :: Bundle v a -> Bool Source #

Check if a Bundle is empty

Construction

empty :: Bundle v a Source #

Empty Bundle

singleton :: a -> Bundle v a Source #

Singleton Bundle

cons :: a -> Bundle v a -> Bundle v a Source #

Prepend an element

snoc :: Bundle v a -> a -> Bundle v a Source #

Append an element

replicate :: Int -> a -> Bundle v a Source #

Replicate a value to a given length

generate :: Int -> (Int -> a) -> Bundle v a Source #

Generate a stream from its indices

(++) :: Bundle v a -> Bundle v a -> Bundle v a infixr 5 Source #

Concatenate two Bundles

Accessing individual elements

head :: Bundle v a -> a Source #

First element of the Bundle or error if empty

last :: Bundle v a -> a Source #

Last element of the Bundle or error if empty

(!!) :: Bundle v a -> Int -> a infixl 9 Source #

Element at the given position

(!?) :: Bundle v a -> Int -> Maybe a infixl 9 Source #

Element at the given position or Nothing if out of bounds

Substreams

slice Source #

Arguments

:: Int	starting index
-> Int	length
-> Bundle v a
-> Bundle v a

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

init :: Bundle v a -> Bundle v a Source #

All but the last element

tail :: Bundle v a -> Bundle v a Source #

All but the first element

take :: Int -> Bundle v a -> Bundle v a Source #

The first n elements

drop :: Int -> Bundle v a -> Bundle v a Source #

All but the first n elements

Mapping

map :: (a -> b) -> Bundle v a -> Bundle v b Source #

Map a function over a Bundle

concatMap :: (a -> Bundle v b) -> Bundle v a -> Bundle v b Source #

flatten :: (a -> s) -> (s -> Step s b) -> Size -> Bundle v a -> Bundle v b Source #

Create a Bundle of values from a Bundle of streamable things

unbox :: Bundle v (Box a) -> Bundle v a Source #

Zipping

indexed :: Bundle v a -> Bundle v (Int, a) Source #

Pair each element in a Bundle with its index

indexedR :: Int -> Bundle v a -> Bundle v (Int, a) Source #

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

zipWith :: (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c Source #

Zip two Bundles with the given function

zipWith3 :: (a -> b -> c -> d) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d Source #

Zip three Bundles with the given function

zipWith4 :: (a -> b -> c -> d -> e) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e Source #

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v f Source #

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v f -> Bundle v g Source #

zip :: Bundle v a -> Bundle v b -> Bundle v (a, b) Source #

zip3 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v (a, b, c) Source #

zip4 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v (a, b, c, d) Source #

zip5 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v (a, b, c, d, e) Source #

zip6 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v e -> Bundle v f -> Bundle v (a, b, c, d, e, f) Source #

Filtering

filter :: (a -> Bool) -> Bundle v a -> Bundle v a Source #

Drop elements which do not satisfy the predicate

takeWhile :: (a -> Bool) -> Bundle v a -> Bundle v a Source #

Longest prefix of elements that satisfy the predicate

dropWhile :: (a -> Bool) -> Bundle v a -> Bundle v a Source #

Drop the longest prefix of elements that satisfy the predicate

Searching

elem :: Eq a => a -> Bundle v a -> Bool infix 4 Source #

Check whether the Bundle contains an element

notElem :: Eq a => a -> Bundle v a -> Bool infix 4 Source #

Inverse of elem

find :: (a -> Bool) -> Bundle v a -> Maybe a Source #

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

findIndex :: (a -> Bool) -> Bundle v a -> Maybe Int Source #

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

Folding

foldl :: (a -> b -> a) -> a -> Bundle v b -> a Source #

Left fold

foldl1 :: (a -> a -> a) -> Bundle v a -> a Source #

Left fold on non-empty Bundles

foldl' :: (a -> b -> a) -> a -> Bundle v b -> a Source #

Left fold with strict accumulator

foldl1' :: (a -> a -> a) -> Bundle v a -> a Source #

Left fold on non-empty Bundles with strict accumulator

foldr :: (a -> b -> b) -> b -> Bundle v a -> b Source #

Right fold

foldr1 :: (a -> a -> a) -> Bundle v a -> a Source #

Right fold on non-empty Bundles

Specialised folds

and :: Bundle v Bool -> Bool Source #

or :: Bundle v Bool -> Bool Source #

Unfolding

unfoldr :: (s -> Maybe (a, s)) -> s -> Bundle v a Source #

Unfold

unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Bundle v a Source #

Unfold at most n elements

unfoldrExactN :: Int -> (s -> (a, s)) -> s -> Bundle v a Source #

Unfold exactly n elements

Since: 0.12.2.0

iterateN :: Int -> (a -> a) -> a -> Bundle v a Source #

O(n) Apply function $\max(n - 1, 0)$ times to an initial value, producing a pure bundle of exact length $\max(n, 0)$. Zeroth element will contain the initial value.

Scans

prescanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a Source #

Prefix scan

prescanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a Source #

Prefix scan with strict accumulator

postscanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a Source #

Suffix scan

postscanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a Source #

Suffix scan with strict accumulator

scanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a Source #

Haskell-style scan

scanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a Source #

Haskell-style scan with strict accumulator

scanl1 :: (a -> a -> a) -> Bundle v a -> Bundle v a Source #

Initial-value free scan over a Bundle

scanl1' :: (a -> a -> a) -> Bundle v a -> Bundle v a Source #

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

Enumerations

enumFromStepN :: Num a => a -> a -> Int -> Bundle v a Source #

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

enumFromTo :: Enum a => a -> a -> Bundle v a Source #

Enumerate values

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

enumFromThenTo :: Enum a => a -> a -> a -> Bundle v a Source #

Enumerate values with a given step.

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

Conversions

toList :: Bundle v a -> [a] Source #

Convert a Bundle to a list

fromList :: [a] -> Bundle v a Source #

Create a Bundle from a list

fromListN :: Int -> [a] -> Bundle v a Source #

Create a Bundle from the first n elements of a list

fromListN n xs = fromList (take n xs)

unsafeFromList :: Size -> [a] -> Bundle v a Source #

lift :: Monad m => Bundle Id v a -> Bundle m v a Source #

Convert a pure stream to a monadic stream

fromVector :: Vector v a => v a -> Bundle v a Source #

reVector :: Bundle u a -> Bundle v a Source #

fromVectors :: Vector v a => [v a] -> Bundle v a Source #

concatVectors :: Vector v a => Bundle u (v a) -> Bundle v a Source #

Monadic combinators

mapM :: Monad m => (a -> m b) -> Bundle v a -> Bundle m v b Source #

Apply a monadic action to each element of the stream, producing a monadic stream of results

mapM_ :: Monad m => (a -> m b) -> Bundle v a -> m () Source #

Apply a monadic action to each element of the stream

zipWithM :: Monad m => (a -> b -> m c) -> Bundle v a -> Bundle v b -> Bundle m v c Source #

zipWithM_ :: Monad m => (a -> b -> m c) -> Bundle v a -> Bundle v b -> m () Source #

filterM :: Monad m => (a -> m Bool) -> Bundle v a -> Bundle m v a Source #

Yield a monadic stream of elements that satisfy the monadic predicate

mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Bundle v a -> Bundle m v b Source #

O(n) Apply monadic function to each element of a bundle and discard elements returning Nothing.

Since: 0.12.2.0

foldM :: Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Source #

Monadic fold

fold1M :: Monad m => (a -> a -> m a) -> Bundle v a -> m a Source #

Monadic fold over non-empty stream

foldM' :: Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Source #

Monadic fold with strict accumulator

fold1M' :: Monad m => (a -> a -> m a) -> Bundle v a -> m a Source #

Monad fold over non-empty stream with strict accumulator

eq :: Eq a => Bundle v a -> Bundle v a -> Bool Source #

Check if two Bundles are equal

cmp :: Ord a => Bundle v a -> Bundle v a -> Ordering Source #

Lexicographically compare two Bundles

eqBy :: (a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool Source #

cmpBy :: (a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering Source #

Orphan instances

Eq1 (Bundle Id v) Source #
Instance details Methods liftEq :: (a -> b -> Bool) -> Bundle Id v a -> Bundle Id v b -> Bool #
Ord1 (Bundle Id v) Source #
Instance details Methods liftCompare :: (a -> b -> Ordering) -> Bundle Id v a -> Bundle Id v b -> Ordering #
Eq a => Eq (Bundle Id v a) Source #
Instance details Methods (==) :: Bundle Id v a -> Bundle Id v a -> Bool # (/=) :: Bundle Id v a -> Bundle Id v a -> Bool #
Ord a => Ord (Bundle Id v a) Source #
Instance details Methods compare :: Bundle Id v a -> Bundle Id v a -> Ordering # (<) :: Bundle Id v a -> Bundle Id v a -> Bool # (<=) :: Bundle Id v a -> Bundle Id v a -> Bool # (>) :: Bundle Id v a -> Bundle Id v a -> Bool # (>=) :: Bundle Id v a -> Bundle Id v a -> Bool # max :: Bundle Id v a -> Bundle Id v a -> Bundle Id v a # min :: Bundle Id v a -> Bundle Id v a -> Bundle Id v a #