Modulevector-sized-1.6.1Haskell2010

Data.Vector.Generic.Mutable.Sized

This module reexports the functionality in Data.Vector.Generic.Mutable which maps well to explicitly sized vectors.

Functions returning a vector determine the size from the type context unless they have a ' suffix in which case they take an explicit Proxy argument.

Functions where the resultant vector size is not known until runtime are not exported.

1 type
46 values

Packagevector-sized-1.6.1
Exports47
LanguageHaskell2010
LicenceBSD-3-Clause
SourceSized.hs

newtypenewtype MVector (v :: Type -> Type -> Type) (n :: Nat) s a

A wrapper to tag mutable vectors with a type level length.

Be careful when using the constructor here to not construct sized vectors which have a different length than that specified in the type parameter!

Instances3Data, Storable, NFData

(KnownNat n, Typeable v, Typeable s, Typeable a, Data (v s a)) => Data (MVector v n s a)Defined in vector-sized-1.6.1 · Data.Vector.Generic.Mutable.Sized.Internal
Storable (v s a) => Storable (MVector v n s a)Defined in vector-sized-1.6.1 · Data.Vector.Generic.Mutable.Sized.Internal
NFData (v s a) => NFData (MVector v n s a)Defined in vector-sized-1.6.1 · Data.Vector.Generic.Mutable.Sized.Internal

Accessors

0 declarations

Length information

valuelength :: KnownNat n => MVector v n s a -> Int

O(1) Yield the length of the mutable vector as an Int.

valuelength' :: MVector v n s a -> Proxy n

O(1) Yield the length of the mutable vector as a Proxy.

valuenull :: KnownNat n => MVector v n s a -> Bool

O(1) Check whether the mutable vector is empty.

Extracting subvectors

valueslice

:: (KnownNat i, KnownNat n, MVector v a)
=> p i
starting index
-> MVector v ((i + n) + k) s a
-> MVector v n s a

O(1) Yield a slice of the mutable vector without copying it with an inferred length argument.

valueslice'

:: (KnownNat i, KnownNat n, MVector v a)
=> p i
starting index
-> p n
length
-> MVector v ((i + n) + k) s a
-> MVector v n s a

O(1) Yield a slice of the mutable vector without copying it with an explicit length argument.

valueinit :: MVector v a => MVector v (n + 1) s a -> MVector v n s a

O(1) Yield all but the last element of a non-empty mutable vector without copying.

valuetail :: MVector v a => MVector v (1 + n) s a -> MVector v n s a

O(1) Yield all but the first element of a non-empty mutable vector without copying.

valuetake

:: (KnownNat n, MVector v a)
=> MVector v (n + k) s a
-> MVector v n s a

O(1) Yield the first n elements. The resulting vector always contains this many elements. The length of the resulting vector is inferred from the type.

valuetake'

:: (KnownNat n, MVector v a)
=> p n
-> MVector v (n + k) s a
-> MVector v n s a

O(1) Yield the first n elements. The resulting vector always contains this many elements. The length of the resulting vector is given explicitly as a Proxy argument.

valuedrop

:: (KnownNat n, MVector v a)
=> MVector v (n + k) s a
-> MVector v k s a

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements. The length of the resulting vector is inferred from the type.

valuedrop'

:: (KnownNat n, MVector v a)
=> p n
-> MVector v (n + k) s a
-> MVector v k s a

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements. The length of the resulting vector is given explicitly as a Proxy argument.

valuesplitAt

:: (KnownNat n, MVector v a)
=> MVector v (n + m) s a
-> (MVector v n s a, MVector v m s a)

O(1) Yield the first n elements, paired with the rest, without copying. The lengths of the resulting vectors are inferred from the type.

valuesplitAt'

:: (KnownNat n, MVector v a)
=> p n
-> MVector v (n + m) s a
-> (MVector v n s a, MVector v m s a)

O(1) Yield the first n elements, paired with the rest, without copying. The length of the first resulting vector is passed explicitly as a Proxy argument.

Overlaps

valueoverlaps :: MVector v a => MVector v n s a -> MVector v k s a -> Bool

O(1) Check whether two vectors overlap.

Construction

0 declarations

Initialisation

valuenew :: (KnownNat n, PrimMonad m, MVector v a) => m (MVector v n (PrimState m) a)

Create a mutable vector where the length is inferred from the type.

valueunsafeNew :: (KnownNat n, PrimMonad m, MVector v a) => m (MVector v n (PrimState m) a)

Create a mutable vector where the length is inferred from the type. The memory is not initialized.

valuereplicate

:: (KnownNat n, PrimMonad m, MVector v a)
=> a
-> m (MVector v n (PrimState m) a)

Create a mutable vector where the length is inferred from the type and fill it with an initial value.

valuereplicate'

:: (KnownNat n, PrimMonad m, MVector v a)
=> p n
-> a
-> m (MVector v n (PrimState m) a)

Create a mutable vector where the length is given explicitly as a Proxy argument and fill it with an initial value.

valuereplicateM

:: (KnownNat n, PrimMonad m, MVector v a)
=> m a
-> m (MVector v n (PrimState m) a)

