Data.Primitive.Contiguous

Documentation

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

A contiguous array of elements.

Associated Types

type Mutable arr = (r :: Type -> Type -> Type) | r -> arr

type Element arr :: Type -> Constraint

Methods

empty :: arr a

null :: arr b -> Bool

new :: (PrimMonad m, Element arr b) => Int -> m (Mutable arr (PrimState m) b)

replicateM :: (PrimMonad m, Element arr b) => Int -> b -> m (Mutable arr (PrimState m) b)

index :: Element arr b => arr b -> Int -> b

index# :: Element arr b => arr b -> Int -> (#b#)

indexM :: (Element arr b, Monad m) => arr b -> Int -> m b

read :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> m b

write :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> b -> m ()

resize :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> m (Mutable arr (PrimState m) b)

size :: Element arr b => arr b -> Int

sizeMutable :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> m Int

unsafeFreeze :: PrimMonad m => Mutable arr (PrimState m) b -> m (arr b)

thaw :: (PrimMonad m, Element arr b) => arr b -> Int -> Int -> m (Mutable arr (PrimState m) b)

copy :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> arr b -> Int -> Int -> m ()

copyMutable :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> Mutable arr (PrimState m) b -> Int -> Int -> m ()

clone :: Element arr b => arr b -> Int -> Int -> arr b

cloneMutable :: (PrimMonad m, Element arr b) => Mutable arr (PrimState m) b -> Int -> Int -> m (Mutable arr (PrimState m) b)

equals :: (Element arr b, Eq b) => arr b -> arr b -> Bool

unlift :: arr b -> ArrayArray#

lift :: ArrayArray# -> arr b

sameMutable :: Mutable arr s a -> Mutable arr s a -> Bool

singleton :: Element arr a => a -> arr a

doubleton :: Element arr a => a -> a -> arr a

tripleton :: Element arr a => a -> a -> a -> arr a

rnf :: (NFData a, Element arr a) => arr a -> ()

Instances

Contiguous UnliftedArray

Defined in Data.Primitive.Contiguous

Associated Types

type Mutable UnliftedArray = (r :: Type -> Type -> Type)

type Element UnliftedArray :: Type -> Constraint

Methods

empty :: UnliftedArray a

null :: UnliftedArray b -> Bool

new :: (PrimMonad m, Element UnliftedArray b) => Int -> m (Mutable UnliftedArray (PrimState m) b)

replicateM :: (PrimMonad m, Element UnliftedArray b) => Int -> b -> m (Mutable UnliftedArray (PrimState m) b)

index :: Element UnliftedArray b => UnliftedArray b -> Int -> b

index# :: Element UnliftedArray b => UnliftedArray b -> Int -> (#b#)

indexM :: (Element UnliftedArray b, Monad m) => UnliftedArray b -> Int -> m b

read :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> Int -> m b

write :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> Int -> b -> m ()

resize :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> Int -> m (Mutable UnliftedArray (PrimState m) b)

size :: Element UnliftedArray b => UnliftedArray b -> Int

sizeMutable :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> m Int

unsafeFreeze :: PrimMonad m => Mutable UnliftedArray (PrimState m) b -> m (UnliftedArray b)

thaw :: (PrimMonad m, Element UnliftedArray b) => UnliftedArray b -> Int -> Int -> m (Mutable UnliftedArray (PrimState m) b)

copy :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> Int -> UnliftedArray b -> Int -> Int -> m ()

copyMutable :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> Int -> Mutable UnliftedArray (PrimState m) b -> Int -> Int -> m ()

clone :: Element UnliftedArray b => UnliftedArray b -> Int -> Int -> UnliftedArray b

cloneMutable :: (PrimMonad m, Element UnliftedArray b) => Mutable UnliftedArray (PrimState m) b -> Int -> Int -> m (Mutable UnliftedArray (PrimState m) b)

equals :: (Element UnliftedArray b, Eq b) => UnliftedArray b -> UnliftedArray b -> Bool

unlift :: UnliftedArray b -> ArrayArray#

lift :: ArrayArray# -> UnliftedArray b

