Data.Vector

Boxed vectors

Documentation

data Vector a

Instances

Vector Vector a

Eq a => Eq (Vector a)

Ord a => Ord (Vector a)

Show a => Show (Vector a)

data MVector s a

Mutable boxed vectors keyed on the monad they live in (IO or ST s).

Instances

MVector MVector a

Length information

length :: Vector a -> Int

null :: Vector a -> Bool

Construction

empty :: Vector a

Empty vector

singleton :: a -> Vector a

Vector with exaclty one element

cons :: a -> Vector a -> Vector a

Prepend an element

snoc :: Vector a -> a -> Vector a

Append an element

replicate :: Int -> a -> Vector a

Vector of the given length with the given value in each position

generate :: Int -> (Int -> a) -> Vector a

Generate a vector of the given length by applying the function to each index

(++) :: Vector a -> Vector a -> Vector a

Concatenate two vectors

copy :: Vector a -> Vector a

Create a copy of a vector. Useful when dealing with slices.

Accessing individual elements

(!) :: Vector a -> Int -> a

Indexing

head :: Vector a -> a

First element

last :: Vector a -> a

Last element

indexM :: Monad m => Vector a -> Int -> m a

Monadic indexing which can be strict in the vector while remaining lazy in the element

headM :: Monad m => Vector a -> m a

lastM :: Monad m => Vector a -> m a

unsafeIndex :: Vector a -> Int -> a

Unsafe indexing without bounds checking

unsafeHead :: Vector a -> a

Yield the first element of a vector without checking if the vector is empty

unsafeLast :: Vector a -> a

Yield the last element of a vector without checking if the vector is empty

unsafeIndexM :: Monad m => Vector a -> Int -> m a

Unsafe monadic indexing without bounds checks

unsafeHeadM :: Monad m => Vector a -> m a

unsafeLastM :: Monad m => Vector a -> m a

Subvectors

slice

Arguments

:: Int

starting index

-> Int

length

-> Vector a

-> Vector a

Yield a part of the vector without copying it. Safer version of basicUnsafeSlice.

init :: Vector a -> Vector a

Yield all but the last element without copying.

tail :: Vector a -> Vector a

All but the first element (without copying).

take :: Int -> Vector a -> Vector a

Yield the first n elements without copying.

drop :: Int -> Vector a -> Vector a

Yield all but the first n elements without copying.

unsafeSlice

Arguments

:: Int

starting index

-> Int

length

-> Vector a

-> Vector a

Unsafely yield a part of the vector without copying it and without performing bounds checks.

unsafeInit :: Vector a -> Vector a

unsafeTail :: Vector a -> Vector a

unsafeTake :: Int -> Vector a -> Vector a

unsafeDrop :: Int -> Vector a -> Vector a

Permutations

accum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

