vector-sized-0.3.2.0: Size tagged vectors

Safe HaskellNone
LanguageHaskell2010

Data.Vector.Generic.Sized

Contents

Description

This module reexports the functionality in Generic which maps well to explicity sized vectors.

Functions returning a vector determine the size from the type context unless they have a ' suffix in which case they take an explicit Proxy argument.

Functions where the resultant vector size is not know until compile time are not exported.

Synopsis

Documentation

data Vector v n a Source

A wrapper to tag vectors with a type level length.

Instances

Functor v => Functor (Vector v n) Source 
KnownNat n => Applicative (Vector Vector n) Source

The Applicative instance for sized vectors does not have the same behaviour as the Applicative instance for the unsized vectors found in the vectors package. The instance defined here has the same behaviour as the ZipList instance.

Foldable v => Foldable (Vector v n) Source 
Traversable v => Traversable (Vector v n) Source 
Eq (v a) => Eq (Vector v n a) Source 
Ord (v a) => Ord (Vector v n a) Source 
Show (v a) => Show (Vector v n a) Source 
(KnownNat n, Storable a, Vector v a) => Storable (Vector v n a) Source

Any sized vector containing storable elements is itself storable.

Vector v m => Monoid (Vector v 0 m) Source 
(Monoid m, Vector v m, KnownNat n) => Monoid (Vector v n m) Source

The Monoid instance for sized vectors does not have the same behaviour as the Monoid instance for the unsized vectors found in the vectors package. Its mempty is a vector of memptys and its mappend is zipWith mappend.

NFData (v a) => NFData (Vector v n a) Source 

Accessors

Length information

length :: forall v n a. KnownNat n => Vector v n a -> Int Source

O(1) Yield the length of the vector as an Int.

length' :: forall v n a. KnownNat n => Vector v n a -> Proxy n Source

O(1) Yield the length of the vector as a Proxy.

Indexing

index :: forall v n a. (KnownNat n, Vector v a) => Vector v n a -> Int -> a Source

O(1) Indexing using an Int.

index' :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Vector v (n + m) a -> Proxy n -> a Source

O(1) Safe indexing using a Proxy.

unsafeIndex :: forall v n a. (KnownNat n, Vector v a) => Vector v n a -> Int -> a Source

O(1) Indexing using an Int without bounds checking.

head :: forall v n a. Vector v a => Vector v (n + 1) a -> a Source

O(1) Yield the first element of a non-empty vector.

last :: forall v n a. Vector v a => Vector v (n + 1) a -> a Source

O(1) Yield the last element of a non-empty vector.

Monadic indexing

indexM :: forall v n a m. (KnownNat n, Vector v a, Monad m) => Vector v n a -> Int -> m a Source

O(1) Indexing in a monad. See the documentation for indexM for an explanation of why this is useful.

indexM' :: forall v n k a m. (KnownNat n, KnownNat k, Vector v a, Monad m) => Vector v (n + k) a -> Proxy n -> m a Source

O(1) Safe indexing in a monad using a Proxy. See the documentation for indexM for an explanation of why this is useful.

unsafeIndexM :: forall v n a m. (KnownNat n, Vector v a, Monad m) => Vector v n a -> Int -> m a Source

O(1) Indexing using an Int without bounds checking. See the documentation for indexM for an explanation of why this is useful.

headM :: forall v n a m. (KnownNat n, Vector v a, Monad m) => Vector v (n + 1) a -> m a Source

O(1) Yield the first element of a non-empty vector in a monad. See the documentation for indexM for an explanation of why this is useful.

lastM :: forall v n a m. (KnownNat n, Vector v a, Monad m) => Vector v (n + 1) a -> m a Source

O(1) Yield the last element of a non-empty vector in a monad. See the documentation for indexM for an explanation of why this is useful.

Extracting subvectors (slicing)

slice Source

Arguments

:: (KnownNat i, KnownNat n, Vector v a) 
=> Proxy i

starting index

-> Vector v (i + n) a 
-> Vector v n a 

