Data.Vector.Unboxed.Mutable

Mutable adaptive unboxed vectors

Mutable vectors of primitive types

data family MVector s a

type IOVector = MVector RealWorld

type STVector s = MVector s

class (Vector Vector a, MVector MVector a) => Unbox a

Instances

Unbox Bool

Unbox Char

Unbox Double

Unbox Float

Unbox Int

Unbox Int8

Unbox Int16

Unbox Int32

Unbox Int64

Unbox Word

Unbox Word8

Unbox Word16

Unbox Word32

Unbox Word64

Unbox ()

(RealFloat a, Unbox a) => Unbox (Complex a)

(Unbox a, Unbox b) => Unbox (a, b)

(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)

(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e)

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)

Operations on mutable vectors

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

Length of the mutable vector.

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

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

Yield a part of the mutable vector without copying it.

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

Create a mutable vector of the given length.

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

Create a mutable vector of the given length and fill it with an initial value.

read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a

Yield the element at the given position.

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

Replace the element at the given position.

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

Swap the elements at the given positions.

clear :: (PrimMonad m, Unbox 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.

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

Set all elements of the vector to the given value.

copy :: (PrimMonad m, Unbox 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.

grow :: (PrimMonad m, Unbox 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.

zip :: (Unbox a, Unbox b) => MVector s a -> MVector s b -> MVector s (a, b)

O(1) Zip 2 vectors

zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c)

O(1) Zip 3 vectors

zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s (a, b, c, d)

O(1) Zip 4 vectors

zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e)

O(1) Zip 5 vectors

zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f)

O(1) Zip 6 vectors

unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a, MVector s b)

O(1) Unzip 2 vectors

unzip3 :: (Unbox a, Unbox b, Unbox c) => MVector s (a, b, c) -> (MVector s a, MVector s b, MVector s c)

O(1) Unzip 3 vectors

unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s (a, b, c, d) -> (MVector s a, MVector s b, MVector s c, MVector s d)

O(1) Unzip 4 vectors

unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e)

O(1) Unzip 5 vectors

unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e, MVector s f)

O(1) Unzip 6 vectors

Unsafe operations

unsafeSlice

Arguments

:: Unbox 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.

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

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

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

Create a mutable vector of the given length and fill it with an initial value. The length is not checked.

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

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

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

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

unsafeSwap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()

Swap the elements at the given positions. No bounds checks are performed.

unsafeCopy

Arguments

:: (PrimMonad m, Unbox 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.

unsafeGrow :: (PrimMonad m, Unbox 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.