vector-0.12.0.2: Efficient Arrays

Copyright(c) Roman Leshchinskiy 2009-2010
LicenseBSD-style
MaintainerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell2010

Data.Vector.Unboxed.Mutable

Contents

Description

Mutable adaptive unboxed vectors

Synopsis

Mutable vectors of primitive types

data family MVector s a #

Instances
MVector MVector Bool # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Char # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Double # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Float # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Int # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Int8 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Int16 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Int32 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Int64 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Word # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Word8 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Word16 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Word32 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector Word64 # 
Instance details

Defined in Data.Vector.Unboxed.Base

MVector MVector () # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s () -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s () #

basicOverlaps :: MVector s () -> MVector s () -> Bool #

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

basicInitialize :: PrimMonad m => MVector (PrimState m) () -> m () #

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

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

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

basicClear :: PrimMonad m => MVector (PrimState m) () -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) () -> () -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () #

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

Unbox a => MVector MVector (Complex a) # 
Instance details

Defined in Data.Vector.Unboxed.Base

(Unbox a, Unbox b) => MVector MVector (a, b) # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b) -> MVector s (a, b) #

basicOverlaps :: MVector s (a, b) -> MVector s (a, b) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b) -> m (MVector (PrimState m) (a, b)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (a, b) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> (a, b) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b) -> (a, b) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (MVector (PrimState m) (a, b)) #

(Unbox a, Unbox b, Unbox c) => MVector MVector (a, b, c) # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c) -> MVector s (a, b, c) #

basicOverlaps :: MVector s (a, b, c) -> MVector s (a, b, c) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c) -> m (MVector (PrimState m) (a, b, c)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (a, b, c) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c) -> (a, b, c) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (MVector (PrimState m) (a, b, c)) #

(Unbox a, Unbox b, Unbox c, Unbox d) => MVector MVector (a, b, c, d) # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d) -> MVector s (a, b, c, d) #

basicOverlaps :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d) -> m (MVector (PrimState m) (a, b, c, d)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (a, b, c, d) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> (a, b, c, d) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> (a, b, c, d) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (MVector (PrimState m) (a, b, c, d)) #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector MVector (a, b, c, d, e) # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) #

basicOverlaps :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e) -> m (MVector (PrimState m) (a, b, c, d, e)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (a, b, c, d, e) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> (a, b, c, d, e) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (MVector (PrimState m) (a, b, c, d, e)) #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector MVector (a, b, c, d, e, f) # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e, f) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) #

basicOverlaps :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e, f) -> m (MVector (PrimState m) (a, b, c, d, e, f)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) #

NFData (MVector s a) # 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

rnf :: MVector s a -> () #

newtype MVector s Bool # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Bool = MV_Bool (MVector s Word8)
newtype MVector s Char # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Char = MV_Char (MVector s Char)
newtype MVector s Double # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Float # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word64 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word32 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word16 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word8 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word = MV_Word (MVector s Word)
newtype MVector s Int64 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int32 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int16 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int8 # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int8 = MV_Int8 (MVector s Int8)
newtype MVector s Int # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int = MV_Int (MVector s Int)
newtype MVector s () # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s () = MV_Unit Int
newtype MVector s (Complex a) # 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Complex a) = MV_Complex (MVector s (a, a))
data MVector s (a, b) # 
Instance details

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b) = MV_2 !Int !(MVector s a) !(MVector s b)
data MVector s (a, b, c) # 
Instance details

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c) = MV_3 !Int !(MVector s a) !(MVector s b) !(MVector s c)
data MVector s (a, b, c, d) # 
Instance details

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d) = MV_4 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d)
data MVector s (a, b, c, d, e) # 
Instance details

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d, e) = MV_5 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e)
data MVector s (a, b, c, d, e, f) # 
Instance details

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d, e, f) = MV_6 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e) !(MVector s f)

type STVector s = MVector s #

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

Instances
Unbox Bool # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Char # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Double # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Float # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Int # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Int8 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Int16 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Int32 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Int64 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Word # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Word8 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Word16 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Word32 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox Word64 # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox () # 
Instance details

Defined in Data.Vector.Unboxed.Base

Unbox a => Unbox (Complex a) # 
Instance details

Defined in Data.Vector.Unboxed.Base

(Unbox a, Unbox b) => Unbox (a, b) # 
Instance details

Defined in Data.Vector.Unboxed.Base

(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) # 
Instance details

Defined in Data.Vector.Unboxed.Base

(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) # 
Instance details

Defined in Data.Vector.Unboxed.Base

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e) # 
Instance details

Defined in Data.Vector.Unboxed.Base

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

Defined in Data.Vector.Unboxed.Base

Accessors

Length information

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

Length of the mutable vector.

null :: Unbox a => MVector s a -> Bool #

Check whether the vector is empty

Extracting subvectors

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

Yield a part of the mutable vector without copying it.

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

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

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

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

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

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.

unsafeInit :: Unbox a => MVector s a -> MVector s a #

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

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

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

Overlapping

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

Check whether two vectors overlap.

Construction

Initialisation

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

Create a mutable vector of the given length.

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

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

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

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

Create a copy of a mutable vector.

Growing

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.

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.

Restricting memory usage

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.

Zipping and unzipping

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

Accessing individual elements

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.

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

Modify 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.

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.

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

Modify 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.

Modifying vectors

nextPermutation :: (PrimMonad m, Ord e, Unbox e) => MVector (PrimState m) e -> m Bool #

Compute the next (lexicographically) permutation of given vector in-place. Returns False when input is the last permtuation

Filling and copying

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

Set all elements of the vector to the given value.

copy #

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.

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

unsafeMove #

Arguments

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