O(1) Yield a slice of the vector without copying it with an inferred length argument.

slice' Source

Arguments

:: (KnownNat i, KnownNat n, Vector v a) 
=> Proxy i

starting index

-> Proxy n

length

-> Vector v (i + n) a 
-> Vector v n a 

O(1) Yield a slice of the vector without copying it with an explicit length argument.

init :: forall v n a. Vector v a => Vector v (n + 1) a -> Vector v n a Source

O(1) Yield all but the last element of a non-empty vector without copying.

tail :: forall v n a. Vector v a => Vector v (n + 1) a -> Vector v n a Source

O(1) Yield all but the first element of a non-empty vector without copying.

take :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Vector v (m + n) a -> Vector v n a Source

O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.

take' :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Proxy n -> Vector v (m + n) a -> Vector v n a Source

O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a Proxy argument.

drop :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Vector v (m + n) a -> Vector v m a Source

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.

drop' :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Proxy n -> Vector v (m + n) a -> Vector v m a Source

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a Proxy argument.

splitAt :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Vector v (n + m) a -> (Vector v n a, Vector v m a) Source

O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.

splitAt' :: forall v n m a. (KnownNat n, KnownNat m, Vector v a) => Proxy n -> Vector v (n + m) a -> (Vector v n a, Vector v m a) Source

O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a Proxy argument.

Construction

Initialization

empty :: forall v a. Vector v a => Vector v 0 a Source

O(1) Empty vector.

singleton :: forall v a. Vector v a => a -> Vector v 1 a Source

O(1) Vector with exactly one element.

replicate :: forall v n a. (KnownNat n, Vector v a) => a -> Vector v n a Source

O(n) Construct a vector with the same element in each position where the length is inferred from the type.

replicate' :: forall v n a. (KnownNat n, Vector v a) => Proxy n -> a -> Vector v n a Source

O(n) Construct a vector with the same element in each position where the length is given explicitly as a Proxy argument.

generate :: forall v n a. (KnownNat n, Vector v a) => (Int -> a) -> Vector v n a Source

O(n) construct a vector of the given length by applying the function to each index where the length is inferred from the type.

generate' :: forall v n a. (KnownNat n, Vector v a) => Proxy n -> (Int -> a) -> Vector v n a Source

O(n) construct a vector of the given length by applying the function to each index where the length is given explicitly as a Proxy argument.

iterateN :: forall v n a. (KnownNat n, Vector v a) => (a -> a) -> a -> Vector v n a Source

O(n) Apply function n times to value. Zeroth element is original value. The length is inferred from the type.

iterateN' :: forall v n a. (KnownNat n, Vector v a) => Proxy n -> (a -> a) -> a -> Vector v n a Source

O(n) Apply function n times to value. Zeroth element is original value. The length is given explicitly as a Proxy argument.

Monadic initialization

replicateM :: forall v n m a. (KnownNat n, Vector v a, Monad m) => m a -> m (Vector v n a) Source

O(n) Execute the monadic action n times and store the results in a vector where n is inferred from the type.

replicateM' :: forall v n m a. (KnownNat n, Vector v a, Monad m) => Proxy n -> m a -> m (Vector v n a) Source

O(n) Execute the monadic action n times and store the results in a vector where n is given explicitly as a Proxy argument.

generateM :: forall v n m a. (KnownNat n, Vector v a, Monad m) => (Int -> m a) -> m (Vector v n a) Source

O(n) Construct a vector of length n by applying the monadic action to each index where n is inferred from the type.

generateM' :: forall v n m a. (KnownNat n, Vector v a, Monad m) => Proxy n -> (Int -> m a) -> m (Vector v n a) Source

O(n) Construct a vector of length n by applying the monadic action to each index where n is given explicitly as a Proxy argument.

Unfolding

unfoldrN :: forall v n a b. (KnownNat n, Vector v a) => (b -> (a, b)) -> b -> Vector v n a Source

O(n) Construct a vector with exactly n elements by repeatedly applying the generator function to the a seed. The length, n, is inferred from the type.

