fromList : List a -> Vector aBuild a dense vector from a list.
importPour l'utiliser :
import Data.VectorVector — dense, immutable, O(1) indexed sequences
Synopsis
fromList : List a -> Vector atoList : Vector a -> List alength : Vector a -> Natlookup : Vector a -> Nat -> Maybe a(!) : Vector a -> Nat -> Maybe aindex : Vector a -> Nat -> aset : Vector a -> Nat -> a -> Vector awithMutable : Vector a -> (forall s. Array s a -> b with Mut s) -> breverse : Vector a -> Vector amap : (a -> b) -> Vector a -> Vector bfilter : (a -> Bool) -> Vector a -> Vector afoldr : (a -> b -> b) -> b -> Vector a -> bfoldl : (b -> a -> b) -> b -> Vector a -> bfoldMap : Monoid m => (a -> m) -> Vector a -> mzipWith : (a -> b -> c) -> Vector a -> Vector b -> Vector celem : Eq a => a -> Vector a -> Booltake : Nat -> Vector a -> Vector adrop : Nat -> Vector a -> Vector aslice : Nat -> Nat -> Vector a -> Vector aappend : Vector a -> Vector a -> Vector aconcat : List (Vector a) -> Vector a
toList : Vector a -> List aThe elements of a vector, in order, as a list.
length : Vector a -> NatThe number of elements. Nat, the same count type as List.length.
lookup : Vector a -> Nat -> Maybe a(!) : Vector a -> Nat -> Maybe aSafe subscript vec[i]? — Nothing if i is out of range.
index : Vector a -> Nat -> aDirect subscript vec[i] — panics if i is out of range.
set : Vector a -> Nat -> a -> Vector aset vec i v — a NEW vector with position i set to v (unchanged if i is out of range). The notation vec { [i] := v } is equivalent (kept — decision Q3 2026-07-02 — but set is the form to teach and document).
withMutable : Vector a -> (forall s. Array s a -> b with Mut s) -> bThe create-mutate-freeze boundary: run f on a fresh MUTABLE copy of vec, discharging Mut so the result type is pure (residual effects like IO pass through). The classic pattern returns a value built from the mutated array (freeze marr, or its toList).
Vector.withMutable (Vector.fromList xs) sortInPlaceThenFreeze.
Combinators
reverse : Vector a -> Vector aReverse the order of the elements.
map : (a -> b) -> Vector a -> Vector bApply f to every element, preserving order and length.
filter : (a -> Bool) -> Vector a -> Vector aKeep the elements satisfying the predicate, in order.
foldr : (a -> b -> b) -> b -> Vector a -> bRight fold over the elements.
foldl : (b -> a -> b) -> b -> Vector a -> bLeft fold over the elements.
foldMap : Monoid m => (a -> m) -> Vector a -> mMap each element to a monoid and combine, in order (mempty if empty).
zipWith : (a -> b -> c) -> Vector a -> Vector b -> Vector cCombine two vectors element-wise with f, stopping at the shorter.
elem : Eq a => a -> Vector a -> BoolIs the element present? (Eq on the element type.) Stops at the first element equal to it.
take : Nat -> Vector a -> Vector aThe first n elements (all of them if n exceeds the length).
drop : Nat -> Vector a -> Vector aAll but the first n elements (empty if n exceeds the length).
slice : Nat -> Nat -> Vector a -> Vector aThe len elements starting at index start (clamped to the bounds).
append : Vector a -> Vector a -> Vector aAppend two vectors.
concat : List (Vector a) -> Vector aFlatten a list of vectors into one, in order.