Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- unsafeIndex :: Unbox a => Vector a -> Int -> a
- unsafeHead :: Unbox a => Vector a -> a
- unsafeLast :: Unbox a => Vector a -> a
- unsafeIndexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
- unsafeHeadM :: (Unbox a, Monad m) => Vector a -> m a
- unsafeLastM :: (Unbox a, Monad m) => Vector a -> m a
- unsafeSlice :: Unbox a => Int -> Int -> Vector a -> Vector a
- unsafeInit :: Unbox a => Vector a -> Vector a
- unsafeTail :: Unbox a => Vector a -> Vector a
- unsafeTake :: Unbox a => Int -> Vector a -> Vector a
- unsafeDrop :: Unbox a => Int -> Vector a -> Vector a
- unsafeUpd :: Unbox a => Vector a -> [(Int, a)] -> Vector a
- unsafeUpdate :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
- unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
- unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
- unsafeAccumulate :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
- unsafeAccumulate_ :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a
- unsafeFreeze :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
- unsafeThaw :: (Unbox a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
- unsafeCopy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()

# 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

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