A wrapper to tag vectors with a type level length.

Be careful when using the constructor here to not construct sized vectors which have a different length than that specified in the type parameter!

A wrapper to tag mutable vectors with a type level length.

Be careful when using the constructor here to not construct sized vectors which have a different length than that specified in the type parameter!

O(1) Yield the length of the vector as an Int. This is more like natVal than length, extracting the value from the KnownNat instance and not looking at the vector itself.

O(1) Yield the length of the vector as a Proxy. This function doesn't do anything; it merely allows the size parameter of the vector to be passed around as a Proxy.

O(1) Reveal a KnownNat instance for a vector's length, determined at runtime.

O(1) Reveal a KnownNat instance and Proxy for a vector's length, determined at runtime.

O(1) Safe indexing using a Finite.

O(1) Safe indexing using a Proxy.

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

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

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

O(1) Safe indexing in a monad.

The monad allows operations to be strict in the vector when necessary. Suppose vector copying is implemented like this:

copy mv v = ... write mv i (v ! i) ...

For lazy vectors, v ! i would not be evaluated, which means that mv would unnecessarily retain a reference to v in each element when written.

With indexM, copying can be implemented like this instead:

copy mv v = ... do
                 x <- indexM v i
                 write mv i x

Here, no references to v are retained, because indexing (but not the elements) are evaluated eagerly.

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

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

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.

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.

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

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

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

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

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

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

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

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

O(1) Yield the first n elements, paired with the rest, without copying. The lengths of the resulting vectors are inferred from the type.

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

O(1) Empty vector.

O(1) Vector with exactly one element.

O(n) Construct a vector in a type-safe manner. fromTuple (1,2) :: Vector v 2 Int fromTuple ("hey", "what's", "going", "on") :: Vector v 4 String

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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

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

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

O(n) Prepend an element.

O(n) Append an element.

O(m+n) Concatenate two vectors.

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.

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>

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>

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)

Same as (//) but without bounds checking.

Same as update but without bounds checking.

Same as update_ but without bounds checking.

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>

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>

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)

Same as accum but without bounds checking.

Same as accumulate but without bounds checking.

Same as accumulate_ but without bounds checking.

O(n) Reverse a vector

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>

Same as backpermute but without bounds checking.

Lens to access (O(1)) and update (O(n)) an arbitrary element by its index.

Type-safe lens to access (O(1)) and update (O(n)) an arbitrary element by its index which should be supplied via TypeApplications.

Lens to access (O(1)) and update (O(n)) the first element of a non-empty vector.

Lens to access (O(1)) and update (O(n)) the last element of a non-empty vector.

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

O(n) Map a function over a vector.

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

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

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

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

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

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

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

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

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

Zip three vectors with the given function.

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

O(n) Zip two vectors of the same length

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

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

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

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

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

O(n) Check if the vector contains an element.

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

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

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

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.

O(n) Left fold.

O(n) Left fold on non-empty vectors.

O(n) Left fold with strict accumulator.

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

O(n) Right fold.

O(n) Right fold on non-empty vectors.

O(n) Right fold with a strict accumulator.

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

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

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

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

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

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

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

O(n) Check if all elements are True

O(n) Check if any element is True

O(n) Compute the sum of the elements.

O(n) Compute the product of the elements.

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

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

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

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

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

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

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

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

O(n) Monadic fold.

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

O(n) Monadic fold over non-empty vectors.

O(n) Monadic fold with strict accumulator.

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

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

O(n) Monadic fold that discards the result.

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

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

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

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

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

Evaluate each action and collect the results.

Evaluate each action and discard the results.

O(n) Prescan

prescanl f z = init . scanl f z

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

O(n) Prescan with strict accumulator.

O(n) Scan

O(n) Scan with strict accumulator.

O(n) Haskell-style scan.

O(n) Haskell-style scan with strict accumulator.

O(n) Scan over a non-empty vector.

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

O(n) Right-to-left prescan.

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

O(n) Right-to-left scan.

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

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

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

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

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

O(n) Convert a vector to a list.

O(n) Convert a list to a vector.

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

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.

O(n) Takes a list and returns a continuation providing a vector with a size parameter corresponding to the length of the list.

Essentially converts a list into a vector with the proper size parameter, determined at runtime.

See withSized

O(n) Convert different vector types.

O(n) Yield an immutable copy of the mutable vector.

O(n) Yield a mutable copy of the immutable vector.

O(n) Copy an immutable vector into a mutable one.

O(1) Unsafely convert a mutable vector to an immutable one withouy copying. The mutable vector may not be used after this operation.

O(n) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.

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

Takes a Vector and returns a continuation providing a Sized with a size parameter n that is determined at runtime based on the length of the input vector.

Essentially converts a Vector into a Vector with the correct size parameter n.

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

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