Safe Haskell | None |
---|
Functor-lazy vectors are like boxed vectors, but support mapping a function onto all elements in constant time. All vector operations (except slicing) are fully supported. See http://github.com/mikeizbicki/functor-lazy for more details.
- data Vector a
- data MVector s a
- length :: Vector v a => v a -> Int
- null :: Vector v a => v a -> Bool
- (!) :: Vector v a => v a -> Int -> a
- (!?) :: Vector v a => v a -> Int -> Maybe a
- head :: Vector v a => v a -> a
- last :: Vector v a => v a -> a
- unsafeIndex :: Vector v a => v a -> Int -> a
- unsafeHead :: Vector v a => v a -> a
- unsafeLast :: Vector v a => v a -> a
- indexM :: (Vector v a, Monad m) => v a -> Int -> m a
- headM :: (Vector v a, Monad m) => v a -> m a
- lastM :: (Vector v a, Monad m) => v a -> m a
- unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
- unsafeHeadM :: (Vector v a, Monad m) => v a -> m a
- unsafeLastM :: (Vector v a, Monad m) => v a -> m a
- empty :: Vector v a => v a
- singleton :: Vector v a => a -> v a
- replicate :: Vector v a => Int -> a -> v a
- generate :: Vector v a => Int -> (Int -> a) -> v a
- iterateN :: Vector v a => Int -> (a -> a) -> a -> v a
- replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a)
- generateM :: (Monad m, Vector v a) => Int -> (Int -> m a) -> m (v a)
- create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a
- unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a
- unfoldrN :: Vector v a => Int -> (b -> Maybe (a, b)) -> b -> v a
- constructN :: Vector v a => Int -> (v a -> a) -> v a
- constructrN :: Vector v a => Int -> (v a -> a) -> v a
- enumFromN :: (Vector v a, Num a) => a -> Int -> v a
- enumFromStepN :: (Vector v a, Num a) => a -> a -> Int -> v a
- enumFromTo :: (Vector v a, Enum a) => a -> a -> v a
- enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
- cons :: Vector v a => a -> v a -> v a
- snoc :: Vector v a => v a -> a -> v a
- (++) :: Vector v a => v a -> v a -> v a
- concat :: Vector v a => [v a] -> v a
- force :: Vector v a => v a -> v a
- (//) :: Vector v a => v a -> [(Int, a)] -> v a
- update :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
- update_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
- unsafeUpd :: Vector v a => v a -> [(Int, a)] -> v a
- unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
- unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
- accum :: Vector v a => (a -> b -> a) -> v a -> [(Int, b)] -> v a
- accumulate :: (Vector v a, Vector v (Int, b)) => (a -> b -> a) -> v a -> v (Int, b) -> v a
- accumulate_ :: (Vector v a, Vector v Int, Vector v b) => (a -> b -> a) -> v a -> v Int -> v b -> v a
- unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int, b)] -> v a
- unsafeAccumulate :: (Vector v a, Vector v (Int, b)) => (a -> b -> a) -> v a -> v (Int, b) -> v a
- unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b) => (a -> b -> a) -> v a -> v Int -> v b -> v a
- reverse :: Vector v a => v a -> v a
- backpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
- unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
- modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
- indexed :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a)
- zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c
- zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d
- zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
- zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e -> v f
- zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g
- izipWith :: (Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> c) -> v a -> v b -> v c
- izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
- izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
- izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (Int -> a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e -> v f
- izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g
- zip :: (Vector v a, Vector v b, Vector v (a, b)) => v a -> v b -> v (a, b)
- zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v a -> v b -> v c -> v (a, b, c)
- zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v a -> v b -> v c -> v d -> v (a, b, c, d)
- zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
- zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)
- zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (a -> b -> m c) -> v a -> v b -> m (v c)
- zipWithM_ :: (Monad m, Vector v a, Vector v b) => (a -> b -> m c) -> v a -> v b -> m ()
- unzip :: (Vector v a, Vector v b, Vector v (a, b)) => v (a, b) -> (v a, v b)
- unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v (a, b, c) -> (v a, v b, v c)
- unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v (a, b, c, d) -> (v a, v b, v c, v d)
- unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v (a, b, c, d, e) -> (v a, v b, v c, v d, v e)
- unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f)
- filter :: Vector v a => (a -> Bool) -> v a -> v a
- ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a
- filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a)
- takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
- dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
- elem :: (Vector v a, Eq a) => a -> v a -> Bool
- notElem :: (Vector v a, Eq a) => a -> v a -> Bool
- find :: Vector v a => (a -> Bool) -> v a -> Maybe a
- findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int
- findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int
- elemIndex :: (Vector v a, Eq a) => a -> v a -> Maybe Int
- elemIndices :: (Vector v a, Vector v Int, Eq a) => a -> v a -> v Int
- foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a
- foldl1 :: Vector v a => (a -> a -> a) -> v a -> a
- foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a
- foldl1' :: Vector v a => (a -> a -> a) -> v a -> a
- foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b
- foldr1 :: Vector v a => (a -> a -> a) -> v a -> a
- foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b
- foldr1' :: Vector v a => (a -> a -> a) -> v a -> a
- ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
- ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
- ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
- ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
- all :: Vector v a => (a -> Bool) -> v a -> Bool
- any :: Vector v a => (a -> Bool) -> v a -> Bool
- and :: Vector v Bool => v Bool -> Bool
- or :: Vector v Bool => v Bool -> Bool
- sum :: (Vector v a, Num a) => v a -> a
- product :: (Vector v a, Num a) => v a -> a
- maximum :: (Vector v a, Ord a) => v a -> a
- maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
- minimum :: (Vector v a, Ord a) => v a -> a
- minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
- minIndex :: (Vector v a, Ord a) => v a -> Int
- minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
- maxIndex :: (Vector v a, Ord a) => v a -> Int
- maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
- foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
- foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
- fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
- fold1M' :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
- foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
- foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
- fold1M_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m ()
- fold1M'_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m ()
- sequence :: (Monad m, Vector v a, Vector v (m a)) => v (m a) -> m (v a)
- sequence_ :: (Monad m, Vector v (m a)) => v (m a) -> m ()
- prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
- prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
- postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
- postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
- scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
- scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
- scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
- scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
- prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
- prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
- postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
- postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
- scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
- scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
- scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a
- scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
- toList :: Vector v a => v a -> [a]
- fromList :: Vector v a => [a] -> v a
- fromListN :: Vector v a => Int -> [a] -> v a
- convert :: (Vector v a, Vector w a) => v a -> w a
- freeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a)
- thaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a)
- copy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
- unsafeFreeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a)
- unsafeThaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a)
- unsafeCopy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
Functor-lazy vectors
Accessors
Length information
Indexing
unsafeIndex :: Vector v a => v a -> Int -> a
O(1) Unsafe indexing without bounds checking
unsafeHead :: Vector v a => v a -> a
O(1) First element without checking if the vector is empty
unsafeLast :: Vector v a => v a -> a
O(1) Last element without checking if the vector is empty
Monadic indexing
indexM :: (Vector v a, Monad m) => v a -> Int -> m a
O(1) Indexing in a monad.
The monad allows operations to be strict in the vector when necessary. Suppose vector copying is implemented like this:
copy mv v = ... write mv i (v ! i) ...
For lazy vectors, v ! i
would not be evaluated which means that mv
would unnecessarily retain a reference to v
in each element written.
With indexM
, copying can be implemented like this instead:
copy mv v = ... do x <- indexM v i write mv i x
Here, no references to v
are retained because indexing (but not the
elements) is evaluated eagerly.
headM :: (Vector v a, Monad m) => v a -> m a
O(1) First element of a vector in a monad. See indexM
for an
explanation of why this is useful.
lastM :: (Vector v a, Monad m) => v a -> m a
O(1) Last element of a vector in a monad. See indexM
for an
explanation of why this is useful.
unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
O(1) Indexing in a monad without bounds checks. See indexM
for an
explanation of why this is useful.
unsafeHeadM :: (Vector v a, Monad m) => v a -> m a
O(1) First element in a monad without checking for empty vectors.
See indexM
for an explanation of why this is useful.
unsafeLastM :: (Vector v a, Monad m) => v a -> m a
O(1) Last element in a monad without checking for empty vectors.
See indexM
for an explanation of why this is useful.
Construction
Initialisation
replicate :: Vector v a => Int -> a -> v a
O(n) Vector of the given length with the same value in each position
generate :: Vector v a => Int -> (Int -> a) -> v a
O(n) Construct a vector of the given length by applying the function to each index
iterateN :: Vector v a => Int -> (a -> a) -> a -> v a
O(n) Apply function n times to value. Zeroth element is original value.
Monadic initialisation
replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a)
O(n) Execute the monadic action the given number of times and store the results in a vector.
generateM :: (Monad m, Vector v a) => Int -> (Int -> m a) -> m (v a)
O(n) Construct a vector of the given length by applying the monadic action to each index
Unfolding
constructN :: Vector v a => Int -> (v a -> a) -> v a
O(n) Construct a vector with n
elements by repeatedly applying the
generator function to the already constructed part of the vector.
constructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in f <a,b,c>
constructrN :: Vector v a => Int -> (v a -> a) -> v a
O(n) Construct a vector with n
elements from right to left by
repeatedly applying the generator function to the already constructed part
of the vector.
constructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in f <c,b,a>
Enumeration
enumFromN :: (Vector v a, Num a) => a -> Int -> v a
O(n) Yield a vector of the given length containing the values x
, x+1
etc. This operation is usually more efficient than enumFromTo
.
enumFromN 5 3 = <5,6,7>
enumFromStepN :: (Vector v a, Num a) => a -> a -> Int -> v a
O(n) 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
.
enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
enumFromTo :: (Vector v a, Enum a) => a -> a -> v a
O(n) Enumerate values from x
to y
.
WARNING: This operation can be very inefficient. If at all possible, use
enumFromN
instead.
enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
O(n) 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.
Concatenation
Restricting memory usage
force :: Vector v a => v a -> v a
O(n) Yield the argument but force it not to retain any extra memory, possibly by copying it.
This is especially useful when dealing with slices. For example:
force (slice 0 2 <huge vector>)
Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.
Modifying vectors
Bulk updates
:: Vector v a | |
=> v a | initial vector (of length |
-> [(Int, a)] | list of index/value pairs (of length |
-> v a |
O(m+n) For each pair (i,a)
from the list, replace the vector
element at position i
by a
.
<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
:: (Vector v a, Vector v (Int, a)) | |
=> v a | initial vector (of length |
-> v (Int, a) | vector of index/value pairs (of length |
-> v a |
O(m+n) For each pair (i,a)
from the vector of index/value pairs,
replace the vector element at position i
by a
.
update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>
:: (Vector v a, Vector v Int) | |
=> v a | initial vector (of length |
-> v Int | index vector (of length |
-> v a | value vector (of length |
-> v a |
O(m+min(n1,n2)) For each index i
from the index vector and the
corresponding value a
from the value vector, replace the element of the
initial vector at position i
by a
.
update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7>
This function is useful for instances of Vector
that cannot store pairs.
Otherwise, update
is probably more convenient.
update_ xs is ys =update
xs (zip
is ys)
unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
Same as update
but without bounds checking.
unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
Same as update_
but without bounds checking.
Accumulations
:: Vector v a | |
=> (a -> b -> a) | accumulating function |
-> v a | initial vector (of length |
-> [(Int, b)] | list of index/value pairs (of length |
-> v a |
O(m+n) For each pair (i,b)
from the list, replace the vector element
a
at position i
by f a b
.
accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
:: (Vector v a, Vector v (Int, b)) | |
=> (a -> b -> a) | accumulating function |
-> v a | initial vector (of length |
-> v (Int, b) | vector of index/value pairs (of length |
-> v a |
O(m+n) For each pair (i,b)
from the vector of pairs, replace the vector
element a
at position i
by f a b
.
accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>
:: (Vector v a, Vector v Int, Vector v b) | |
=> (a -> b -> a) | accumulating function |
-> v a | initial vector (of length |
-> v Int | index vector (of length |
-> v b | value vector (of length |
-> v a |
O(m+min(n1,n2)) For each index i
from the index vector and the
corresponding value b
from the the value vector,
replace the element of the initial vector at
position i
by f a b
.
accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
This function is useful for instances of Vector
that cannot store pairs.
Otherwise, accumulate
is probably more convenient:
accumulate_ f as is bs =accumulate
f as (zip
is bs)
unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int, b)] -> v a
Same as accum
but without bounds checking.
unsafeAccumulate :: (Vector v a, Vector v (Int, b)) => (a -> b -> a) -> v a -> v (Int, b) -> v a
Same as accumulate
but without bounds checking.
unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b) => (a -> b -> a) -> v a -> v Int -> v b -> v a
Same as accumulate_
but without bounds checking.
Permutations
unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
Same as backpermute
but without bounds checking.
Safe destructive updates
Elementwise operations
Indexing
indexed :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a)
O(n) Pair each element in a vector with its index
Zipping
zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c
O(min(m,n)) Zip two vectors with the given function.
zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d
Zip three vectors with the given function.
zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e -> v f
zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g
izipWith :: (Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> c) -> v a -> v b -> v c
O(min(m,n)) Zip two vectors with a function that also takes the elements' indices.
izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (Int -> a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e -> v f
izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g
zip :: (Vector v a, Vector v b, Vector v (a, b)) => v a -> v b -> v (a, b)
O(min(m,n)) Zip two vectors
zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v a -> v b -> v c -> v (a, b, c)
zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v a -> v b -> v c -> v d -> v (a, b, c, d)
zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)
Monadic zipping
zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (a -> b -> m c) -> v a -> v b -> m (v c)
O(min(m,n)) Zip the two vectors with the monadic action and yield a vector of results
zipWithM_ :: (Monad m, Vector v a, Vector v b) => (a -> b -> m c) -> v a -> v b -> m ()
O(min(m,n)) Zip the two vectors with the monadic action and ignore the results
Unzipping
unzip :: (Vector v a, Vector v b, Vector v (a, b)) => v (a, b) -> (v a, v b)
O(min(m,n)) Unzip a vector of pairs.
unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v (a, b, c) -> (v a, v b, v c)
unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v (a, b, c, d) -> (v a, v b, v c, v d)
unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v (a, b, c, d, e) -> (v a, v b, v c, v d, v e)
unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f)
Working with predicates
Filtering
filter :: Vector v a => (a -> Bool) -> v a -> v a
O(n) Drop elements that do not satisfy the predicate
ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a
O(n) Drop elements that do not satisfy the predicate which is applied to values and their indices
filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a)
O(n) Drop elements that do not satisfy the monadic predicate
takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
O(n) Yield the longest prefix of elements satisfying the predicate without copying.
dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
O(n) Drop the longest prefix of elements that satisfy the predicate without copying.
Searching
notElem :: (Vector v a, Eq a) => a -> v a -> Bool
O(n) Check if the vector does not contain an element (inverse of elem
)
findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int
O(n) Yield the indices of elements satisfying the predicate in ascending order.
elemIndices :: (Vector v a, Vector v Int, Eq a) => a -> v a -> v Int
O(n) Yield the indices of all occurences of the given element in
ascending order. This is a specialised version of findIndices
.
Folding
foldl1' :: Vector v a => (a -> a -> a) -> v a -> a
O(n) Left fold on non-empty vectors with strict accumulator
foldr1' :: Vector v a => (a -> a -> a) -> v a -> a
O(n) Right fold on non-empty vectors with strict accumulator
ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
O(n) Left fold (function applied to each element and its index)
ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
O(n) Left fold with strict accumulator (function applied to each element and its index)
ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
O(n) Right fold (function applied to each element and its index)
ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
O(n) Right fold with strict accumulator (function applied to each element and its index)
Specialised folds
maximum :: (Vector v a, Ord a) => v a -> a
O(n) Yield the maximum element of the vector. The vector may not be empty.
maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
O(n) Yield the maximum element of the vector according to the given comparison function. The vector may not be empty.
minimum :: (Vector v a, Ord a) => v a -> a
O(n) Yield the minimum element of the vector. The vector may not be empty.
minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
O(n) Yield the minimum element of the vector according to the given comparison function. The vector may not be empty.
minIndex :: (Vector v a, Ord a) => v a -> Int
O(n) Yield the index of the minimum element of the vector. The vector may not be empty.
minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
O(n) Yield the index of the minimum element of the vector according to the given comparison function. The vector may not be empty.
maxIndex :: (Vector v a, Ord a) => v a -> Int
O(n) Yield the index of the maximum element of the vector. The vector may not be empty.
maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
O(n) Yield the index of the maximum element of the vector according to the given comparison function. The vector may not be empty.
Monadic folds
foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
O(n) Monadic fold with strict accumulator
fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
O(n) Monadic fold over non-empty vectors
fold1M' :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
O(n) Monadic fold over non-empty vectors with strict accumulator
foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
O(n) Monadic fold that discards the result
foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
O(n) Monadic fold with strict accumulator that discards the result
fold1M_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m ()
O(n) Monadic fold over non-empty vectors that discards the result
fold1M'_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m ()
O(n) Monad fold over non-empty vectors with strict accumulator that discards the result
Monadic sequencing
sequence :: (Monad m, Vector v a, Vector v (m a)) => v (m a) -> m (v a)
Evaluate each action and collect the results
sequence_ :: (Monad m, Vector v (m a)) => v (m a) -> m ()
Evaluate each action and discard the results
Prefix sums (scans)
prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
O(n) Prescan with strict accumulator
postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
O(n) Scan with strict accumulator
scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
O(n) Haskell-style scan
scanl f z <x1,...,xn> = <y1,...,y(n+1)> where y1 = z yi = f y(i-1) x(i-1)
Example: scanl (+) 0 <1,2,3,4> = <0,1,3,6,10>
scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
O(n) Haskell-style scan with strict accumulator
scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
O(n) Scan over a non-empty vector
scanl f <x1,...,xn> = <y1,...,yn> where y1 = x1 yi = f y(i-1) xi
scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
O(n) Scan over a non-empty vector with a strict accumulator
prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
O(n) Right-to-left prescan with strict accumulator
postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
O(n) Right-to-left scan with strict accumulator
scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
O(n) Right-to-left Haskell-style scan
scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
O(n) Right-to-left Haskell-style scan with strict accumulator
scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
O(n) Right-to-left scan over a non-empty vector with a strict accumulator
Conversions
Lists
Other vector types
Mutable vectors
freeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a)
O(n) Yield an immutable copy of the mutable vector.
thaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a)
O(n) Yield a mutable copy of the immutable vector.
copy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
O(n) Copy an immutable vector into a mutable one. The two vectors must have the same length.
unsafeFreeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a)
O(1) Unsafe convert a mutable vector to an immutable one without copying. The mutable vector may not be used after this operation.
unsafeThaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a)
O(1) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.
unsafeCopy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
O(n) Copy an immutable vector into a mutable one. The two vectors must have the same length. This is not checked.