Modulecontiguous-0.6.5.0Haskell2010

Data.Primitive.Contiguous.Class

The Contiguous typeclass parameterises over a contiguous array type. It provides the core primitives necessary to implement the common API in Data.Primitive.Contiguous. This allows us to have a common API to a number of contiguous array types and their mutable counterparts.

2 types
3 classes

Packagecontiguous-0.6.5.0
Exports5
LanguageHaskell2010
LicenceBSD-3-Clause
SourceClass.hs

classclass Contiguous (arr :: Type -> Type) where

The Contiguous typeclass as an interface to a multitude of contiguous structures.

Some functions do not make sense on slices; for those, see ContiguousU.

Associated types

type family Mutable (arr :: Type -> Type) :: Type -> Type -> Type
The Mutable counterpart to the array.
type family Element (arr :: Type -> Type) :: Type -> Constraint
The constraint needed to store elements in the array.
type family Sliced (arr :: Type -> Type) :: Type -> Type
The slice type of this array. The slice of a raw array type t should be 'Slice t', whereas the slice of a slice should be the same slice type.
type family MutableSliced (arr :: Type -> Type) :: Type -> Type -> Type
The mutable slice type of this array. The mutable slice of a raw array type t should be 'MutableSlice t', whereas the mutable slice of a mutable slice should be the same slice type.

Methods

new :: (PrimMonad m, Element arr b) => Int -> m (Mutable arr (PrimState m) b)
Allocate a new mutable array of the given size.
replicateMut :: (PrimMonad m, Element arr b) => Int -> b -> m (Mutable arr (PrimState m) b)
replicateMut n x is a mutable array of length n with x the value of every element.
shrink :: (PrimMonad m, Element arr a) => Mutable arr (PrimState m) a -> Int -> m (Mutable arr (PrimState m) a)
Resize an array without growing it. It may be shrunk in place.
empty :: arr a
The empty array.
singleton :: Element arr a => a -> arr a
Create a singleton array.
doubleton :: Element arr a => a -> a -> arr a
Create a doubleton array.
tripleton :: Element arr a => a -> a -> a -> arr a
Create a tripleton array.
quadrupleton :: Element arr a => a -> a -> a -> a -> arr a
Create a quadrupleton array.
quintupleton :: Element arr a => a -> a -> a -> a -> a -> arr a
Create a quintupleton array.
sextupleton :: Element arr a => a -> a -> a -> a -> a -> a -> arr a
Create a sextupleton array.
index :: Element arr b => arr b -> Int -> b
Index into an array at the given index.
index# :: Element arr b => arr b -> Int -> (# b #)
Index into an array at the given index, yielding an unboxed one-tuple of the element.
indexM :: (Element arr b, Monad m) => arr b -> Int -> m b
Indexing in a monad.
The monad allows operations to be strict in the array when necessary. Suppose array copying is implemented like this:
```
copy mv v = ... write mv i (v ! i) ...
```
For lazy arrays, v ! i would not be not be evaluated, which means that mv would unnecessarily retain a reference to v in each element written.
With indexM, copying can be implemented like this instead:
```
copy mv v = ... do
  x <- indexM v i
  write mv i x
```
Here, no references to v are retained because indexing (but not the elements) is evaluated eagerly.
read :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> m b
Read a mutable array at the given index.
write :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> b -> m ()
Write to a mutable array at the given index.
null :: arr b -> Bool
Test whether the array is empty.
size :: Element arr b => arr b -> Int
The size of the array
sizeMut :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> m Int
The size of the mutable array
equals :: (Element arr b, Eq b) => arr b -> arr b -> Bool
Test the two arrays for equality.
equalsMut :: Mutable arr s a -> Mutable arr s a -> Bool
Test the two mutable arrays for pointer equality. Does not check equality of elements.
slice :: Element arr a => arr a -> Int -> Int -> Sliced arr a
Create a Slice of an array.
O(1).
sliceMut :: Element arr a => Mutable arr s a -> Int -> Int -> MutableSliced arr s a
Create a MutableSlice of a mutable array.
O(1).
toSlice :: Element arr a => arr a -> Sliced arr a
Create a Slice that covers the entire array.
toSliceMut :: (PrimMonad m, Element arr a) => Mutable arr (PrimState m) a -> m (MutableSliced arr (PrimState m) a)
Create a MutableSlice that covers the entire array.
clone :: Element arr b => Sliced arr b -> arr b
Clone a slice of an array.
clone_ :: Element arr a => arr a -> Int -> Int -> arr a
Clone a slice of an array without using the Slice type. These methods are required to implement 'Contiguous (Slice arr)' for any `Contiguous arr`; they are not really meant for direct use.
cloneMut :: (PrimMonad m, Element arr b) => MutableSliced arr (PrimState m) b -> m (Mutable arr (PrimState m) b)
Clone a slice of a mutable array.
cloneMut_ :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> Int -> m (Mutable arr (PrimState m) b)
Clone a slice of a mutable array without using the MutableSlice type. These methods are required to implement 'Contiguous (Slice arr)' for any `Contiguous arr`; they are not really meant for direct use.
freeze :: (PrimMonad m, Element arr a) => MutableSliced arr (PrimState m) a -> m (arr a)
Turn a mutable array slice an immutable array by copying.
freeze_ :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> Int -> m (arr b)
Turn a slice of a mutable array into an immutable one with copying, without using the MutableSlice type. These methods are required to implement 'Contiguous (Slice arr)' for any `Contiguous arr`; they are not really meant for direct use.
unsafeFreeze :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> m (arr b)
Turn a mutable array into an immutable one without copying. The mutable array should not be used after this conversion.
unsafeShrinkAndFreeze :: (PrimMonad m, Element arr a) => Mutable arr (PrimState m) a -> Int -> m (arr a)
thaw :: (PrimMonad m, Element arr b) => Sliced arr b -> m (Mutable arr (PrimState m) b)
Copy a slice of an immutable array into a new mutable array.
thaw_ :: (PrimMonad m, Element arr b) => arr b -> Int -> Int -> m (Mutable arr (PrimState m) b)
Copy a slice of an immutable array into a new mutable array without using the Slice type. These methods are required to implement 'Contiguous (Slice arr)' for any `Contiguous arr`; they are not really meant for direct use.
copy :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> Sliced arr b -> m ()
Copy a slice of an array into a mutable array.
copy_ :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> arr b -> Int -> Int -> m ()
Copy a slice of an array into a mutable array without using the Slice type. These methods are required to implement 'Contiguous (Slice arr)' for any `Contiguous arr`; they are not really meant for direct use.
copyMut :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> MutableSliced arr (PrimState m) b -> m ()
Copy a slice of a mutable array into another mutable array. In the case that the destination and source arrays are the same, the regions may overlap.
copyMut_ :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> Mutable arr (PrimState m) b -> Int -> Int -> m ()
Copy a slice of a mutable array into another mutable array without using the Slice type. These methods are required to implement 'Contiguous (Slice arr)' for any `Contiguous arr`; they are not really meant for direct use.
insertAt :: Element arr b => arr b -> Int -> b -> arr b
Copy a slice of an array and then insert an element into that array.
The default implementation performs a memset which would be unnecessary except that the garbage collector might trace the uninitialized array.
Was previously insertSlicing @since 0.6.0
rnf :: (NFData a, Element arr a) => arr a -> ()
Reduce the array and all of its elements to WHNF.
run :: (forall s. ST s (arr a)) -> arr a
Run an effectful computation that produces an array.