sameMutable :: Mutable UnliftedArray s a -> Mutable UnliftedArray s a -> Bool

singleton :: Element UnliftedArray a => a -> UnliftedArray a

doubleton :: Element UnliftedArray a => a -> a -> UnliftedArray a

tripleton :: Element UnliftedArray a => a -> a -> a -> UnliftedArray a

rnf :: (NFData a, Element UnliftedArray a) => UnliftedArray a -> ()

Contiguous PrimArray

Defined in Data.Primitive.Contiguous

Associated Types

type Mutable PrimArray = (r :: Type -> Type -> Type)

type Element PrimArray :: Type -> Constraint

Methods

empty :: PrimArray a

null :: PrimArray b -> Bool

new :: (PrimMonad m, Element PrimArray b) => Int -> m (Mutable PrimArray (PrimState m) b)

replicateM :: (PrimMonad m, Element PrimArray b) => Int -> b -> m (Mutable PrimArray (PrimState m) b)

index :: Element PrimArray b => PrimArray b -> Int -> b

index# :: Element PrimArray b => PrimArray b -> Int -> (#b#)

indexM :: (Element PrimArray b, Monad m) => PrimArray b -> Int -> m b

read :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> Int -> m b

write :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> Int -> b -> m ()

resize :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> Int -> m (Mutable PrimArray (PrimState m) b)

size :: Element PrimArray b => PrimArray b -> Int

sizeMutable :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> m Int

unsafeFreeze :: PrimMonad m => Mutable PrimArray (PrimState m) b -> m (PrimArray b)

thaw :: (PrimMonad m, Element PrimArray b) => PrimArray b -> Int -> Int -> m (Mutable PrimArray (PrimState m) b)

copy :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> Int -> PrimArray b -> Int -> Int -> m ()

copyMutable :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> Int -> Mutable PrimArray (PrimState m) b -> Int -> Int -> m ()

clone :: Element PrimArray b => PrimArray b -> Int -> Int -> PrimArray b

cloneMutable :: (PrimMonad m, Element PrimArray b) => Mutable PrimArray (PrimState m) b -> Int -> Int -> m (Mutable PrimArray (PrimState m) b)

equals :: (Element PrimArray b, Eq b) => PrimArray b -> PrimArray b -> Bool

unlift :: PrimArray b -> ArrayArray#

lift :: ArrayArray# -> PrimArray b

sameMutable :: Mutable PrimArray s a -> Mutable PrimArray s a -> Bool

singleton :: Element PrimArray a => a -> PrimArray a

doubleton :: Element PrimArray a => a -> a -> PrimArray a

tripleton :: Element PrimArray a => a -> a -> a -> PrimArray a

rnf :: (NFData a, Element PrimArray a) => PrimArray a -> ()

Contiguous Array

Defined in Data.Primitive.Contiguous

Associated Types

type Mutable Array = (r :: Type -> Type -> Type)

type Element Array :: Type -> Constraint

Methods

empty :: Array a

null :: Array b -> Bool

new :: (PrimMonad m, Element Array b) => Int -> m (Mutable Array (PrimState m) b)

replicateM :: (PrimMonad m, Element Array b) => Int -> b -> m (Mutable Array (PrimState m) b)

index :: Element Array b => Array b -> Int -> b

index# :: Element Array b => Array b -> Int -> (#b#)

indexM :: (Element Array b, Monad m) => Array b -> Int -> m b

read :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> Int -> m b

write :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> Int -> b -> m ()

resize :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> Int -> m (Mutable Array (PrimState m) b)

size :: Element Array b => Array b -> Int

sizeMutable :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> m Int

unsafeFreeze :: PrimMonad m => Mutable Array (PrimState m) b -> m (Array b)

thaw :: (PrimMonad m, Element Array b) => Array b -> Int -> Int -> m (Mutable Array (PrimState m) b)

copy :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> Int -> Array b -> Int -> Int -> m ()

copyMutable :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> Int -> Mutable Array (PrimState m) b -> Int -> Int -> m ()

clone :: Element Array b => Array b -> Int -> Int -> Array b

