Safe Haskell  None 

Mutable functorlazy 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/functorlazy 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.