Data.Vector.IVector

Generic interface to pure vectors

Immutable vectors

class IVector v a where

Class of immutable vectors.

Methods

vnew :: (forall mv m. MVector mv m a => m (mv a)) -> v a

Construct a pure vector from a monadic initialiser (not fusible!)

vlength :: v a -> Int

Length of the vector (not fusible!)

unsafeSlice :: v a -> Int -> Int -> v a

Yield a part of the vector without copying it. No range checks!

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

Instances

IVector Vector a

Unbox a => IVector Vector a

Length information

length :: IVector v a => v a -> Int

null :: IVector v a => v a -> Bool

Construction

empty :: IVector v a => v a

Empty vector

singleton :: IVector v a => a -> v a

Vector with exaclty one element

cons :: IVector v a => a -> v a -> v a

Prepend an element

snoc :: IVector v a => v a -> a -> v a

Append an element

replicate :: IVector v a => Int -> a -> v a

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

(++) :: IVector v a => v a -> v a -> v a

Concatenate two vectors

copy :: IVector v a => v a -> v a

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

Accessing individual elements

(!) :: IVector v a => v a -> Int -> a

Indexing

head :: IVector v a => v a -> a

First element

last :: IVector v a => v a -> a

Last element

indexM :: (IVector v a, Monad m) => v a -> Int -> m a

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

headM :: (IVector v a, Monad m) => v a -> m a

lastM :: (IVector v a, Monad m) => v a -> m a

Subvectors

slice

Arguments

:: IVector v a

=> v a

-> Int

starting index

-> Int

length

-> v a

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

init :: IVector v a => v a -> v a

Yield all but the last element without copying.

tail :: IVector v a => v a -> v a

All but the first element (without copying).

take :: IVector v a => Int -> v a -> v a

Yield the first n elements without copying.

drop :: IVector v a => Int -> v a -> v a

Yield all but the first n elements without copying.

Permutations

accum :: IVector v a => (a -> b -> a) -> v a -> [(Int, b)] -> v a

(//) :: IVector v a => v a -> [(Int, a)] -> v a

update :: (IVector v a, IVector v (Int, a)) => v a -> v (Int, a) -> v a

backpermute :: (IVector v a, IVector v Int) => v a -> v Int -> v a

reverse :: IVector v a => v a -> v a

Mapping

map :: (IVector v a, IVector v b) => (a -> b) -> v a -> v b

Map a function over a vector

concatMap :: (IVector v a, IVector v b) => (a -> v b) -> v a -> v b

Zipping and unzipping

zipWith :: (IVector v a, IVector v b, IVector v c) => (a -> b -> c) -> v a -> v b -> v c

Zip two vectors with the given function.

zipWith3 :: (IVector v a, IVector v b, IVector v c, IVector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d

Zip three vectors with the given function.

zip :: (IVector v a, IVector v b, IVector v (a, b)) => v a -> v b -> v (a, b)

zip3 :: (IVector v a, IVector v b, IVector v c, IVector v (a, b, c)) => v a -> v b -> v c -> v (a, b, c)

unzip :: (IVector v a, IVector v b, IVector v (a, b)) => v (a, b) -> (v a, v b)

unzip3 :: (IVector v a, IVector v b, IVector v c, IVector v (a, b, c)) => v (a, b, c) -> (v a, v b, v c)

Comparisons

eq :: (IVector v a, Eq a) => v a -> v a -> Bool

cmp :: (IVector v a, Ord a) => v a -> v a -> Ordering

Filtering

filter :: IVector v a => (a -> Bool) -> v a -> v a

Drop elements which do not satisfy the predicate

takeWhile :: IVector v a => (a -> Bool) -> v a -> v a

Yield the longest prefix of elements satisfying the predicate.

dropWhile :: IVector v a => (a -> Bool) -> v a -> v a

Drop the longest prefix of elements that satisfy the predicate.

Searching

elem :: (IVector v a, Eq a) => a -> v a -> Bool

Check whether the vector contains an element

notElem :: (IVector v a, Eq a) => a -> v a -> Bool

Inverse of elem

find :: IVector v a => (a -> Bool) -> v a -> Maybe a

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

findIndex :: IVector v a => (a -> Bool) -> v a -> Maybe Int

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

Folding

foldl :: IVector v b => (a -> b -> a) -> a -> v b -> a

Left fold

foldl1 :: IVector v a => (a -> a -> a) -> v a -> a

Lefgt fold on non-empty vectors

foldl' :: IVector v b => (a -> b -> a) -> a -> v b -> a

Left fold with strict accumulator

foldl1' :: IVector v a => (a -> a -> a) -> v a -> a

Left fold on non-empty vectors with strict accumulator

foldr :: IVector v a => (a -> b -> b) -> b -> v a -> b

Right fold

foldr1 :: IVector v a => (a -> a -> a) -> v a -> a

Right fold on non-empty vectors

Specialised folds

and :: IVector v Bool => v Bool -> Bool

or :: IVector v Bool => v Bool -> Bool

sum :: (IVector v a, Num a) => v a -> a

product :: (IVector v a, Num a) => v a -> a

maximum :: (IVector v a, Ord a) => v a -> a

minimum :: (IVector v a, Ord a) => v a -> a

Unfolding

unfoldr :: IVector v a => (b -> Maybe (a, b)) -> b -> v a

Scans

prescanl :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a

Prefix scan

prescanl' :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a

Prefix scan with strict accumulator

Enumeration

enumFromTo :: (IVector v a, Enum a) => a -> a -> v a

enumFromThenTo :: (IVector v a, Enum a) => a -> a -> a -> v a

Conversion to/from lists

toList :: IVector v a => v a -> [a]

Convert a vector to a list

fromList :: IVector v a => [a] -> v a

Convert a list to a vector

Conversion to/from Streams

stream :: IVector v a => v a -> Stream a

Convert a vector to a Stream

unstream :: IVector v a => Stream a -> v a

Create a vector from a Stream

MVector-based initialisation

new :: IVector v a => New a -> v a

Construct a pure vector from a monadic initialiser

Unsafe functions

Utility functions