RIO.Vector.Storable.Unsafe

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

import qualified RIO.Vector.Storable.Unsafe as VS'

Accessors

Indexing

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

O(1) Unsafe indexing without bounds checking

unsafeHead :: Storable a => Vector a -> a

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

unsafeLast :: Storable a => Vector a -> a

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

Monadic indexing

unsafeIndexM :: (Storable 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 :: (Storable 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 :: (Storable 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

:: Storable 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 :: Storable 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 :: Storable 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 :: Storable 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 :: Storable 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 :: Storable a => Vector a -> [(Int, a)] -> Vector a

Same as (//) but without bounds checking.

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

Same as update_ but without bounds checking.

Accumulations

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

Same as accum but without bounds checking.

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

Same as accumulate_ but without bounds checking.

Permutations

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

Same as backpermute but without bounds checking.

Conversions

Mutable vectors

unsafeFreeze :: (Storable 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 :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)

O(1) Unsafely convert an immutable vector to a mutable one without copying. Note that this is very dangerous function and generally it's only safe to read from resulting vector. In which case immutable vector could be used safely as well.

Problem with mutation happens because GHC has a lot of freedom to introduce sharing. As a result mutable vectors produced by unsafeThaw may or may not share same underlying buffer. For example:

foo = do
  let vec = V.generate 10 id
  mvec <- V.unsafeThaw vec
  do_something mvec

Here GHC could lift vec outside of foo which means all calls to do_something will use same buffer with possibly disastrous results. Whether such aliasing happens or not depends on program in question, optimization levels, and GHC flags.

All in all attempts to modify vector after unsafeThaw falls out of domain of software engineering and into realm of black magic, dark rituals, and unspeakable horrors. Only advice that could be given is: "don't attempt to mutate vector after unsafeThaw unless you know how to prevent GHC from aliasing buffers accidentally. We don't"

unsafeCopy :: (Storable 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.

Raw pointers

unsafeFromForeignPtr

Arguments

:: Storable a

=> ForeignPtr a

pointer

-> Int

offset

-> Int

length

-> Vector a

O(1) Create a vector from a ForeignPtr with an offset and a length.

The data may not be modified through the ForeignPtr afterwards.

If your offset is 0 it is more efficient to use unsafeFromForeignPtr0.

unsafeFromForeignPtr0

Arguments

:: Storable a

=> ForeignPtr a

pointer

-> Int

length

-> Vector a

O(1) Create a vector from a ForeignPtr and a length.

It is assumed the pointer points directly to the data (no offset). Use unsafeFromForeignPtr if you need to specify an offset.

The data may not be modified through the ForeignPtr afterwards.

unsafeToForeignPtr :: Storable a => Vector a -> (ForeignPtr a, Int, Int)

O(1) Yield the underlying ForeignPtr together with the offset to the data and its length. The data may not be modified through the ForeignPtr.

unsafeToForeignPtr0 :: Storable a => Vector a -> (ForeignPtr a, Int)

O(1) Yield the underlying ForeignPtr together with its length.

You can assume the pointer points directly to the data (no offset).

The data may not be modified through the ForeignPtr.

unsafeWith :: (MonadUnliftIO m, Storable a) => Vector a -> (Ptr a -> m b) -> m b

Lifted version of unsafeWith