Data.Vector.Mutable

vector-0.11.0.0: Efficient Arrays

Copyright | (c) Roman Leshchinskiy 2008-2010
License | BSD-style
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au>
Stability | experimental
Portability | non-portable
Safe Haskell | None
Language | Haskell2010

Data.Vector.Mutable

Contents

- Mutable boxed vectors
- Accessors
  - Length information
  - Extracting subvectors
  - Overlapping
- Construction
  - Initialisation
  - Growing
  - Restricting memory usage
- Accessing individual elements
- Modifying vectors
  - Filling and copying

Description

Mutable boxed vectors.

Synopsis

- data MVector s a = MVector !Int !Int !(MutableArray s a)
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- length :: MVector s a -> Int
- null :: MVector s a -> Bool
- slice :: Int -> Int -> MVector s a -> MVector s a
- init :: MVector s a -> MVector s a
- tail :: MVector s a -> MVector s a
- take :: Int -> MVector s a -> MVector s a
- drop :: Int -> MVector s a -> MVector s a
- splitAt :: Int -> MVector s a -> (MVector s a, MVector s a)
- unsafeSlice :: Int -> Int -> MVector s a -> MVector s a
- unsafeInit :: MVector s a -> MVector s a
- unsafeTail :: MVector s a -> MVector s a
- unsafeTake :: Int -> MVector s a -> MVector s a
- unsafeDrop :: Int -> MVector s a -> MVector s a
- overlaps :: MVector s a -> MVector s a -> Bool
- new :: PrimMonad m => Int -> m (MVector (PrimState m) a)
- unsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) a)
- replicate :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
- replicateM :: PrimMonad m => Int -> m a -> m (MVector (PrimState m) a)
- clone :: PrimMonad m => MVector (PrimState m) a -> m (MVector (PrimState m) a)
- grow :: PrimMonad m => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- unsafeGrow :: PrimMonad m => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- clear :: PrimMonad m => MVector (PrimState m) a -> m ()
- read :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
- write :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
- modify :: PrimMonad m => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- swap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
- unsafeRead :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
- unsafeWrite :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
- unsafeModify :: PrimMonad m => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- unsafeSwap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
- set :: PrimMonad m => MVector (PrimState m) a -> a -> m ()
- copy :: PrimMonad m => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- move :: PrimMonad m => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCopy :: PrimMonad m => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeMove :: PrimMonad m => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()

# Mutable boxed vectors

data MVector s a #

Mutable boxed vectors keyed on the monad they live in (`IO` or ``ST` s`).

Constructors

MVector !Int !Int !(MutableArray s a) |

Instances

MVector MVector a # |
Methods basicLength :: MVector s a -> Int # basicUnsafeSlice :: Int -> Int -> MVector s a -> MVector s a # basicOverlaps :: MVector s a -> MVector s a -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) a) # basicInitialize :: PrimMonad m => MVector (PrimState m) a -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) a -> Int -> m a # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) a -> m () # basicSet :: PrimMonad m => MVector (PrimState m) a -> a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) a -> MVector (PrimState m) a -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) a -> MVector (PrimState m) a -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #

type IOVector = MVector RealWorld #

type STVector s = MVector s #

# Accessors

## Length information

length :: MVector s a -> Int #

Length of the mutable vector.

null :: MVector s a -> Bool #

Check whether the vector is empty

## Extracting subvectors

slice :: Int -> Int -> MVector s a -> MVector s a #

Yield a part of the mutable vector without copying it.

init :: MVector s a -> MVector s a #

tail :: MVector s a -> MVector s a #

take :: Int -> MVector s a -> MVector s a #

drop :: Int -> MVector s a -> MVector s a #

splitAt :: Int -> MVector s a -> (MVector s a, MVector s a) #

unsafeSlice #

Arguments

:: 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 :: MVector s a -> MVector s a #

unsafeTail :: MVector s a -> MVector s a #

unsafeTake :: Int -> MVector s a -> MVector s a #

unsafeDrop :: Int -> MVector s a -> MVector s a #

## Overlapping

overlaps :: MVector s a -> MVector s a -> Bool #

Check whether two vectors overlap.

# Construction

## Initialisation

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

Create a mutable vector of the given length.

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

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

replicate :: PrimMonad m => 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.

replicateM :: PrimMonad m => Int -> m a -> m (MVector (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 (PrimState m) a -> m (MVector (PrimState m) a) #

Create a copy of a mutable vector.

## Growing

grow :: PrimMonad m => 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 => 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 => 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 => MVector (PrimState m) a -> Int -> m a #

Yield the element at the given position.

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

Replace the element at the given position.

modify :: PrimMonad m => MVector (PrimState m) a -> (a -> a) -> Int -> m () #

Modify the element at the given position.

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

Swap the elements at the given positions.

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

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

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

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

unsafeModify :: PrimMonad m => MVector (PrimState m) a -> (a -> a) -> Int -> m () #

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

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

Set all elements of the vector to the given value.

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

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

move :: PrimMonad m => MVector (PrimState m) a -> MVector (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.

unsafeCopy #

Arguments

:: PrimMonad m |
=> 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.

unsafeMove #

Arguments

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

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.