Safe Haskell | None |
---|
Mutable functor-lazy vectors are like mutable 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 MVector s a = MVector {
- mvecAny :: !(MutableArray s Any)
- mvecInt :: !(MutableByteArray s)
- mlen :: !Int
- mcontrol :: !LazyController
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- forceElement :: MVector s a -> Int -> a
- mapM :: Monad m => (a -> b) -> MVector s a -> m (MVector s b)
- length :: MVector v a => v s a -> Int
- null :: MVector v a => v s a -> Bool
- new :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
- unsafeNew :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
- replicate :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a)
- replicateM :: (PrimMonad m, MVector v a) => Int -> m a -> m (v (PrimState m) a)
- clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a)
- grow :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a)
- unsafeGrow :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a)
- clear :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m ()
- read :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
- write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
- swap :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m ()
- unsafeRead :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
- unsafeWrite :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
- unsafeSwap :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m ()
- set :: (PrimMonad m, MVector v a) => v (PrimState m) a -> a -> m ()
- copy :: (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m ()
- move :: (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m ()
- unsafeCopy :: (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m ()
- unsafeMove :: (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m ()
Mutable functorlazy vectors
MVector | |
|
forceElement :: MVector s a -> Int -> aSource
forces all queued functions to be applied at a given index; this does not actually evaluate the functions, however, only stores the appropriate thunk in the index
mapM :: Monad m => (a -> b) -> MVector s a -> m (MVector s b)Source
map a function onto all elements in the vector; uses time O(1)
Accessors
Length information
Construction
Initialisation
new :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
Create a mutable vector of the given length.
unsafeNew :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
Create a mutable vector of the given length. The length is not checked.
replicate :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a)
Create a mutable vector of the given length (0 if the length is negative) and fill it with an initial value.
replicateM :: (PrimMonad m, MVector v a) => Int -> m a -> m (v (PrimState m) a)
Create a mutable vector of the given length (0 if the length is negative) and fill it with values produced by repeatedly executing the monadic action.
clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a)
Create a copy of a mutable vector.
Growing
grow :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a)
Grow a vector by the given number of elements. The number must be positive.
unsafeGrow :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a)
Grow a vector by the given number of elements. The number must be positive but this is not checked.
Restricting memory usage
clear :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m ()
Reset all elements of the vector to some undefined value, clearing all references to external objects. This is usually a noop for unboxed vectors.
Accessing individual elements
read :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
Yield the element at the given position.
write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
Replace the element at the given position.
swap :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m ()
Swap the elements at the given positions.
unsafeRead :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
Yield the element at the given position. No bounds checks are performed.
unsafeWrite :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
Replace the element at the given position. No bounds checks are performed.
unsafeSwap :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m ()
Swap the elements at the given positions. No bounds checks are performed.
Modifying vectors
Filling and copying
set :: (PrimMonad m, MVector v a) => v (PrimState m) a -> a -> m ()
Set all elements of the vector to the given value.
copy :: (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m ()
Copy a vector. The two vectors must have the same length and may not overlap.
move :: (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m ()
Move the contents of a vector. The two vectors must have the same length.
If the vectors do not overlap, then this is equivalent to copy
.
Otherwise, the copying is performed as if the source vector were
copied to a temporary vector and then the temporary vector was copied
to the target vector.
Copy a vector. The two vectors must have the same length and may not overlap. This is not checked.
Move the contents of a vector. The two vectors must have the same length, but this is not checked.
If the vectors do not overlap, then this is equivalent to unsafeCopy
.
Otherwise, the copying is performed as if the source vector were
copied to a temporary vector and then the temporary vector was copied
to the target vector.