Vector

empty :: Vector a { } #

O(1). Empty vector.

singleton :: a -> Vector a { } #

O(1). Single element vector.

replicate :: Int -> a -> Vector a { } #

O(n). Replicate element n times.

generate :: Int -> (Int -> a) -> Vector a { } #

O(n). Generate using index function.

iterateN :: Int -> (a -> a) -> a -> Vector a { } #

O(n). Iterate function n times.

replicateM :: (Monad m) => Int -> (m a) -> m (Vector a) { } #

O(n). Monadic replicate.

generateM :: (Monad m) => Int -> (Int -> m a) -> m (Vector a) { } #

O(n). Monadic generate.

fromList :: [a] -> Vector a { } #

O(n). Convert list to vector.

fromListN :: Int -> [a] -> Vector a { } #

O(n). Convert list with known length.

length :: (Vector a) -> Int { } #

O(1). Length of vector.

null :: (Vector a) -> Bool { } #

O(1). Test for empty.

head :: (Vector a) -> a { } #

last :: (Vector a) -> a { } #

O(1). Last element (unsafe).

unsafeIndex :: (Vector a) -> Int -> a { } #

O(1). Unsafe index.

unsafeHead :: (Vector a) -> a { } #

O(1). Unsafe head.

unsafeLast :: (Vector a) -> a { } #

O(1). Unsafe last.

slice :: Int -> Int -> (Vector a) -> Vector a { } #

O(1). Slice from offset with length (view).

init :: (Vector a) -> Vector a { } #

O(1). All but last element (view).

tail :: (Vector a) -> Vector a { } #

O(1). All but first element (view).

take :: Int -> (Vector a) -> Vector a { } #

O(1). First n elements (view).

drop :: Int -> (Vector a) -> Vector a { } #

O(1). Drop first n elements (view).

splitAt :: Int -> (Vector a) -> (Vector a, Vector a) { } #

O(1). Split at position.

cons :: a -> (Vector a) -> Vector a { } #

O(n). Prepend element.

snoc :: (Vector a) -> a -> Vector a { } #

O(n). Append element.

++ :: (Vector a) -> (Vector a) -> Vector a { } #

O(n). Append vectors.

concat :: [Vector a] -> Vector a { } #

O(n). Concatenate vectors.

force :: (Vector a) -> Vector a { } #

O(n). Force evaluation and compaction.

map :: (a -> b) -> (Vector a) -> Vector b { } #

O(n). Map function over elements.

imap :: (Int -> a -> b) -> (Vector a) -> Vector b { } #

O(n). Map with index.

concatMap :: (a -> Vector b) -> (Vector a) -> Vector b { } #

O(n). Map and concatenate.

mapM :: (Monad m) => (a -> m b) -> (Vector a) -> m (Vector b) { } #

O(n). Monadic map.

mapM_ :: (Monad m) => (a -> m b) -> (Vector a) -> m () { } #

O(n). Monadic map, discarding results.

forM :: (Monad m) => (Vector a) -> (a -> m b) -> m (Vector b) { } #

O(n). Flipped monadic map.

forM_ :: (Monad m) => (Vector a) -> (a -> m b) -> m () { } #

O(n). Flipped monadic map, discarding results.

zipWith :: (a -> b -> c) -> (Vector a) -> (Vector b) -> Vector c { } #

O(n). Zip with function.

zipWith3 :: (a -> b -> c -> d) -> (Vector a) -> (Vector b) -> (Vector c) -> Vector d { } #

O(n). Zip three vectors.

zipWith4 :: (a -> b -> c -> d -> e) -> (Vector a) -> (Vector b) -> (Vector c) -> (Vector d) -> Vector e { } #

O(n). Zip four vectors.

zipWithM :: (Monad m) => (a -> b -> m c) -> (Vector a) -> (Vector b) -> m (Vector c) { } #

O(n). Monadic zipWith.

zipWithM_ :: (Monad m) => (a -> b -> m c) -> (Vector a) -> (Vector b) -> m () { } #

O(n). Monadic zipWith, discarding results.

zip :: (Vector a) -> (Vector b) -> Vector (a, b) { } #

O(n). Zip to pairs.

zip3 :: (Vector a) -> (Vector b) -> (Vector c) -> Vector (a, b, c) { } #

O(n). Zip three vectors.