cloneMutable :: (PrimMonad m, Element Array b) => Mutable Array (PrimState m) b -> Int -> Int -> m (Mutable Array (PrimState m) b)

equals :: (Element Array b, Eq b) => Array b -> Array b -> Bool

unlift :: Array b -> ArrayArray#

lift :: ArrayArray# -> Array b

sameMutable :: Mutable Array s a -> Mutable Array s a -> Bool

singleton :: Element Array a => a -> Array a

doubleton :: Element Array a => a -> a -> Array a

tripleton :: Element Array a => a -> a -> a -> Array a

rnf :: (NFData a, Element Array a) => Array a -> ()

class Always a

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

Instances

Always a

Defined in Data.Primitive.Contiguous

append :: (Contiguous arr, Element arr a) => arr a -> arr a -> arr a

map :: (Contiguous arr1, Element arr1 b, Contiguous arr2, Element arr2 c) => (b -> c) -> arr1 b -> arr2 c

Map over the elements of an array.

map' :: (Contiguous arr1, Element arr1 b, Contiguous arr2, Element arr2 c) => (b -> c) -> arr1 b -> arr2 c

Map strictly over the elements of an array.

imap :: (Contiguous arr1, Element arr1 b, Contiguous arr2, Element arr2 c) => (Int -> b -> c) -> arr1 b -> arr2 c

Map over the elements of an array with the index.

mapMutable' :: (PrimMonad m, Contiguous arr, Element arr a) => (a -> a) -> Mutable arr (PrimState m) a -> m ()

Strictly map over a mutable array, modifying the elements in place.

imapMutable' :: (PrimMonad m, Contiguous arr, Element arr a) => (Int -> a -> a) -> Mutable arr (PrimState m) a -> m ()

Strictly map over a mutable array with indices, modifying the elements in place.

foldr :: (Contiguous arr, Element arr a) => (a -> b -> b) -> b -> arr a -> b

Right fold over the element of an array.

foldMap :: (Contiguous arr, Element arr a, Monoid m) => (a -> m) -> arr a -> m

Monoidal fold over the element of an array.

foldl' :: (Contiguous arr, Element arr a) => (b -> a -> b) -> b -> arr a -> b

Strict left fold over the elements of an array.

foldr' :: (Contiguous arr, Element arr a) => (a -> b -> b) -> b -> arr a -> b

Strict right fold over the elements of an array.

foldMap' :: (Contiguous arr, Element arr a, Monoid m) => (a -> m) -> arr a -> m

Strict monoidal fold over the elements of an array.

foldlM' :: (Contiguous arr, Element arr a, Monad m) => (b -> a -> m b) -> b -> arr a -> m b

Strict left monadic fold over the elements of an array.

traverse :: (Contiguous arr, Element arr a, Element arr b, Applicative f) => (a -> f b) -> arr a -> f (arr b)

traverseP :: (PrimMonad m, Contiguous arr1, Contiguous arr2, Element arr1 a, Element arr2 b) => (a -> m b) -> arr1 a -> m (arr2 b)

traverse_ :: (Contiguous arr, Element arr a, Applicative f) => (a -> f b) -> arr a -> f ()

itraverse_ :: (Contiguous arr, Element arr a, Applicative f) => (Int -> a -> f b) -> arr a -> f ()

unsafeFromListN

Arguments

:: (Contiguous arr, Element arr a)

=> Int

length of list

-> [a]

list

-> arr a

Create an array from a list. If the given length does not match the actual length, this function has undefined behavior.

unsafeFromListReverseN :: (Contiguous arr, Element arr a) => Int -> [a] -> arr a

Create an array from a list, reversing the order of the elements. If the given length does not match the actual length, this function has undefined behavior.

liftHashWithSalt :: (Contiguous arr, Element arr a) => (Int -> a -> Int) -> Int -> arr a -> Int

same :: Contiguous arr => arr a -> arr a -> Bool

This function does not behave deterministically. Optimization level and inlining can affect its results. However, the one thing that can be counted on is that if it returns True, the two immutable arrays are definitely the same. This is useful as shortcut for equality tests. However, keep in mind that a result of False tells us nothing about the arguments.