vector-0.4.1: Efficient Arrays Source code Contents Index

Data.Vector Portability non-portable Stability experimental Maintainer Roman Leshchinskiy <rl@cse.unsw.edu.au>

Contents Length information Construction Accessing individual elements Subvectors Permutations Mapping Zipping and unzipping Filtering Searching Folding Specialised folds Unfolding Scans Enumeration Conversion to/from lists

Description

Boxed vectors

Synopsis

data Vector a data MVector m a length :: Vector a -> Int null :: Vector a -> Bool empty :: Vector a singleton :: a -> Vector a cons :: a -> Vector a -> Vector a snoc :: Vector a -> a -> Vector a replicate :: Int -> a -> Vector a (++) :: Vector a -> Vector a -> Vector a copy :: Vector a -> Vector a (!) :: Vector a -> Int -> a head :: Vector a -> a last :: Vector a -> a indexM :: Monad m => Vector a -> Int -> m a headM :: Monad m => Vector a -> m a lastM :: Monad m => Vector a -> m a slice :: Vector a -> Int -> Int -> Vector a init :: Vector a -> Vector a tail :: Vector a -> Vector a take :: Int -> Vector a -> Vector a drop :: Int -> Vector a -> Vector a accum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a (//) :: Vector a -> [(Int, a)] -> Vector a update :: Vector a -> Vector (Int, a) -> Vector a backpermute :: Vector a -> Vector Int -> Vector a reverse :: Vector a -> Vector a map :: (a -> b) -> Vector a -> Vector b concatMap :: (a -> Vector b) -> Vector a -> Vector b zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c zipWith3 :: (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d zip :: Vector a -> Vector b -> Vector (a, b) zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c) unzip :: Vector (a, b) -> (Vector a, Vector b) unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c) filter :: (a -> Bool) -> Vector a -> Vector a takeWhile :: (a -> Bool) -> Vector a -> Vector a dropWhile :: (a -> Bool) -> Vector a -> Vector a elem :: Eq a => a -> Vector a -> Bool notElem :: Eq a => a -> Vector a -> Bool find :: (a -> Bool) -> Vector a -> Maybe a findIndex :: (a -> Bool) -> Vector a -> Maybe Int foldl :: (a -> b -> a) -> a -> Vector b -> a foldl1 :: (a -> a -> a) -> Vector a -> a foldl' :: (a -> b -> a) -> a -> Vector b -> a foldl1' :: (a -> a -> a) -> Vector a -> a foldr :: (a -> b -> b) -> b -> Vector a -> b foldr1 :: (a -> a -> a) -> Vector a -> a 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 minimum :: Ord a => Vector a -> a unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a scanl :: (a -> b -> a) -> a -> Vector b -> Vector a scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a scanl1 :: (a -> a -> a) -> Vector a -> Vector a scanl1' :: (a -> a -> a) -> Vector a -> Vector a enumFromTo :: Enum a => a -> a -> Vector a enumFromThenTo :: Enum a => a -> a -> a -> Vector a toList :: Vector a -> [a] fromList :: [a] -> Vector a

Documentation

data Vector a Source

Instances Vector Vector a Eq a => Eq (Vector a) Ord a => Ord (Vector a) Show a => Show (Vector a)

data MVector m a Source

Mutable boxed vectors keyed on the monad they live in (IO or ST s). Instances MVectorPure (MVector m) a PrimMonad m => MVector (MVector m) m a

Length information

length :: Vector a -> Int Source

null :: Vector a -> Bool Source

Construction

empty :: Vector a Source

Empty vector

singleton :: a -> Vector a Source

Vector with exaclty one element

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

Prepend an element

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

Append an element

replicate :: Int -> a -> Vector a Source

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

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

Concatenate two vectors

copy :: Vector a -> Vector a Source

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

Accessing individual elements

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

Indexing

head :: Vector a -> a Source

First element

last :: Vector a -> a Source

Last element

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

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

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

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

Subvectors

slice Source

:: => Vector a -> Int starting index -> Int length -> Vector a Yield a part of the vector without copying it. Safer version of unsafeSlice.

init :: Vector a -> Vector a Source

Yield all but the last element without copying.

tail :: Vector a -> Vector a Source

All but the first element (without copying).

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

Yield the first n elements without copying.

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

Yield all but the first n elements without copying.

Permutations

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

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

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

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

reverse :: Vector a -> Vector a Source

Mapping

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

Map a function over a vector

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

Zipping and unzipping

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

Zip two vectors with the given function.

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

Zip three vectors with the given function.

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

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

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

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

Filtering

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

Drop elements which do not satisfy the predicate

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

Yield the longest prefix of elements satisfying the predicate.

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

Drop the longest prefix of elements that satisfy the predicate.

Searching

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

Check whether the vector contains an element

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

Inverse of elem

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

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

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

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

Folding

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

Left fold

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

Lefgt fold on non-empty vectors

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

Left fold with strict accumulator

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

Left fold on non-empty vectors with strict accumulator

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

Right fold

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

Right fold on non-empty vectors

Specialised folds

and :: Vector Bool -> Bool Source

or :: Vector Bool -> Bool Source

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

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

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

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

Unfolding

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

Scans

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

Prefix scan

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

Prefix scan with strict accumulator

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

Suffix scan

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

Suffix scan with strict accumulator

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

Haskell-style scan

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

Haskell-style scan with strict accumulator

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

Scan over a non-empty Vector

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

Scan over a non-empty Vector with a strict accumulator

Enumeration

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

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

Conversion to/from lists

toList :: Vector a -> [a] Source

Convert a vector to a list

fromList :: [a] -> Vector a Source

Convert a list to a vector

Produced by Haddock version 2.4.2