Modulecontiguous-0.6.4.2Haskell2010

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

Instances5Contiguous

Contiguous ArrayDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
Contiguous PrimArrayDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
Contiguous SmallArrayDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
Contiguous (UnliftedArray_ unlifted_a)Defined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
ContiguousU arr => Contiguous (Slice arr)Defined in contiguous-0.6.4.2 · 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.4.2 · Data.Primitive.Contiguous.Class
type Element (Slice arr) = Element arrDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
type Mutable (Slice arr) = MutableSlice arrDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
type MutableSliced (Slice arr) = MutableSlice arrDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
type Sliced (Slice arr) = Slice arrDefined in contiguous-0.6.4.2 · 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.
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).

Instances4ContiguousU

ContiguousU ArrayDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
ContiguousU PrimArrayDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
ContiguousU SmallArrayDefined in contiguous-0.6.4.2 · Data.Primitive.Contiguous.Class
ContiguousU (UnliftedArray_ unlifted_a)Defined in contiguous-0.6.4.2 · 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.4.2 · Data.Primitive.Contiguous.Class