RIO.Vector.Unboxed.Unsafe

Unoxed Vector unsafe functions. These perform no bounds checking, and may cause segmentation faults etc.! Import as:

import qualified RIO.Vector.Unoxed.Unsafe as VU'

Accessors

Indexing

unsafeIndex :: Unbox a => Vector a -> Int -> a

O(1) Unsafe indexing without bounds checking

unsafeHead :: Unbox a => Vector a -> a

O(1) First element without checking if the vector is empty

unsafeLast :: Unbox a => Vector a -> a

O(1) Last element without checking if the vector is empty

Monadic indexing

unsafeIndexM :: (Unbox a, Monad m) => Vector a -> Int -> m a

O(1) Indexing in a monad without bounds checks. See indexM for an explanation of why this is useful.

unsafeHeadM :: (Unbox a, Monad m) => Vector a -> m a

O(1) First element in a monad without checking for empty vectors. See indexM for an explanation of why this is useful.

unsafeLastM :: (Unbox a, Monad m) => Vector a -> m a

O(1) Last element in a monad without checking for empty vectors. See indexM for an explanation of why this is useful.

Extracting subvectors

unsafeSlice

Arguments

:: Unbox a

=> Int

i starting index

-> Int

n length

-> Vector a

-> Vector a

O(1) Yield a slice of the vector without copying. The vector must contain at least i+n elements but this is not checked.

unsafeInit :: Unbox a => Vector a -> Vector a

O(1) Yield all but the last element without copying. The vector may not be empty but this is not checked.

unsafeTail :: Unbox a => Vector a -> Vector a

O(1) Yield all but the first element without copying. The vector may not be empty but this is not checked.

unsafeTake :: Unbox a => Int -> Vector a -> Vector a

O(1) Yield the first n elements without copying. The vector must contain at least n elements but this is not checked.

unsafeDrop :: Unbox a => Int -> Vector a -> Vector a

O(1) Yield all but the first n elements without copying. The vector must contain at least n elements but this is not checked.

Modifying vectors

Bulk updates

unsafeUpd :: Unbox a => Vector a -> [(Int, a)] -> Vector a

Same as (//) but without bounds checking.

unsafeUpdate :: Unbox a => Vector a -> Vector (Int, a) -> Vector a

Same as update but without bounds checking.

unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a

Same as update_ but without bounds checking.

Accumulations

unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

Same as accum but without bounds checking.

unsafeAccumulate :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a

Same as accumulate but without bounds checking.

unsafeAccumulate_ :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a

Same as accumulate_ but without bounds checking.

Permutations

unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a

Same as backpermute but without bounds checking.

Conversions

Mutable vectors

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

O(1) Unsafe convert a mutable vector to an immutable one without copying. The mutable vector may not be used after this operation.

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

O(1) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.

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

O(n) Copy an immutable vector into a mutable one. The two vectors must have the same length. This is not checked.