Create a mutable vector where the length is inferred from the type and fill it with values produced by repeatedly executing the monadic action.

valuereplicateM'

:: (KnownNat n, PrimMonad m, MVector v a)
=> p n
-> m a
-> m (MVector v n (PrimState m) a)

Create a mutable vector where the length is given explicitly as a Proxy argument and fill it with values produced by repeatedly executing the monadic action.

valueclone

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> m (MVector v n (PrimState m) a)

Create a copy of a mutable vector.

Growing

valuegrow

:: (KnownNat k, PrimMonad m, MVector v a)
=> p k
-> MVector v n (PrimState m) a
-> m (MVector v (n + k) (PrimState m) a)

Grow a mutable vector by an amount given explicitly as a Proxy argument.

valuegrowFront

:: (KnownNat k, PrimMonad m, MVector v a)
=> p k
-> MVector v n (PrimState m) a
-> m (MVector v (n + k) (PrimState m) a)

Grow a mutable vector (from the front) by an amount given explicitly as a Proxy argument.

Restricting memory usage

valueclear :: (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> m ()

Reset all elements of the vector to some undefined value, clearing all references to external objects.

Accessing individual elements

14 declarations

valueread

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Finite n
-> m a

O(1) Yield the element at a given type-safe position using Finite.

valueread'

:: (KnownNat k, PrimMonad m, MVector v a)
=> MVector v ((n + k) + 1) (PrimState m) a
-> p k
-> m a

O(1) Yield the element at a given type-safe position using Proxy.

valuewrite

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Finite n
-> a
-> m ()

O(1) Replace the element at a given type-safe position using Finite.

valuewrite'

:: (KnownNat k, PrimMonad m, MVector v a)
=> MVector v ((n + k) + 1) (PrimState m) a
-> p k
-> a
-> m ()

O(1) Replace the element at a given type-safe position using Proxy.

valuemodify

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> a -> a
-> Finite n
-> m ()

O(1) Modify the element at a given type-safe position using Finite.

valuemodify'

:: (KnownNat k, PrimMonad m, MVector v a)
=> MVector v ((n + k) + 1) (PrimState m) a
-> a -> a
-> p k
-> m ()

O(1) Modify the element at a given type-safe position using Proxy.

valueswap

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Finite n
-> Finite n
-> m ()

O(1) Swap the elements at given type-safe positions using Finites.

valueexchange

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Finite n
-> a
-> m a

O(1) Replace the element at a given type-safe position and return the old element, using Finite.

valueexchange'

:: (KnownNat k, PrimMonad m, MVector v a)
=> MVector v ((n + k) + 1) (PrimState m) a
-> p k
-> a
-> m a

O(1) Replace the element at a given type-safe position and return the old element, using Finite.

valueunsafeRead

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Int
-> m a

O(1) Yield the element at a given Int position without bounds checking.

valueunsafeWrite

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Int
-> a
-> m ()

O(1) Replace the element at a given Int position without bounds checking.

valueunsafeModify

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> a -> a
-> Int
-> m ()

O(1) Modify the element at a given Int position without bounds checking.

valueunsafeSwap

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Int
-> Int
-> m ()

O(1) Swap the elements at given Int positions without bounds checking.

valueunsafeExchange

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> Int
-> a
-> m a

O(1) Replace the element at a given Int position and return the old element. No bounds checks are performed.

Modifying vectors

1 declaration

valuenextPermutation

:: (Ord e, PrimMonad m, MVector v e)
=> MVector v n (PrimState m) e
-> m Bool

Compute the next permutation (in lexicographic order) of a given vector in-place. Returns False when the input is the last permutation.

Filling and copying

valueset

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
-> a
-> m ()

Set all elements of the vector to the given value.

valuecopy

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
target
-> MVector v n (PrimState m) a
source
-> m ()

Copy a vector. The two vectors may not overlap.

valuemove

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
target
-> MVector v n (PrimState m) a
source
-> m ()

Move the contents of a vector. If the two vectors do not overlap, 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.

valueunsafeCopy

:: (PrimMonad m, MVector v a)
=> MVector v n (PrimState m) a
target
-> MVector v n (PrimState m) a
source
-> m ()

Copy a vector. The two vectors may not overlap. This is not checked.

Conversions

0 declarations

Unsized Mutable Vectors

valuetoSized :: (MVector v a, KnownNat n) => v s a -> Maybe (MVector v n s a)

Convert a MVector into a MVector if it has the correct size, otherwise return Nothing.

Note that this does no copying; the returned MVector is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given MVector.

valuewithSized

:: MVector v a
=> v s a
-> forall (n :: Nat). KnownNat n => MVector v n s a -> r
-> r

Takes a MVector and returns a continuation providing a MVector with a size parameter n that is determined at runtime based on the length of the input vector.

Essentially converts a MVector into a MVector with the correct size parameter n.

Note that this does no copying; the returned MVector is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given MVector.

valuefromSized :: MVector v n s a -> v s a

Convert a MVector into a MVector.

Note that this does no copying; the returned MVector is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given MVector.