The data type Vector is modeled similar to a list. It has two data type constructors. NullV constructs the empty vector, while :> constructsa vector by adding an value to an existing vector..

Vector is an instance of the classes Read and Show. This means that the vector

1:>2:>3:>NullV

is shown as

<1,2,3>

The operator <+> concatenates two vectors.

The operator '(<:)' appends an element at the end of a vector.

The function nullV returns True if a vector is empty.

The function lengthV returns the number of elements in a value.

The function vector converts a list into a vector.

The function fromVector converts a vector into a list.

The function unitV creates a vector with one element.

The function iterateV generates a vector with a given number of elements starting from an initial element using a supplied function for the generation of elements.

>>> iterateV 5 (+1) 1
<1,2,3,4,5>

The function generateV behaves in the same way as iterateV, but starts with the application of the supplied function to the supplied value.

>>> generateV 5 (+1) 1
<2,3,4,5,6>

The function copyV generates a vector with a given number of copies of the same element.

>>> copyV 7 5
<5,5,5,5,5,5,5>

The higher-order function mapV applies a function on all elements of a vector.

The higher-order function zipWithV applies a function pairwise on two vectors.

The higher-order function zipWithV3 applies a function 3-tuple-wise on three vectors.

Reduces a vector of elements to a single element based on a binary function.

>>> reduceV (+) $ vector [1,2,3,4,5]
15

Pipes an element through a vector of functions.

>>> vector [(*2), (+1), (/3)] `pipeV` 3      -- is the same as ((*2) . (+1) . (/3)) 3
4.0

The higher-order functions foldlV folds a function from the right to the left over a vector using an initial value.

>>> foldlV (-) 8 $ vector [4,2,1]   -- is the same as (((8 - 4) - 2) - 1)
1

The higher-order functions foldrV folds a function from the left to the right over a vector using an initial value.

>>> foldrV (-) 8 $ vector [4,2,1]   -- is the same as (4 - (2 - (1 - 8)))
-5

Performs the parallel prefix operation on a vector.

>>> scanlV (+) 0 $ vector [1,1,1,1,1,1]
<1,2,3,4,5,6>

Performs the parallel suffix operation on a vector.

>>> scanrV (+) 0 $ vector [1,1,1,1,1,1]
<6,5,4,3,2,1>

The function atV returns the n-th element in a vector, starting from zero.

>>> vector [1,2,3,4,5] `atV` 3
4

The functions headV returns the first element of a vector.

The functions tailV returns all, but the first element of a vector.

The function lastV returns the last element of a vector.

The function initV returns all but the last elements of a vector.

Returns a vector containing all the possible prefixes of an input vector.

>>> let v = vector [1,2,3,4,5,6]
>>> headsV v
<<1>,<1,2>,<1,2,3>,<1,2,3,4>,<1,2,3,4,5>,<1,2,3,4,5,6>,<1,2,3,4,5,6>>

Returns a vector containing all the possible suffixes of an input vector.

>>> let v = vector [1,2,3,4,5,6]
>>> tailsV v
<<1,2,3,4,5,6>,<2,3,4,5,6>,<3,4,5,6>,<4,5,6>,<5,6>,<6>,<>>

The function takeV returns the first n elements of a vector.

>>> takeV 2 $ vector [1,2,3,4,5]
<1,2>

The function dropV drops the first n elements of a vector.

>>> dropV 2 $ vector [1,2,3,4,5]
<3,4,5>

The function selectV selects elements in the vector based on a regular stride.

The function groupV groups a vector into a vector of vectors of size n.

>>> groupV 3 $ vector [1,2,3,4,5,6,7,8]
<<1,2,3>,<4,5,6>>

The higher-function filterV takes a predicate function and a vector and creates a new vector with the elements for which the predicate is true.

>>> filterV odd $ vector [1,2,3,4,5,6,7,8]
<1,3,5,7>

(*) however, the length is unknown, because it is dependent on the data contained inside the vector. Try avoiding filterV in designs where the size of the data is crucial.

Returns a stencil of n neighboring elements for each possible element in a vector.

>>> stencilV 3 $ vector [1..5]
<<1,2,3>,<2,3,4>,<3,4,5>>

The function replaceV replaces an element in a vector.

>>> replaceV (vector [1..5]) 2 100
<1,2,100,4,5>

The function zipV zips two vectors into a vector of tuples.

The function unzipV unzips a vector of tuples into two vectors.

The function concatV transforms a vector of vectors to a single vector.

The function reverseV reverses the order of elements in a vector.

The function shiftlV shifts a value from the left into a vector.

>>> vector [1..5] `shiftlV` 100
<100,1,2,3,4>

The function shiftrV shifts a value from the right into a vector.

>>> vector [1..5] `shiftrV` 100
<2,3,4,5,100>

The function rotrV rotates a vector to the right. Note that this fuction does not change the size of a vector.

>>> rotrV $ vector [1..5]
<2,3,4,5,1>

The function rotlV rotates a vector to the left. Note that this fuctions does not change the size of a vector.

>>> rotlV $ vector [1..5]
<5,1,2,3,4>

The function rotateV rotates a vector based on an index offset.

• (> 0) : rotates the vector left with the corresponding number of positions.
• (= 0) : does not modify the vector.
• (< 0) : rotates the vector right with the corresponding number of positions.