Portability | non-portable |
---|---|

Stability | experimental |

Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |

Safe interface to Data.Vector.Primitive.Mutable

- data MVector s a
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- class Prim a
- length :: Prim a => MVector s a -> Int
- null :: Prim a => MVector s a -> Bool
- slice :: Prim a => Int -> Int -> MVector s a -> MVector s a
- init :: Prim a => MVector s a -> MVector s a
- tail :: Prim a => MVector s a -> MVector s a
- take :: Prim a => Int -> MVector s a -> MVector s a
- drop :: Prim a => Int -> MVector s a -> MVector s a
- splitAt :: Prim a => Int -> MVector s a -> (MVector s a, MVector s a)
- overlaps :: Prim a => MVector s a -> MVector s a -> Bool
- new :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
- replicate :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
- replicateM :: (PrimMonad m, Prim a) => Int -> m a -> m (MVector (PrimState m) a)
- clone :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m (MVector (PrimState m) a)
- grow :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- clear :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m ()
- read :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
- write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
- swap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m ()
- set :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> a -> m ()
- copy :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- move :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()

# Mutable vectors of primitive types

Mutable vectors of primitive types.

class Prim a

Class of types supporting primitive array operations

# Accessors

## Length information

## Extracting subvectors

slice :: Prim a => Int -> Int -> MVector s a -> MVector s aSource

Yield a part of the mutable vector without copying it.

## Overlapping

# Construction

## Initialisation

new :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)Source

Create a mutable vector of the given length.

replicate :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)Source

Create a mutable vector of the given length (0 if the length is negative) and fill it with an initial value.

replicateM :: (PrimMonad m, Prim a) => Int -> m a -> m (MVector (PrimState m) a)Source

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, Prim a) => MVector (PrimState m) a -> m (MVector (PrimState m) a)Source

Create a copy of a mutable vector.

## Growing

grow :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)Source

Grow a vector by the given number of elements. The number must be positive.

## Restricting memory usage

clear :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m ()Source

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, Prim a) => MVector (PrimState m) a -> Int -> m aSource

Yield the element at the given position.

write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()Source

Replace the element at the given position.

swap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m ()Source

Swap the elements at the given positions.

# Modifying vectors

## Filling and copying

set :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> a -> m ()Source

Set all elements of the vector to the given value.

copy :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()Source

Copy a vector. The two vectors must have the same length and may not overlap.

move :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()Source

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.