zip4 :: (Vector a) -> (Vector b) -> (Vector c) -> (Vector d) -> Vector (a, b, c, d) { } #

O(n). Zip four vectors.

unzip :: (Vector (a, b)) -> (Vector a, Vector b) { } #

O(n). Unzip pairs.

unzip3 :: (Vector (a, b, c)) -> (Vector a, Vector b, Vector c) { } #

O(n). Unzip triples.

unzip4 :: (Vector (a, b, c, d)) -> (Vector a, Vector b, Vector c, Vector d) { } #

O(n). Unzip quadruples.

filter :: (a -> Bool) -> (Vector a) -> Vector a { } #

O(n). Filter by predicate.

ifilter :: (Int -> a -> Bool) -> (Vector a) -> Vector a { } #

O(n). Filter with index.

filterM :: (Monad m) => (a -> m Bool) -> (Vector a) -> m (Vector a) { } #

O(n). Monadic filter.

takeWhile :: (a -> Bool) -> (Vector a) -> Vector a { } #

O(n). Take while predicate holds.

dropWhile :: (a -> Bool) -> (Vector a) -> Vector a { } #

O(n). Drop while predicate holds.

partition :: (a -> Bool) -> (Vector a) -> (Vector a, Vector a) { } #

O(n). Partition by predicate.

span :: (a -> Bool) -> (Vector a) -> (Vector a, Vector a) { } #

O(n). Span while predicate holds.

break :: (a -> Bool) -> (Vector a) -> (Vector a, Vector a) { } #

O(n). Break at first failure.

elem :: (Eq a) => a -> (Vector a) -> Bool { } #

O(n). Test membership.

notElem :: (Eq a) => a -> (Vector a) -> Bool { } #

O(n). Test non-membership.

find :: (a -> Bool) -> (Vector a) -> Maybe a { } #

O(n). Find first match.

findIndex :: (a -> Bool) -> (Vector a) -> Maybe Int { } #

O(n). Find index of first match.

findIndices :: (a -> Bool) -> (Vector a) -> Vector Int { } #

O(n). Find all matching indices.

elemIndex :: (Eq a) => a -> (Vector a) -> Maybe Int { } #

O(n). Find index of element.

elemIndices :: (Eq a) => a -> (Vector a) -> Vector Int { } #

O(n). Find all indices of element.

foldl :: (b -> a -> b) -> b -> (Vector a) -> b { } #

O(n). Left fold.

foldl' :: (b -> a -> b) -> b -> (Vector a) -> b { } #

O(n). Strict left fold.

foldl1 :: (a -> a -> a) -> (Vector a) -> a { } #

O(n). Left fold without starting value.

foldl1' :: (a -> a -> a) -> (Vector a) -> a { } #

O(n). Strict left fold without starting value.

foldr :: (a -> b -> b) -> b -> (Vector a) -> b { } #

O(n). Right fold.

foldr' :: (a -> b -> b) -> b -> (Vector a) -> b { } #

O(n). Strict right fold.

foldr1 :: (a -> a -> a) -> (Vector a) -> a { } #

O(n). Right fold without starting value.

foldr1' :: (a -> a -> a) -> (Vector a) -> a { } #

O(n). Strict right fold without starting value.

ifoldl :: (b -> Int -> a -> b) -> b -> (Vector a) -> b { } #

O(n). Indexed left fold.

ifoldl' :: (b -> Int -> a -> b) -> b -> (Vector a) -> b { } #

O(n). Strict indexed left fold.

ifoldr :: (Int -> a -> b -> b) -> b -> (Vector a) -> b { } #

O(n). Indexed right fold.

ifoldr' :: (Int -> a -> b -> b) -> b -> (Vector a) -> b { } #

O(n). Strict indexed right fold.

all :: (a -> Bool) -> (Vector a) -> Bool { } #

O(n). All elements satisfy predicate.

any :: (a -> Bool) -> (Vector a) -> Bool { } #

O(n). Any element satisfies predicate.

sum :: (Num a) => (Vector a) -> a { } #

O(n). Sum of elements.

product :: (Num a) => (Vector a) -> a { } #

O(n). Product of elements.

maximum :: (Ord a) => (Vector a) -> a { } #

O(n). Maximum element.

minimum :: (Ord a) => (Vector a) -> a { } #

O(n). Minimum element.

