Size of vector expressed as type-level natural.

Type level zero

Successor of n

Type class for vectors with fixed length. Instance should provide two functions: one to create vector and another for vector deconstruction. They must obey following law:

 inspect v construct = v

Vector parametrized by length. In ideal world it should be:

 forall n. (Arity n, Vector (v n) a, Dim (v n) ~ n) => VectorN v a

Alas polymorphic constraints aren't allowed in haskell.

Type class for handling n-ary functions.

Newtype wrapper which is used to make Fn injective. It's also a reader monad.

Length of vector. Function doesn't evaluate its argument.

Vector represented as continuation. Alternative wording: it's Church encoded N-element vector.

Create empty vector.

Convert continuation to the vector.

Cons value to continuation based vector.

Type class for variadic vector constructors.

Variadic vector constructor. Resulting vector should be converted from ContVec using vector function. For example:

>>> vector $ mkN 'a' 'b' 'c' :: (Char,Char,Char)
('a','b','c')

Replicate value n times.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2)
>>> replicate 1 :: Vec2 Int
fromList [1,1]

>>> replicate 2 :: (Double,Double,Double)
(2.0,2.0,2.0)

>>> import Data.Vector.Fixed.Boxed (Vec4)
>>> replicate "foo" :: Vec4 String
fromList ["foo","foo","foo","foo"]

Execute monadic action for every element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2,Vec3)
>>> replicateM (Just 3) :: Maybe (Vec3 Int)
Just fromList [3,3,3]
>>> replicateM (putStrLn "Hi!") :: IO (Vec2 ())
Hi!
Hi!
fromList [(),()]

Generate vector from function which maps element's index to its value.

Examples:

>>> import Data.Vector.Fixed.Unboxed (Vec4)
>>> generate (^2) :: Vec4 Int
fromList [0,1,4,9]

Generate vector from monadic function which maps element's index to its value.

Unfold vector.

Unit vector along Nth axis. If index is larger than vector dimensions returns zero vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> basis 0 :: Vec3 Int
fromList [1,0,0]
>>> basis 1 :: Vec3 Int
fromList [0,1,0]
>>> basis 3 :: Vec3 Int
fromList [0,0,0]

First element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = mk3 1 2 3 :: Vec3 Int
>>> head x
1

Tail of vector.

Examples:

>>> import Data.Complex
>>> tail (1,2,3) :: Complex Double
2.0 :+ 3.0

Cons element to the vector

Append element to the vector

Reverse order of elements in the vector

Type class for indexing of vector when index value is known at compile time.

Retrieve vector's element at index. Generic implementation is O(n) but more efficient one is used when possible.

Get element from vector at statically known index

Twan van Laarhoven's lens for element of vector

Twan van Laarhoven's lens for element of vector with statically known index.

Test two vectors for equality.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2)
>>> let v0 = basis 0 :: Vec2 Int
>>> let v1 = basis 1 :: Vec2 Int
>>> v0 `eq` v0
True
>>> v0 `eq` v1
False

Lexicographic ordering of two vectors.

Map over vector

Monadic map over vector.

Apply monadic action to each element of vector and ignore result.

Apply function to every element of the vector and its index.

Apply monadic function to every element of the vector and its index.

Apply monadic function to every element of the vector and its index and discard result.

Evaluate every action in the vector from left to right.

Evaluate every action in the vector from left to right and ignore result

Analog of sequenceA from Traversable.

Analog of traverse from Traversable.

Left fold over vector

Right fold over vector

Left fold over vector

Combine the elements of a structure using a monoid. Similar to fold

Map each element of the structure to a monoid, and combine the results. Similar to foldMap

Left fold over vector. Function is applied to each element and its index.

Left fold over vector

Monadic fold over vector.

Left monadic fold over vector. Function is applied to each element and its index.

Sum all elements in the vector.

Maximal element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = mk3 1 2 3 :: Vec3 Int
>>> maximum x
3

Minimal element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = mk3 1 2 3 :: Vec3 Int
>>> minimum x
1

Conjunction of all elements of a vector.

Disjunction of all elements of a vector.

Determines whether all elements of vector satisfy predicate.

Determines whether any of element of vector satisfy predicate.

Zip two vector together using function.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let b0 = basis 0 :: Vec3 Int
>>> let b1 = basis 1 :: Vec3 Int
>>> let b2 = basis 2 :: Vec3 Int
>>> let vplus x y = zipWith (+) x y
>>> vplus b0 b1
fromList [1,1,0]
>>> vplus b0 b2
fromList [1,0,1]
>>> vplus b1 b2
fromList [0,1,1]

Zip two vector together using monadic function.

Zip two vector together using function which takes element index as well.

Zip two vector together using monadic function which takes element index as well..

Convert between different vector types

Convert vector to the list

Create vector form list. Will throw error if list is shorter than resulting vector.

Create vector form list. Will throw error if list has different length from resulting vector.

Create vector form list. Will return Nothing if list has different length from resulting vector.

Create vector from Foldable data type. Will return Nothing if data type different number of elements that resulting vector.

Vector based on the lists. Not very useful by itself but is necessary for implementation.

Single-element tuple.

Empty tuple.