accumulate :: (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a

accumulate_ :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a

(//) :: Vector a -> [(Int, a)] -> Vector a

update :: Vector a -> Vector (Int, a) -> Vector a

update_ :: Vector a -> Vector Int -> Vector a -> Vector a

backpermute :: Vector a -> Vector Int -> Vector a

reverse :: Vector a -> Vector a

unsafeAccum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

unsafeAccumulate :: (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a

unsafeAccumulate_ :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a

unsafeUpd :: Vector a -> [(Int, a)] -> Vector a

unsafeUpdate :: Vector a -> Vector (Int, a) -> Vector a

unsafeUpdate_ :: Vector a -> Vector Int -> Vector a -> Vector a

unsafeBackpermute :: Vector a -> Vector Int -> Vector a

Mapping

map :: (a -> b) -> Vector a -> Vector b

Map a function over a vector

imap :: (Int -> a -> b) -> Vector a -> Vector b

Apply a function to every index/value pair

concatMap :: (a -> Vector b) -> Vector a -> Vector b

Zipping and unzipping

zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c

Zip two vectors with the given function.

zipWith3 :: (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d

Zip three vectors with the given function.

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

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g

izipWith :: (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c

Zip two vectors and their indices with the given function.

izipWith3 :: (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d

Zip three vectors and their indices with the given function.

izipWith4 :: (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e

izipWith5 :: (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f

izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g

zip :: Vector a -> Vector b -> Vector (a, b)

zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)

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

zip5 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)

zip6 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)

unzip :: Vector (a, b) -> (Vector a, Vector b)

unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)

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

unzip5 :: Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)

unzip6 :: Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)

Filtering

filter :: (a -> Bool) -> Vector a -> Vector a

Drop elements which do not satisfy the predicate

ifilter :: (Int -> a -> Bool) -> Vector a -> Vector a

Drop elements that do not satisfy the predicate (applied to values and their indices)

takeWhile :: (a -> Bool) -> Vector a -> Vector a

Yield the longest prefix of elements satisfying the predicate.

dropWhile :: (a -> Bool) -> Vector a -> Vector a

Drop the longest prefix of elements that satisfy the predicate.

partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The relative order of the elements is preserved at the cost of a (sometimes) reduced performance compared to unstablePartition.

unstablePartition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The order of the elements is not preserved.

span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector into the longest prefix of elements that satisfy the predicate and the rest.

break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest.

Searching

elem :: Eq a => a -> Vector a -> Bool

Check whether the vector contains an element

notElem :: Eq a => a -> Vector a -> Bool

Inverse of elem

find :: (a -> Bool) -> Vector a -> Maybe a

Yield Just the first element matching the predicate or Nothing if no such element exists.

findIndex :: (a -> Bool) -> Vector a -> Maybe Int

Yield Just the index of the first element matching the predicate or Nothing if no such element exists.

findIndices :: (a -> Bool) -> Vector a -> Vector Int

Yield the indices of elements satisfying the predicate

elemIndex :: Eq a => a -> Vector a -> Maybe Int

Yield Just the index of the first occurence of the given element or Nothing if the vector does not contain the element

elemIndices :: Eq a => a -> Vector a -> Vector Int

Yield the indices of all occurences of the given element

Folding

foldl :: (a -> b -> a) -> a -> Vector b -> a

Left fold

foldl1 :: (a -> a -> a) -> Vector a -> a

Lefgt fold on non-empty vectors

foldl' :: (a -> b -> a) -> a -> Vector b -> a

Left fold with strict accumulator

foldl1' :: (a -> a -> a) -> Vector a -> a

Left fold on non-empty vectors with strict accumulator

foldr :: (a -> b -> b) -> b -> Vector a -> b

Right fold

foldr1 :: (a -> a -> a) -> Vector a -> a

Right fold on non-empty vectors

foldr' :: (a -> b -> b) -> b -> Vector a -> b

Right fold with a strict accumulator

foldr1' :: (a -> a -> a) -> Vector a -> a

Right fold on non-empty vectors with strict accumulator

ifoldl :: (a -> Int -> b -> a) -> a -> Vector b -> a

Left fold (function applied to each element and its index)

ifoldl' :: (a -> Int -> b -> a) -> a -> Vector b -> a

Left fold with strict accumulator (function applied to each element and its index)

ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b

Right fold (function applied to each element and its index)

ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b

Right fold with strict accumulator (function applied to each element and its index)

Specialised folds

all :: (a -> Bool) -> Vector a -> Bool

any :: (a -> Bool) -> Vector a -> Bool

and :: Vector Bool -> Bool

or :: Vector Bool -> Bool

sum :: Num a => Vector a -> a

product :: Num a => Vector a -> a

maximum :: Ord a => Vector a -> a

maximumBy :: (a -> a -> Ordering) -> Vector a -> a

minimum :: Ord a => Vector a -> a

minimumBy :: (a -> a -> Ordering) -> Vector a -> a

minIndex :: Ord a => Vector a -> Int

minIndexBy :: (a -> a -> Ordering) -> Vector a -> Int

maxIndex :: Ord a => Vector a -> Int

maxIndexBy :: (a -> a -> Ordering) -> Vector a -> Int

Unfolding

unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a

Scans

prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a

Prefix scan

prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a

Prefix scan with strict accumulator

postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a

Suffix scan

postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a

Suffix scan with strict accumulator

scanl :: (a -> b -> a) -> a -> Vector b -> Vector a

Haskell-style scan

scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a

Haskell-style scan with strict accumulator

scanl1 :: (a -> a -> a) -> Vector a -> Vector a

Scan over a non-empty Vector

scanl1' :: (a -> a -> a) -> Vector a -> Vector a

Scan over a non-empty Vector with a strict accumulator

prescanr :: (a -> b -> b) -> b -> Vector a -> Vector b

Prefix right-to-left scan

prescanr' :: (a -> b -> b) -> b -> Vector a -> Vector b

Prefix right-to-left scan with strict accumulator

postscanr :: (a -> b -> b) -> b -> Vector a -> Vector b

Suffix right-to-left scan

postscanr' :: (a -> b -> b) -> b -> Vector a -> Vector b

Suffix right-to-left scan with strict accumulator

scanr :: (a -> b -> b) -> b -> Vector a -> Vector b

Haskell-style right-to-left scan

scanr' :: (a -> b -> b) -> b -> Vector a -> Vector b

Haskell-style right-to-left scan with strict accumulator

scanr1 :: (a -> a -> a) -> Vector a -> Vector a

Right-to-left scan over a non-empty vector

scanr1' :: (a -> a -> a) -> Vector a -> Vector a

Right-to-left scan over a non-empty vector with a strict accumulator

Enumeration

enumFromN :: Num a => a -> Int -> Vector a

Yield a vector of the given length containing the values x, x+1 etc. This operation is usually more efficient than enumFromTo.

enumFromStepN :: Num a => a -> a -> Int -> Vector a

Yield a vector of the given length containing the values x, x+y, x+y+y etc. This operations is usually more efficient than enumFromThenTo.

enumFromTo :: Enum a => a -> a -> Vector a

Enumerate values from x to y.

WARNING: This operation can be very inefficient. If at all possible, use enumFromN instead.

enumFromThenTo :: Enum a => a -> a -> a -> Vector a

Enumerate values from x to y with a specific step z.

WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

Conversion to/from lists

toList :: Vector a -> [a]

Convert a vector to a list

fromList :: [a] -> Vector a

Convert a list to a vector