maximumBy :: (a -> a -> Ordering) -> (Vector a) -> a { } #

O(n). Maximum by comparison function.

minimumBy :: (a -> a -> Ordering) -> (Vector a) -> a { } #

O(n). Minimum by comparison function.

maxIndex :: (Ord a) => (Vector a) -> Int { } #

O(n). Index of maximum element.

minIndex :: (Ord a) => (Vector a) -> Int { } #

O(n). Index of minimum element.

prescanl :: (a -> b -> a) -> a -> (Vector b) -> Vector a { } #

O(n). Prefix scan (exclusive).

prescanl' :: (a -> b -> a) -> a -> (Vector b) -> Vector a { } #

O(n). Strict prefix scan (exclusive).

postscanl :: (a -> b -> a) -> a -> (Vector b) -> Vector a { } #

O(n). Suffix scan (exclusive).

postscanl' :: (a -> b -> a) -> a -> (Vector b) -> Vector a { } #

O(n). Strict suffix scan (exclusive).

scanl :: (a -> b -> a) -> a -> (Vector b) -> Vector a { } #

O(n). Left scan (inclusive).

scanl' :: (a -> b -> a) -> a -> (Vector b) -> Vector a { } #

O(n). Strict left scan (inclusive).

scanl1 :: (a -> a -> a) -> (Vector a) -> Vector a { } #

O(n). Left scan without starting value.

scanl1' :: (a -> a -> a) -> (Vector a) -> Vector a { } #

O(n). Strict left scan without starting value.

prescanr :: (a -> b -> b) -> b -> (Vector a) -> Vector b { } #

O(n). Right prefix scan.

prescanr' :: (a -> b -> b) -> b -> (Vector a) -> Vector b { } #

O(n). Strict right prefix scan.

postscanr :: (a -> b -> b) -> b -> (Vector a) -> Vector b { } #

O(n). Right suffix scan.

postscanr' :: (a -> b -> b) -> b -> (Vector a) -> Vector b { } #

O(n). Strict right suffix scan.

scanr :: (a -> b -> b) -> b -> (Vector a) -> Vector b { } #

O(n). Right scan (inclusive).

scanr' :: (a -> b -> b) -> b -> (Vector a) -> Vector b { } #

O(n). Strict right scan (inclusive).

scanr1 :: (a -> a -> a) -> (Vector a) -> Vector a { } #

O(n). Right scan without starting value.

scanr1' :: (a -> a -> a) -> (Vector a) -> Vector a { } #

O(n). Strict right scan without starting value.

toList :: (Vector a) -> [a] { } #

O(n). Convert to list.

convert :: ((Vector a) -> Vector b) { } #

O(n). Convert between vector types.

new :: Int -> IO (MVector RealWorld a) { } #

O(n). Allocate new mutable vector.

newWith :: Int -> a -> IO (MVector RealWorld a) { } #

O(n). Allocate with initial value.

read :: (MVector s a) -> Int -> ST s a { } #

O(1). Read element.

write :: (MVector s a) -> Int -> a -> ST s () { } #

O(1). Write element.

modify :: (MVector s a) -> (a -> a) -> Int -> ST s () { } #

O(1). Modify element.

swap :: (MVector s a) -> Int -> Int -> ST s () { } #

O(1). Swap two elements.

grow :: (MVector s a) -> Int -> ST s (MVector s a) { } #

O(n). Grow vector capacity.

freeze :: (MVector s a) -> ST s (Vector a) { } #

O(n). Freeze mutable to immutable.

thaw :: (Vector a) -> ST s (MVector s a) { } #

O(n). Thaw immutable to mutable.

copy :: (MVector s a) -> (MVector s a) -> ST s () { } #

O(n). Copy between mutable vectors.

unsafeFreeze :: (MVector s a) -> ST s (Vector a) { } #

O(1). Unsafe freeze (no copy).

unsafeThaw :: (Vector a) -> ST s (MVector s a) { } #

O(1). Unsafe thaw (no copy).

sort :: (Ord a) => (Vector a) -> Vector a { } #

O(n log n). Sort elements.

sortBy :: (a -> a -> Ordering) -> (Vector a) -> Vector a { } #

O(n log n). Sort by comparison function.

sortOn :: (Ord b) => (a -> b) -> (Vector a) -> Vector a { } #

O(n log n). Sort by key extraction.

Methods