Modulelinear-base-0.4.0Haskell2010

Data.Vector.Mutable.Linear

Mutable vectors with a linear API.

Vectors are arrays that grow automatically, that you can append to with push. They never shrink automatically to reduce unnecessary copying, use shrinkToFit to get rid of the wasted space.

To use mutable vectors, create a linear computation of type Vector a %1-> Ur b and feed it to constant or fromList.

Example

Example4 expressions

>>> :set -XLinearTypes>>> import Prelude.Linear>>> import qualified Data.Vector.Mutable.Linear as Vector>>> :{ isFirstZero :: Vector.Vector Int %1-> Ur Bool isFirstZero vec =   Vector.get 0 vec     & \(Ur ret, vec) -> vec `lseq` Ur (ret == 0):}

Example2 expressions

>>> unur $ Vector.fromList [0..10] isFirstZeroTrue>>> unur $ Vector.fromList [1,2,3] isFirstZeroFalse

1 type
23 values

Packagelinear-base-0.4.0
Exports24
LanguageHaskell2010
LicenceMIT
SourceLinear.hs

A mutable vector

1 declaration

datadata Vector a where

A dynamic mutable vector.

Instances5Functor, Consumable, Dupable, Semigroup

Functor VectorDefined in linear-base-0.4.0 · Data.Vector.Mutable.Linear.Internal
Semigroup (Vector a)Defined in linear-base-0.4.0 · Data.Vector.Mutable.Linear.Internal
Consumable (Vector a)Defined in linear-base-0.4.0 · Data.Vector.Mutable.Linear.Internal
Dupable (Vector a)Defined in linear-base-0.4.0 · Data.Vector.Mutable.Linear.Internal
Semigroup (Vector a)Defined in linear-base-0.4.0 · Data.Vector.Mutable.Linear.Internal

Run a computation with a vector

3 declarations

valueempty :: (Vector a %1 -> Ur b) %1 -> Ur b

valueconstant :: HasCallStack => Int -> a -> (Vector a %1 -> Ur b) %1 -> Ur b

Allocate a constant vector of a given non-negative size (and error on a bad size)

valuefromList :: HasCallStack => [a] -> (Vector a %1 -> Ur b) %1 -> Ur b

Allocator from a list

Mutators

10 declarations

valueset :: HasCallStack => Int -> a -> Vector a %1 -> Vector a

Write to an element . Note: this will not write to elements beyond the current size of the vector and will error instead.

valueunsafeSet :: HasCallStack => Int -> a -> Vector a %1 -> Vector a

Same as write, but does not do bounds-checking. The behaviour is undefined when passed an invalid index.

valuemodify

:: HasCallStack
=> a -> (a, b)
-> Int
-> Vector a
-> (Ur b, Vector a)

Modify a value inside a vector, with an ability to return an extra information. Errors if the index is out of bounds.

valuemodify_ :: HasCallStack => (a -> a) -> Int -> Vector a %1 -> Vector a

Same as modify, but without the ability to return extra information.

valuepush :: a -> Vector a %1 -> Vector a

Insert at the end of the vector. This will grow the vector if there is no empty space.

valuepop :: Vector a %1 -> (Ur (Maybe a), Vector a)

Pop from the end of the vector. This will never shrink the vector, use shrinkToFit to remove the wasted space.

valuefilter :: Vector a %1 -> (a -> Bool) -> Vector a

Filters the vector in-place. It does not deallocate unused capacity, use shrinkToFit for that if necessary.

valuemapMaybe :: Vector a %1 -> (a -> Maybe b) -> Vector b

A version of fmap which can throw out elements.

valueslice :: Int -> Int -> Vector a %1 -> Vector a

Return a slice of the vector with given size, starting from an offset.

Start offset + target size should be within the input vector, and both should be non-negative.

This is a constant time operation if the start offset is 0. Use shrinkToFit to remove the possible wasted space if necessary.

valueshrinkToFit :: Vector a %1 -> Vector a

Resize the vector to not have any wasted memory (size == capacity). This returns a semantically identical vector.

Accessors

6 declarations

valueget :: HasCallStack => Int -> Vector a %1 -> (Ur a, Vector a)

Read from a vector, with an in-range index and error for an index that is out of range (with the usual range 0..size-1).

valueunsafeGet :: HasCallStack => Int -> Vector a %1 -> (Ur a, Vector a)

Same as read, but does not do bounds-checking. The behaviour is undefined when passed an invalid index.

valuesize :: Vector a %1 -> (Ur Int, Vector a)

Number of elements inside the vector.

This might be different than how much actual memory the vector is using. For that, see: capacity.

valuecapacity :: Vector a %1 -> (Ur Int, Vector a)

Capacity of a vector. In other words, the number of elements the vector can contain before it is copied to a bigger array.

valuetoList :: Vector a %1 -> Ur [a]

Return the vector elements as a lazy list.

valuefreeze :: Vector a %1 -> Ur (Vector a)

O(1) Convert a Vector to an immutable Vector (from vector package).

Mutable-style interface

4 declarations

valueread :: HasCallStack => Vector a %1 -> Int -> (Ur a, Vector a)

Same as get, but takes the Vector as the first parameter.

valueunsafeRead :: Vector a %1 -> Int -> (Ur a, Vector a)

Same as unsafeGet, but takes the Vector as the first parameter.

valuewrite :: HasCallStack => Vector a %1 -> Int -> a -> Vector a

Same as set, but takes the Vector as the first parameter.

valueunsafeWrite :: Vector a %1 -> Int -> a -> Vector a

Same as unsafeSafe, but takes the Vector as the first parameter.