unfoldrN' :: forall v n a b. (KnownNat n, Vector v a) => Proxy n -> (b -> (a, b)) -> b -> Vector v n a Source

O(n) Construct a vector with exactly n elements by repeatedly applying the generator function to the a seed. The length, n, is given explicitly as a Proxy argument.

Enumeration

enumFromN :: forall v n a. (KnownNat n, Vector v a, Num a) => a -> Vector v n a Source

O(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is inferred from the type.

enumFromN' :: forall v n a. (KnownNat n, Vector v a, Num a) => a -> Proxy n -> Vector v n a Source

O(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is given explicitly as a Proxy argument.

enumFromStepN :: forall v n a. (KnownNat n, Vector v a, Num a) => a -> a -> Vector v n a Source

O(n) Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is inferred from the type.

enumFromStepN' :: forall v n a. (KnownNat n, Vector v a, Num a) => a -> a -> Proxy n -> Vector v n a Source

O(n) Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is given explicitly as a Proxy argument.

Concatenation

cons :: forall v n a. Vector v a => a -> Vector v n a -> Vector v (n + 1) a Source

O(n) Prepend an element.

snoc :: forall v n a. Vector v a => Vector v n a -> a -> Vector v (n + 1) a Source

O(n) Append an element.

(++) :: forall v n m a. Vector v a => Vector v n a -> Vector v m a -> Vector v (n + m) a Source

O(m+n) Concatenate two vectors.

Restricting memory usage

force :: Vector v a => Vector v n a -> Vector v n a Source

O(n) Yield the argument but force it not to retain any extra memory, possibly by copying it.

This is especially useful when dealing with slices. For example:

force (slice 0 2 <huge vector>)

Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.

Modifying vectors

Bulk updates

(//) Source

Arguments

:: Vector v a 
=> Vector v m a

initial vector (of length m)

-> [(Int, a)]

list of index/value pairs (of length n)

-> Vector v m a 

O(m+n) For each pair (i,a) from the list, replace the vector element at position i by a.

<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>

update Source

Arguments

:: (Vector v a, Vector v (Int, a)) 
=> Vector v m a

initial vector (of length m)

-> Vector v n (Int, a)

vector of index/value pairs (of length n)

-> Vector v m a 

O(m+n) For each pair (i,a) from the vector of index/value pairs, replace the vector element at position i by a.

update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>

update_ Source

Arguments

:: (Vector v a, Vector v Int) 
=> Vector v m a

initial vector (of length m)

-> Vector v n Int

index vector (of length n)

-> Vector v n a

value vector (of length n)

-> Vector v m a 

O(m+n) For each index i from the index vector and the corresponding value a from the value vector, replace the element of the initial vector at position i by a.

update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>

This function is useful for instances of Vector that cannot store pairs. Otherwise, update is probably more convenient.

update_ xs is ys = update xs (zip is ys)

unsafeUpd Source

Arguments

:: Vector v a 
=> Vector v m a

initial vector (of length m)

-> [(Int, a)]

list of index/value pairs (of length n)

-> Vector v m a 

Same as (//) but without bounds checking.

unsafeUpdate Source

Arguments

:: (Vector v a, Vector v (Int, a)) 
=> Vector v m a

initial vector (of length m)

-> Vector v n (Int, a)

vector of index/value pairs (of length n)

-> Vector v m a 

Same as update but without bounds checking.

unsafeUpdate_ Source

Arguments

:: (Vector v a, Vector v Int) 
=> Vector v m a

initial vector (of length m)

-> Vector v n Int

index vector (of length n)

-> Vector v n a

value vector (of length n)

-> Vector v m a 

Same as update_ but without bounds checking.

Accumulations

accum Source

Arguments

:: Vector v a 
=> (a -> b -> a)

accumulating function f

-> Vector v m a

initial vector (of length m)

-> [(Int, b)]

list of index/value pairs (of length n)

-> Vector v m a 

O(m+n) For each pair (i,b) from the list, replace the vector element a at position i by f a b.

accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>

accumulate Source

Arguments

:: (Vector v a, Vector v (Int, b)) 
=> (a -> b -> a)

accumulating function f

-> Vector v m a

initial vector (of length m)

-> Vector v n (Int, b)

vector of index/value pairs (of length n)

-> Vector v m a 

O(m+n) For each pair (i,b) from the vector of pairs, replace the vector element a at position i by f a b.

accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>

accumulate_ Source

Arguments

:: (Vector v a, Vector v Int, Vector v b) 
=> (a -> b -> a)

accumulating function f

-> Vector v m a

initial vector (of length m)

-> Vector v n Int

index vector (of length n)

-> Vector v n b

value vector (of length n)

-> Vector v m a 

O(m+n) For each index i from the index vector and the corresponding value b from the the value vector, replace the element of the initial vector at position i by f a b.

accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>

This function is useful for instances of Vector that cannot store pairs. Otherwise, accumulate is probably more convenient:

accumulate_ f as is bs = accumulate f as (zip is bs)

unsafeAccum Source

Arguments

:: Vector v a 
=> (a -> b -> a)

accumulating function f

-> Vector v m a

initial vector (of length m)

-> [(Int, b)]

list of index/value pairs (of length n)

-> Vector v m a 

Same as accum but without bounds checking.

unsafeAccumulate Source

Arguments

:: (Vector v a, Vector v (Int, b)) 
=> (a -> b -> a)

accumulating function f

-> Vector v m a

initial vector (of length m)

-> Vector v n (Int, b)

vector of index/value pairs (of length n)

-> Vector v m a 

Same as accumulate but without bounds checking.

unsafeAccumulate_ Source

Arguments

:: (Vector v a, Vector v Int, Vector v b) 
=> (a -> b -> a)

accumulating function f

-> Vector v m a

initial vector (of length m)

-> Vector v n Int

index vector (of length n)

-> Vector v n b

value vector (of length n)

-> Vector v m a 

Same as accumulate_ but without bounds checking.

Permutations

reverse :: Vector v a => Vector v n a -> Vector v n a Source

O(n) Reverse a vector

backpermute Source

Arguments

:: (Vector v a, Vector v Int) 
=> Vector v m a

xs value vector

-> Vector v n Int

is index vector (of length n)

-> Vector v n a 

O(n) Yield the vector obtained by replacing each element i of the index vector by xs!i. This is equivalent to map (xs!) is but is often much more efficient.

backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>

unsafeBackpermute Source

Arguments

:: (Vector v a, Vector v Int) 
=> Vector v m a

xs value vector

-> Vector v n Int

is index vector (of length n)

-> Vector v n a 

Same as backpermute but without bounds checking.

Elementwise operations

Indexing

indexed :: (Vector v a, Vector v (Int, a)) => Vector v n a -> Vector v n (Int, a) Source

O(n) Pair each element in a vector with its index

Mapping

map :: (Vector v a, Vector v b) => (a -> b) -> Vector v n a -> Vector v n b Source

O(n) Map a function over a vector

imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> Vector v n a -> Vector v n b Source

O(n) Apply a function to every element of a vector and its index

concatMap :: (Vector v a, Vector v b) => (a -> Vector v m b) -> Vector v n a -> Vector v (n * m) b Source

O(n*m) Map a function over a vector and concatenate the results. The function is required to always return the same length vector.

Monadic mapping

mapM :: (Monad m, Vector v a, Vector v b) => (a -> m b) -> Vector v n a -> m (Vector v n b) Source

O(n) Apply the monadic action to all elements of the vector, yielding a vector of results

imapM :: (Monad m, Vector v a, Vector v b) => (Int -> a -> m b) -> Vector v n a -> m (Vector v n b) Source

O(n) Apply the monadic action to every element of a vector and its index, yielding a vector of results

mapM_ :: (Monad m, Vector v a) => (a -> m b) -> Vector v n a -> m () Source

O(n) Apply the monadic action to all elements of a vector and ignore the results

imapM_ :: (Monad m, Vector v a) => (Int -> a -> m b) -> Vector v n a -> m () Source

O(n) Apply the monadic action to every element of a vector and its index, ignoring the results

forM :: (Monad m, Vector v a, Vector v b) => Vector v n a -> (a -> m b) -> m (Vector v n b) Source

O(n) Apply the monadic action to all elements of the vector, yielding a vector of results. Equvalent to flip mapM.

forM_ :: (Monad m, Vector v a) => Vector v n a -> (a -> m b) -> m () Source

O(n) Apply the monadic action to all elements of a vector and ignore the results. Equivalent to flip mapM_.

Zipping

zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c Source

O(n) Zip two vectors of the same length with the given function.

zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d Source

Zip three vectors with the given function.

zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e Source

zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (a -> b -> c -> d -> e -> f) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f Source

zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (a -> b -> c -> d -> e -> f -> g) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n g Source

izipWith :: (Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c Source

O(n) Zip two vectors of the same length with a function that also takes the elements' indices).

izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Int -> a -> b -> c -> d) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d Source

izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (Int -> a -> b -> c -> d -> e) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e Source

izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f Source

izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n g Source

zip :: (Vector v a, Vector v b, Vector v (a, b)) => Vector v n a -> Vector v n b -> Vector v n (a, b) Source

O(n) Zip two vectors of the same length

zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n (a, b, c) Source

zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n (a, b, c, d) Source

zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n (a, b, c, d, e) Source

zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n (a, b, c, d, e, f) Source

Monadic zipping

zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (a -> b -> m c) -> Vector v n a -> Vector v n b -> m (Vector v n c) Source

O(n) Zip the two vectors of the same length with the monadic action and yield a vector of results

izipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> m c) -> Vector v n a -> Vector v n b -> m (Vector v n c) Source

O(n) Zip the two vectors with a monadic action that also takes the element index and yield a vector of results

zipWithM_ :: (Monad m, Vector v a, Vector v b) => (a -> b -> m c) -> Vector v n a -> Vector v n b -> m () Source

O(n) Zip the two vectors with the monadic action and ignore the results

izipWithM_ :: (Monad m, Vector v a, Vector v b) => (Int -> a -> b -> m c) -> Vector v n a -> Vector v n b -> m () Source

O(n) Zip the two vectors with a monadic action that also takes the element index and ignore the results

Unzipping

unzip :: (Vector v a, Vector v b, Vector v (a, b)) => Vector v n (a, b) -> (Vector v n a, Vector v n b) Source

O(min(m,n)) Unzip a vector of pairs.

unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => Vector v n (a, b, c) -> (Vector v n a, Vector v n b, Vector v n c) Source

unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vector v n (a, b, c, d) -> (Vector v n a, Vector v n b, Vector v n c, Vector v n d) Source

unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => Vector v n (a, b, c, d, e) -> (Vector v n a, Vector v n b, Vector v n c, Vector v n d, Vector v n e) Source

unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => Vector v n (a, b, c, d, e, f) -> (Vector v n a, Vector v n b, Vector v n c, Vector v n d, Vector v n e, Vector v n f) Source

Working with predicates

Searching

elem :: (Vector v a, Eq a) => a -> Vector v n a -> Bool infix 4 Source

O(n) Check if the vector contains an element

notElem :: (Vector v a, Eq a) => a -> Vector v n a -> Bool infix 4 Source

O(n) Check if the vector does not contain an element (inverse of elem)

find :: Vector v a => (a -> Bool) -> Vector v n a -> Maybe a Source

O(n) Yield Just the first element matching the predicate or Nothing if no such element exists.

findIndex :: Vector v a => (a -> Bool) -> Vector v n a -> Maybe Int Source

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

elemIndex :: (Vector v a, Eq a) => a -> Vector v n a -> Maybe Int Source

O(n) Yield Just the index of the first occurence of the given element or Nothing if the vector does not contain the element. This is a specialised version of findIndex.

Folding

foldl :: Vector v b => (a -> b -> a) -> a -> Vector v n b -> a Source

O(n) Left fold

foldl1 :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> a Source

O(n) Left fold on non-empty vectors

foldl' :: Vector v b => (a -> b -> a) -> a -> Vector v n b -> a Source

O(n) Left fold with strict accumulator

foldl1' :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> a Source

O(n) Left fold on non-empty vectors with strict accumulator

foldr :: Vector v a => (a -> b -> b) -> b -> Vector v n a -> b Source

O(n) Right fold

foldr1 :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> a Source

O(n) Right fold on non-empty vectors

foldr' :: Vector v a => (a -> b -> b) -> b -> Vector v n a -> b Source

O(n) Right fold with a strict accumulator

foldr1' :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> a Source

O(n) Right fold on non-empty vectors with strict accumulator

ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> Vector v n b -> a Source

O(n) Left fold (function applied to each element and its index)

ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> Vector v n b -> a Source

O(n) Left fold with strict accumulator (function applied to each element and its index)

ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> Vector v n a -> b Source

O(n) Right fold (function applied to each element and its index)

ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> Vector v n a -> b Source

O(n) Right fold with strict accumulator (function applied to each element and its index)

Specialised folds

all :: Vector v a => (a -> Bool) -> Vector v n a -> Bool Source

O(n) Check if all elements satisfy the predicate.

any :: Vector v a => (a -> Bool) -> Vector v n a -> Bool Source

O(n) Check if any element satisfies the predicate.

and :: Vector v Bool => Vector v n Bool -> Bool Source

O(n) Check if all elements are True

or :: Vector v Bool => Vector v n Bool -> Bool Source

O(n) Check if any element is True

sum :: (Vector v a, Num a) => Vector v n a -> a Source

O(n) Compute the sum of the elements

product :: (Vector v a, Num a) => Vector v n a -> a Source

O(n) Compute the produce of the elements

maximum :: (Vector v a, Ord a, KnownNat n) => Vector v (n + 1) a -> a Source

O(n) Yield the maximum element of the non-empty vector.

maximumBy :: (Vector v a, KnownNat n) => (a -> a -> Ordering) -> Vector v (n + 1) a -> a Source

O(n) Yield the maximum element of the non-empty vector according to the given comparison function.

minimum :: (Vector v a, Ord a, KnownNat n) => Vector v (n + 1) a -> a Source

O(n) Yield the minimum element of the non-empty vector.

minimumBy :: (Vector v a, KnownNat n) => (a -> a -> Ordering) -> Vector v (n + 1) a -> a Source

O(n) Yield the minimum element of the non-empty vector according to the given comparison function.

maxIndex :: (Vector v a, Ord a, KnownNat n) => Vector v (n + 1) a -> Int Source

O(n) Yield the index of the maximum element of the non-empty vector.

maxIndexBy :: (Vector v a, KnownNat n) => (a -> a -> Ordering) -> Vector v (n + 1) a -> Int Source

O(n) Yield the index of the maximum element of the non-empty vector according to the given comparison function.

minIndex :: (Vector v a, Ord a, KnownNat n) => Vector v (n + 1) a -> Int Source

O(n) Yield the index of the minimum element of the non-empty vector.

minIndexBy :: (Vector v a, KnownNat n) => (a -> a -> Ordering) -> Vector v (n + 1) a -> Int Source

O(n) Yield the index of the minimum element of the non-empty vector according to the given comparison function.

Monadic folds

foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m a Source

O(n) Monadic fold

ifoldM :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> Vector v n b -> m a Source

O(n) Monadic fold (action applied to each element and its index)

fold1M :: (Monad m, Vector v a, KnownNat n) => (a -> a -> m a) -> Vector v (n + 1) a -> m a Source

O(n) Monadic fold over non-empty vectors

foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m a Source

O(n) Monadic fold with strict accumulator

ifoldM' :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> Vector v n b -> m a Source

O(n) Monadic fold with strict accumulator (action applied to each element and its index)

fold1M' :: (Monad m, Vector v a, KnownNat n) => (a -> a -> m a) -> Vector v (n + 1) a -> m a Source

O(n) Monadic fold over non-empty vectors with strict accumulator

foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m () Source

O(n) Monadic fold that discards the result

ifoldM_ :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> Vector v n b -> m () Source

O(n) Monadic fold that discards the result (action applied to each element and its index)

fold1M_ :: (Monad m, Vector v a, KnownNat n) => (a -> a -> m a) -> Vector v (n + 1) a -> m () Source

O(n) Monadic fold over non-empty vectors that discards the result

foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m () Source

O(n) Monadic fold with strict accumulator that discards the result

ifoldM'_ :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> Vector v n b -> m () Source

O(n) Monadic fold with strict accumulator that discards the result (action applied to each element and its index)

fold1M'_ :: (Monad m, Vector v a, KnownNat n) => (a -> a -> m a) -> Vector v (n + 1) a -> m () Source

O(n) Monad fold over non-empty vectors with strict accumulator that discards the result

Monadic sequencing

sequence :: (Monad m, Vector v a, Vector v (m a)) => Vector v n (m a) -> m (Vector v n a) Source

Evaluate each action and collect the results

sequence_ :: (Monad m, Vector v (m a)) => Vector v n (m a) -> m () Source

Evaluate each action and discard the results

Prefix sums (scans)

prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a Source

O(n) Prescan

prescanl f z = init . scanl f z

Example: prescanl (+) 0 <1,2,3,4> = <0,1,3,6>

prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a Source

O(n) Prescan with strict accumulator

postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a Source

O(n) Scan

postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a Source

O(n) Scan with strict accumulator

scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a Source

O(n) Haskell-style scan

scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a Source

O(n) Haskell-style scan with strict accumulator

scanl1 :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 1) a Source

O(n) Scan over a non-empty vector

scanl1' :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 1) a Source

O(n) Scan over a non-empty vector with a strict accumulator

prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b Source

O(n) Right-to-left prescan

prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b Source

O(n) Right-to-left prescan with strict accumulator

postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b Source

O(n) Right-to-left scan

postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b Source

O(n) Right-to-left scan with strict accumulator

scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b Source

O(n) Right-to-left Haskell-style scan

scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b Source

O(n) Right-to-left Haskell-style scan with strict accumulator

scanr1 :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 1) a Source

O(n) Right-to-left scan over a non-empty vector

scanr1' :: (Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 1) a Source

O(n) Right-to-left scan over a non-empty vector with a strict accumulator

Conversions

Lists

toList :: Vector v a => Vector v n a -> [a] Source

O(n) Convert a vector to a list

fromList :: (Vector v a, KnownNat n) => [a] -> Maybe (Vector v n a) Source

O(n) Convert a list to a vector

fromListN :: forall v n a. (Vector v a, KnownNat n) => [a] -> Maybe (Vector v n a) Source

O(n) Convert the first n elements of a list to a vector. The length of the resultant vector is inferred from the type.

fromListN' :: forall v n a. (Vector v a, KnownNat n) => Proxy n -> [a] -> Maybe (Vector v n a) Source

O(n) Convert the first n elements of a list to a vector. The length of the resultant vector is given explicitly as a Proxy argument.

Other Vector types

convert :: (Vector v a, Vector w a) => Vector v n a -> Vector w n a Source

O(n) Convert different vector types

Unsized Vectors

toSized :: forall v n a. (Vector v a, KnownNat n) => v a -> Maybe (Vector v n a) Source

Convert a Vector into a Vector if it has the correct size, otherwise return Nothing.

fromSized :: Vector v n a -> v a Source

withVectorUnsafe :: forall a b v w n. (Vector v a, Vector w b) => (v a -> w b) -> Vector v n a -> Vector w n b Source

Apply a function on unsized vectors to a sized vector. The function must preserve the size of the vector, this is not checked.