Instances6Contiguous

Contiguous ArrayDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
Contiguous PrimArrayDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
Contiguous SmallArrayDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
Contiguous (UnliftedArray_ unlifted_a)Defined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
Contiguous (SmallUnliftedArray_ unlifted_a)Defined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
ContiguousU arr => Contiguous (Slice arr)Defined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class

datadata Slice (arr :: Type -> Type) a

Slices of immutable arrays: packages an offset and length with a backing array.

Constructors

Slice
- offset :: !Int
- length :: !Int
- base :: !Unlifted arr a

Instances5Contiguous, Element, Mutable, MutableSliced, Sliced

ContiguousU arr => Contiguous (Slice arr)Defined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
type Element (Slice arr) = Element arrDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
type Mutable (Slice arr) = MutableSlice arrDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
type MutableSliced (Slice arr) = MutableSlice arrDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
type Sliced (Slice arr) = Slice arrDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class

datadata MutableSlice (arr :: Type -> Type) s a

Slices of mutable arrays: packages an offset and length with a mutable backing array.

Constructors

MutableSlice
- offsetMut :: !Int
- lengthMut :: !Int
- baseMut :: !UnliftedMut arr s a

classclass Contiguous arr => ContiguousU (arr :: Type -> Type) where

The ContiguousU typeclass is an extension of the Contiguous typeclass, but includes operations that make sense only on unsliced contiguous structures.

Associated types

type family Unlifted (arr :: Type -> Type) :: Type -> UnliftedType
The unifted version of the immutable array type (i.e. eliminates an indirection through a thunk).
type family UnliftedMut (arr :: Type -> Type) :: Type -> Type -> UnliftedType
The unifted version of the mutable array type (i.e. eliminates an indirection through a thunk).

Methods

resize :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> m (Mutable arr (PrimState m) b)
Resize an array into one with the given size. If the array is grown, then reading from any newly introduced element before writing to it is undefined behavior. The current behavior is that anything backed by MutableByteArray# ends with uninitialized memory at these indices. But for SmallMutableArray or Array, these are set to an error thunk, so reading from them and forcing the result causes the program to crash. For UnliftedArray, the new elements have undefined values of an unknown type. If the array is not grown, it may (or may not) be modified in place.
unlift :: arr b -> Unlifted arr b
Unlift an array (i.e. point to the data without an intervening thunk).
unliftMut :: Mutable arr s b -> UnliftedMut arr s b
Unlift a mutable array (i.e. point to the data without an intervening thunk).
lift :: Unlifted arr b -> arr b
Lift an array (i.e. point to the data through an intervening thunk).
liftMut :: UnliftedMut arr s b -> Mutable arr s b
Lift a mutable array (i.e. point to the data through an intervening thunk).

Instances5ContiguousU

ContiguousU ArrayDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
ContiguousU PrimArrayDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
ContiguousU SmallArrayDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
ContiguousU (UnliftedArray_ unlifted_a)Defined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class
ContiguousU (SmallUnliftedArray_ unlifted_a)Defined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class

classclass Always a

A typeclass that is satisfied by all types. This is used used to provide a fake constraint for Array and SmallArray.

Instances1Always

Always aDefined in contiguous-0.6.5.0 · Data.Primitive.Contiguous.Class