Vec n a is an element-lazy array of n values of type a.

This comes with a fusion framework, so many intermediate vectors are optimized away, and generally the only Vecs that correspond to actual arrays are those stored in data constructors, accessed multiple times, or appearing as inputs or outputs of non-inlinable functions. Additionally, some operations that rely on building up a vector incrementally (as opposed to computing each index independently of the others) cannot be fused; notably fromList, traverse, iterate, and vscanl; these will always construct real arrays for their results.

Most operations are access-strict unless otherwise noted, which means that forcing the result (usually a Vec, but possibly something else, like with foldMap) eagerly performs all indexing and drops references to any input arrays.

Create a known-length vector using a pure function.

Note if you already have a Vec of the desired length, you can use svSize to get the SInt parameter.

Element-strict form of mkVec: elements are forced when forcing the Vec.

Construct a vector by choosing an element of another vector for each index.

    backpermute n f v ! i === v ! f i

Convert a list to a vector, throwing an error if the list has the wrong length. Note: Because this walks xs to check its length, this cannot be used with the list fusion optimization rules.

Convert a list to a vector of the same length.

Create a singleton Vec.

Create a Vec from two elements.

Create a Vec from three elements.

Create a Vec from four elements.

Create a Vec from six elements.

Create a Vec from eight elements.

Return a vector with all elements of the type in ascending order.

Return the size of a vector as SInt.

Dynamically determine the (actual) size/length of the vector, as a standard term-level Int. If you'd rather obtain n at the type-level, and/or to prove that the returned value is indeed the n of the input, see svSize and withSize instead. If you'd rather obtain n statically, see vLength.

Extract the given index from a Vec.

This is subject to fusion if this is the only use of its input, so code like fmap f v ! i (which might arise due to inlining) will optimize to f (v ! i).

Eagerly look up the value at a given position, without forcing the value itself.

One of the problems with (!) is that it will hold onto the underlying array until the xs!i expression is forced; which is a source of space leaks. However, forcing the xs!i expression will force not only the array lookup but also the value itself; which can be undesirably strict, thereby ruining the compositionality benefits of laziness. The indexK function is designed to overcome those limitations. That is, forcing the expression indexK xs i k will force the array lookup and the r value; thereby leaving it up to k to decide whether or not to force the a before returning r. So, for example, if we force indexK xs i Just this will force the array lookup, and wrap the unforced element in the Just constructor.

Insert an element at the given position in a vector. O(n)

Remove an element at the given position in a vector. O(n)

Modify the given index of a Vec.

A zero-length Vec of any element type.

Concatenate two Vecs.

Split a vector into two shorter vectors at the given index.

Concatenate a nested Vec into one longer Vec.

Map each element of a Vec to a (same-sized) sub-Vec of the result.

Turn a vector into a vector of vector by chunking it.

Return a copy of the array with elements in the reverse order.

Rotate a vector right by i positions.

rot 1 [x, y, z] = [z, x, y]

Transpose a vector of vectors.

Generate a Vec by repeated application of a function.

toList (Vec.iterate @n f z) === take (valueOf @n) (Prelude.iterate f z)

A strict version of iterate.

Sort a Vec according to its Ord instance.

Sort a Vec with a given comparison function.

Sort a Vec with a given sort-key function.

Find the index of the first element, if any, that satisfies a predicate.

An element-strict version of fmap.

An element-strict version of imap.

Pair each element of a Vec with its index.

You can also use imap, but there should be no harm in using this because the fusion framework should optimize away the intermediate Vec.

One variant of the cross product of two vectors.

scanl, for Vec.

A truly lazy version of liftA2.

As opposed to the actual liftA2 it does not inspect the arguments which makes it possible it to use in code that has lazy knot-tying.