Data.Vector.Primitive.Mutable

vector-0.7.0.1: Efficient Arrays

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

Data.Vector.Primitive.Mutable

Contents

- Mutable vectors of primitive types
- Accessors
  - Length information
  - Extracting subvectors
  - Overlapping
- Construction
  - Initialisation
  - Growing
  - Restricting memory usage
- Accessing individual elements
- Modifying vectors
  - Filling and copying
- Deprecated operations

Description

Mutable primitive vectors.

Synopsis

- data MVector s a = MVector !Int !Int !(MutableByteArray s)
- 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
- unsafeSlice :: Prim a => Int -> Int -> MVector s a -> MVector s a
- unsafeInit :: Prim a => MVector s a -> MVector s a
- unsafeTail :: Prim a => MVector s a -> MVector s a
- unsafeTake :: Prim a => Int -> MVector s a -> MVector s a
- unsafeDrop :: Prim a => Int -> 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)
- unsafeNew :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
- replicate :: (PrimMonad m, Prim a) => Int -> 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)
- unsafeGrow :: (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 ()
- unsafeRead :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
- unsafeWrite :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
- unsafeSwap :: (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 ()
- unsafeCopy :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- newWith :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
- unsafeNewWith :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)

# Mutable vectors of primitive types

data MVector s a

Mutable vectors of primitive types.

Constructors

MVector !Int !Int !(MutableByteArray s) |

Instances

Typeable2 MVector |
Prim a => MVector MVector a |

type IOVector = MVector RealWorld

type STVector s = MVector s

class Prim a

Class of types supporting primitive array operations

Instances

Prim Char |
Prim Double |
Prim Float |
Prim Int |
Prim Int8 |
Prim Int16 |
Prim Int32 |
Prim Int64 |
Prim Word |
Prim Word8 |
Prim Word16 |
Prim Word32 |
Prim Word64 |
Prim Addr |

# Accessors

## Length information

length :: Prim a => MVector s a -> Int

Length of the mutable vector.

null :: Prim a => MVector s a -> Bool

Check whether the vector is empty

## Extracting subvectors

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

Yield a part of the mutable vector without copying it.

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

unsafeSlice

Arguments

:: Prim a |
=> Int | starting index
-> Int | length of the slice
-> MVector s a |
-> MVector s a |

Yield a part of the mutable vector without copying it. No bounds checks are performed.

unsafeInit :: Prim a => MVector s a -> MVector s a

unsafeTail :: Prim a => MVector s a -> MVector s a

unsafeTake :: Prim a => Int -> MVector s a -> MVector s a

unsafeDrop :: Prim a => Int -> MVector s a -> MVector s a

## Overlapping

overlaps :: Prim a => MVector s a -> MVector s a -> Bool

# Construction

## Initialisation

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

Create a mutable vector of the given length.

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

Create a mutable vector of the given length. The length is not checked.

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

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

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

Create a copy of a mutable vector.

## Growing

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

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

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

Yield the element at the given position.

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

Replace the element at the given position.

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

Swap the elements at the given positions.

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

Yield the element at the given position. No bounds checks are performed.

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

Replace the element at the given position. No bounds checks are performed.

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

Set all elements of the vector to the given value.

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

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

unsafeCopy

Arguments

:: (PrimMonad m, Prim a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

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

# Deprecated operations

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

DEPRECATED Use `replicate` instead

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

DEPRECATED Use `replicate` instead