Std.Data.Array

Unified unboxed and boxed array operations using functional dependencies.

All operations are NOT bound checked, if you need checked operations please use Std.Data.Array.Checked. It exports exactly same APIs so that you can switch between without pain.

Some mnemonics:

• newArr, newArrWith return mutable array, readArr, writeArr works on them, setArr fill elements with offset and length.
• indexArr works on immutable one, use indexArr' to avoid indexing thunk.
• The order of arguements of copyArr, copyMutableArr and moveArr are always target and its offset come first, and source and source offset follow, copying length comes last.

Arr typeclass

class Arr (marr :: * -> * -> *) (arr :: * -> *) a | arr -> marr, marr -> arr where

A typeclass to unify box & unboxed, mutable & immutable array operations.

Most of these functions simply wrap their primitive counterpart, if there's no primitive ones, we polyfilled using other operations to get the same semantics.

One exception is that shrinkMutableArr only perform closure resizing on PrimArray because current RTS support only that, shrinkMutableArr will do nothing on other array type.

It's reasonable to trust GHC with specializing & inlining these polymorphric functions. They are used across this package and perform identical to their monomophric counterpart.

Associated Types

type IArr marr = (ar :: * -> *) | ar -> marr

type MArr arr = (mar :: * -> * -> *) | mar -> arr

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (marr s a)

Make a new array with given size.

For boxed array, all elements are uninitialized which shall not be accessed. For primitive array, elements are just random garbage.

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (marr s a)

Make a new array and fill it with an initial value.

readArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> m a

Index mutable array in a primitive monad.

writeArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> a -> m ()

Write mutable array in a primitive monad.

setArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> Int -> a -> m ()

Fill mutable array with a given value.

indexArr :: arr a -> Int -> a

Index immutable array, which is a pure operation. This operation often result in an indexing thunk for lifted arrays, use 'indexArr\'' or indexArrM if that's not desired.

indexArr' :: arr a -> Int -> (#a#)

Index immutable array, pattern match on the unboxed unit tuple to force indexing (without forcing the element).

indexArrM :: Monad m => arr a -> Int -> m a

Index immutable array in a primitive monad, this helps in situations that you want your indexing result is not a thunk referencing whole array.

freezeArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> Int -> m (arr a)

Safely freeze mutable array by make a immutable copy of its slice.

thawArr :: (PrimMonad m, PrimState m ~ s) => arr a -> Int -> Int -> m (marr s a)

Safely thaw immutable array by make a mutable copy of its slice.

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> m (arr a)

In place freeze a mutable array, the original mutable array can not be used anymore.

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => arr a -> m (marr s a)

In place thaw a immutable array, the original immutable array can not be used anymore.

copyArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> arr a -> Int -> Int -> m ()

Copy a slice of immutable array to mutable array at given offset.

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> marr s a -> Int -> Int -> m ()

Copy a slice of mutable array to mutable array at given offset. The two mutable arrays shall no be the same one.

moveArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> marr s a -> Int -> Int -> m ()

Copy a slice of mutable array to mutable array at given offset. The two mutable arrays may be the same one.

cloneArr :: arr a -> Int -> Int -> arr a

Create immutable copy.

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> Int -> m (marr s a)

Create mutable copy.

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> m (marr s a)

Resize mutable array to given size.

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> Int -> m ()

Shrink mutable array to given size. This operation only works on primitive arrays. For boxed array, this is a no-op, e.g. sizeOfMutableArr will not change.

sameMutableArr :: marr s a -> marr s a -> Bool

Is two mutable array are reference equal.

sizeofArr :: arr a -> Int

Size of immutable array.

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => marr s a -> m Int

Size of mutable array.

sameArr :: arr a -> arr a -> Bool

Is two immutable array are referencing the same one.

Note that sameArr 's result may change depending on compiler's optimizations, for example let arr = runST ... in arr sameArr arr may return false if compiler decides to inline it.

See https://ghc.haskell.org/trac/ghc/ticket/13908 for more background.

Instances

Prim a => Arr MutablePrimArray PrimArray a

Defined in Std.Data.Array

Associated Types

type IArr MutablePrimArray = (ar :: Type -> Type)

type MArr PrimArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutablePrimArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutablePrimArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> a -> m ()

indexArr :: PrimArray a -> Int -> a

indexArr' :: PrimArray a -> Int -> (#a#)

indexArrM :: Monad m => PrimArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> m (PrimArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> Int -> Int -> m (MutablePrimArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> m (PrimArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> m (MutablePrimArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> PrimArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> MutablePrimArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> MutablePrimArray s a -> Int -> Int -> m ()

cloneArr :: PrimArray a -> Int -> Int -> PrimArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> m (MutablePrimArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m (MutablePrimArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m ()

sameMutableArr :: MutablePrimArray s a -> MutablePrimArray s a -> Bool

sizeofArr :: PrimArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> m Int

sameArr :: PrimArray a -> PrimArray a -> Bool

Arr MutableArray Array a

Defined in Std.Data.Array

Associated Types

type IArr MutableArray = (ar :: Type -> Type)

type MArr Array = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutableArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutableArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> a -> m ()

indexArr :: Array a -> Int -> a

indexArr' :: Array a -> Int -> (#a#)

indexArrM :: Monad m => Array a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> m (Array a)

thawArr :: (PrimMonad m, PrimState m ~ s) => Array a -> Int -> Int -> m (MutableArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> m (Array a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => Array a -> m (MutableArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Array a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> MutableArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> MutableArray s a -> Int -> Int -> m ()

cloneArr :: Array a -> Int -> Int -> Array a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> m (MutableArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m (MutableArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m ()

sameMutableArr :: MutableArray s a -> MutableArray s a -> Bool

sizeofArr :: Array a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> m Int

sameArr :: Array a -> Array a -> Bool

Arr SmallMutableArray SmallArray a

Defined in Std.Data.Array

Associated Types

type IArr SmallMutableArray = (ar :: Type -> Type)

type MArr SmallArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (SmallMutableArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (SmallMutableArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> a -> m ()

indexArr :: SmallArray a -> Int -> a

indexArr' :: SmallArray a -> Int -> (#a#)

indexArrM :: Monad m => SmallArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> m (SmallArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> Int -> Int -> m (SmallMutableArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> m (SmallArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> m (SmallMutableArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallMutableArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallMutableArray s a -> Int -> Int -> m ()

cloneArr :: SmallArray a -> Int -> Int -> SmallArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> m (SmallMutableArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m (SmallMutableArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m ()

sameMutableArr :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

sizeofArr :: SmallArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> m Int

sameArr :: SmallArray a -> SmallArray a -> Bool

PrimUnlifted a => Arr MutableUnliftedArray UnliftedArray a

Defined in Std.Data.Array

Associated Types

type IArr MutableUnliftedArray = (ar :: Type -> Type)

type MArr UnliftedArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutableUnliftedArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutableUnliftedArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> a -> m ()

indexArr :: UnliftedArray a -> Int -> a

indexArr' :: UnliftedArray a -> Int -> (#a#)

indexArrM :: Monad m => UnliftedArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> m (UnliftedArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => UnliftedArray a -> Int -> Int -> m (MutableUnliftedArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> m (UnliftedArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => UnliftedArray a -> m (MutableUnliftedArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> UnliftedArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> MutableUnliftedArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> MutableUnliftedArray s a -> Int -> Int -> m ()

cloneArr :: UnliftedArray a -> Int -> Int -> UnliftedArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> m (MutableUnliftedArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m (MutableUnliftedArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m ()

sameMutableArr :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

sizeofArr :: UnliftedArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> m Int

sameArr :: UnliftedArray a -> UnliftedArray a -> Bool

data RealWorld :: Type

RealWorld is deeply magical. It is primitive, but it is not unlifted (hence ptrArg). We never manipulate values of type RealWorld; it's only used in the type system, to parameterise State#.

Boxed array type

data Array a

Constructors

Array

Fields

• array# :: Array# a

Instances

Monad Array

Defined in Data.Primitive.Array

Methods

(>>=) :: Array a -> (a -> Array b) -> Array b

(>>) :: Array a -> Array b -> Array b

return :: a -> Array a

fail :: String -> Array a

Functor Array

Defined in Data.Primitive.Array

Methods

fmap :: (a -> b) -> Array a -> Array b

(<$) :: a -> Array b -> Array a

MonadFix Array

Defined in Data.Primitive.Array

Methods

mfix :: (a -> Array a) -> Array a

Applicative Array

Defined in Data.Primitive.Array

Methods

pure :: a -> Array a

(<*>) :: Array (a -> b) -> Array a -> Array b

liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c

(*>) :: Array a -> Array b -> Array b

(<*) :: Array a -> Array b -> Array a

Foldable Array

Defined in Data.Primitive.Array

Methods

fold :: Monoid m => Array m -> m

foldMap :: Monoid m => (a -> m) -> Array a -> m

foldr :: (a -> b -> b) -> b -> Array a -> b

foldr' :: (a -> b -> b) -> b -> Array a -> b

foldl :: (b -> a -> b) -> b -> Array a -> b

foldl' :: (b -> a -> b) -> b -> Array a -> b

foldr1 :: (a -> a -> a) -> Array a -> a

foldl1 :: (a -> a -> a) -> Array a -> a

toList :: Array a -> [a]

null :: Array a -> Bool

length :: Array a -> Int

elem :: Eq a => a -> Array a -> Bool

maximum :: Ord a => Array a -> a

minimum :: Ord a => Array a -> a

sum :: Num a => Array a -> a

product :: Num a => Array a -> a

Traversable Array

Defined in Data.Primitive.Array

Methods

traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b)

sequenceA :: Applicative f => Array (f a) -> f (Array a)

mapM :: Monad m => (a -> m b) -> Array a -> m (Array b)

sequence :: Monad m => Array (m a) -> m (Array a)

Eq1 Array

Defined in Data.Primitive.Array

Methods

liftEq :: (a -> b -> Bool) -> Array a -> Array b -> Bool

Ord1 Array

Defined in Data.Primitive.Array

Methods

liftCompare :: (a -> b -> Ordering) -> Array a -> Array b -> Ordering

Read1 Array

Defined in Data.Primitive.Array

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Array a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Array a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Array a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Array a]

Show1 Array

Defined in Data.Primitive.Array

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Array a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Array a] -> ShowS

MonadZip Array

Defined in Data.Primitive.Array

Methods

mzip :: Array a -> Array b -> Array (a, b)

mzipWith :: (a -> b -> c) -> Array a -> Array b -> Array c

munzip :: Array (a, b) -> (Array a, Array b)

Alternative Array

Defined in Data.Primitive.Array

Methods

empty :: Array a

(<|>) :: Array a -> Array a -> Array a

some :: Array a -> Array [a]

many :: Array a -> Array [a]

MonadPlus Array

Defined in Data.Primitive.Array

Methods

mzero :: Array a

mplus :: Array a -> Array a -> Array a

Arr MutableArray Array a

Defined in Std.Data.Array

Associated Types

type IArr MutableArray = (ar :: Type -> Type)

type MArr Array = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutableArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutableArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> a -> m ()

indexArr :: Array a -> Int -> a

indexArr' :: Array a -> Int -> (#a#)

indexArrM :: Monad m => Array a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> m (Array a)

thawArr :: (PrimMonad m, PrimState m ~ s) => Array a -> Int -> Int -> m (MutableArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> m (Array a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => Array a -> m (MutableArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Array a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> MutableArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> MutableArray s a -> Int -> Int -> m ()

cloneArr :: Array a -> Int -> Int -> Array a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> m (MutableArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m (MutableArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m ()

sameMutableArr :: MutableArray s a -> MutableArray s a -> Bool

sizeofArr :: Array a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> m Int

sameArr :: Array a -> Array a -> Bool

IsList (Array a)

Defined in Data.Primitive.Array

Associated Types

type Item (Array a) :: Type

Methods

fromList :: [Item (Array a)] -> Array a

fromListN :: Int -> [Item (Array a)] -> Array a

toList :: Array a -> [Item (Array a)]

Eq a => Eq (Array a)

Defined in Data.Primitive.Array

Methods

(==) :: Array a -> Array a -> Bool

(/=) :: Array a -> Array a -> Bool

Data a => Data (Array a)

Defined in Data.Primitive.Array

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array a -> c (Array a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a)

toConstr :: Array a -> Constr

dataTypeOf :: Array a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a))

gmapT :: (forall b. Data b => b -> b) -> Array a -> Array a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a -> r

gmapQ :: (forall d. Data d => d -> u) -> Array a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a -> m (Array a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a -> m (Array a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a -> m (Array a)

Ord a => Ord (Array a)

Defined in Data.Primitive.Array

Methods

compare :: Array a -> Array a -> Ordering

(<) :: Array a -> Array a -> Bool

(<=) :: Array a -> Array a -> Bool

(>) :: Array a -> Array a -> Bool

(>=) :: Array a -> Array a -> Bool

max :: Array a -> Array a -> Array a

min :: Array a -> Array a -> Array a

Read a => Read (Array a)

Defined in Data.Primitive.Array

Methods

readsPrec :: Int -> ReadS (Array a)

readList :: ReadS [Array a]

readPrec :: ReadPrec (Array a)

readListPrec :: ReadPrec [Array a]

Show a => Show (Array a)

Defined in Data.Primitive.Array

Methods

showsPrec :: Int -> Array a -> ShowS

show :: Array a -> String

showList :: [Array a] -> ShowS

Semigroup (Array a)

Defined in Data.Primitive.Array

Methods

(<>) :: Array a -> Array a -> Array a

sconcat :: NonEmpty (Array a) -> Array a

stimes :: Integral b => b -> Array a -> Array a

Monoid (Array a)

Defined in Data.Primitive.Array

Methods

mempty :: Array a

mappend :: Array a -> Array a -> Array a

mconcat :: [Array a] -> Array a

PrimUnlifted (Array a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: Array a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> Array a

type MArr Array

Defined in Std.Data.Array

type MArr Array = MutableArray

type Item (Array a)

Defined in Data.Primitive.Array

type Item (Array a) = a

data MutableArray s a

Constructors

MutableArray

Fields

• marray# :: MutableArray# s a

Instances

Arr MutableArray Array a

Defined in Std.Data.Array

Associated Types

type IArr MutableArray = (ar :: Type -> Type)

type MArr Array = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutableArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutableArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> a -> m ()

indexArr :: Array a -> Int -> a

indexArr' :: Array a -> Int -> (#a#)

indexArrM :: Monad m => Array a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> m (Array a)

thawArr :: (PrimMonad m, PrimState m ~ s) => Array a -> Int -> Int -> m (MutableArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> m (Array a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => Array a -> m (MutableArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Array a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> MutableArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> MutableArray s a -> Int -> Int -> m ()

cloneArr :: Array a -> Int -> Int -> Array a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> Int -> m (MutableArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m (MutableArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> Int -> m ()

sameMutableArr :: MutableArray s a -> MutableArray s a -> Bool

sizeofArr :: Array a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableArray s a -> m Int

sameArr :: Array a -> Array a -> Bool

Eq (MutableArray s a)

Defined in Data.Primitive.Array

Methods

(==) :: MutableArray s a -> MutableArray s a -> Bool

(/=) :: MutableArray s a -> MutableArray s a -> Bool

(Typeable s, Typeable a) => Data (MutableArray s a)

Defined in Data.Primitive.Array

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MutableArray s a -> c (MutableArray s a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MutableArray s a)

toConstr :: MutableArray s a -> Constr

dataTypeOf :: MutableArray s a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MutableArray s a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MutableArray s a))

gmapT :: (forall b. Data b => b -> b) -> MutableArray s a -> MutableArray s a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MutableArray s a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MutableArray s a -> r

gmapQ :: (forall d. Data d => d -> u) -> MutableArray s a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MutableArray s a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a)

PrimUnlifted (MutableArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutableArray s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutableArray s a

type IArr MutableArray

Defined in Std.Data.Array

type IArr MutableArray = Array

data SmallArray a

Constructors

SmallArray (SmallArray# a)

Instances

Monad SmallArray

Defined in Data.Primitive.SmallArray

Methods

(>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b

(>>) :: SmallArray a -> SmallArray b -> SmallArray b

return :: a -> SmallArray a

fail :: String -> SmallArray a

Functor SmallArray

Defined in Data.Primitive.SmallArray

Methods

fmap :: (a -> b) -> SmallArray a -> SmallArray b

(<$) :: a -> SmallArray b -> SmallArray a

MonadFix SmallArray

Defined in Data.Primitive.SmallArray

Methods

mfix :: (a -> SmallArray a) -> SmallArray a

Applicative SmallArray

Defined in Data.Primitive.SmallArray

Methods

pure :: a -> SmallArray a

(<*>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b

liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c

(*>) :: SmallArray a -> SmallArray b -> SmallArray b

(<*) :: SmallArray a -> SmallArray b -> SmallArray a

Foldable SmallArray

Defined in Data.Primitive.SmallArray

Methods

fold :: Monoid m => SmallArray m -> m

foldMap :: Monoid m => (a -> m) -> SmallArray a -> m

foldr :: (a -> b -> b) -> b -> SmallArray a -> b

foldr' :: (a -> b -> b) -> b -> SmallArray a -> b

foldl :: (b -> a -> b) -> b -> SmallArray a -> b

foldl' :: (b -> a -> b) -> b -> SmallArray a -> b

foldr1 :: (a -> a -> a) -> SmallArray a -> a

foldl1 :: (a -> a -> a) -> SmallArray a -> a

toList :: SmallArray a -> [a]

null :: SmallArray a -> Bool

length :: SmallArray a -> Int

elem :: Eq a => a -> SmallArray a -> Bool

maximum :: Ord a => SmallArray a -> a

minimum :: Ord a => SmallArray a -> a

sum :: Num a => SmallArray a -> a

product :: Num a => SmallArray a -> a

Traversable SmallArray

Defined in Data.Primitive.SmallArray

Methods

traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b)

sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a)

mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b)

sequence :: Monad m => SmallArray (m a) -> m (SmallArray a)

Eq1 SmallArray

Defined in Data.Primitive.SmallArray

Methods

liftEq :: (a -> b -> Bool) -> SmallArray a -> SmallArray b -> Bool

Ord1 SmallArray

Defined in Data.Primitive.SmallArray

Methods

liftCompare :: (a -> b -> Ordering) -> SmallArray a -> SmallArray b -> Ordering

Read1 SmallArray

Defined in Data.Primitive.SmallArray

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (SmallArray a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [SmallArray a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (SmallArray a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [SmallArray a]

Show1 SmallArray

Defined in Data.Primitive.SmallArray

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SmallArray a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [SmallArray a] -> ShowS

MonadZip SmallArray

Defined in Data.Primitive.SmallArray

Methods

mzip :: SmallArray a -> SmallArray b -> SmallArray (a, b)

mzipWith :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c

munzip :: SmallArray (a, b) -> (SmallArray a, SmallArray b)

Alternative SmallArray

Defined in Data.Primitive.SmallArray

Methods

empty :: SmallArray a

(<|>) :: SmallArray a -> SmallArray a -> SmallArray a

some :: SmallArray a -> SmallArray [a]

many :: SmallArray a -> SmallArray [a]

MonadPlus SmallArray

Defined in Data.Primitive.SmallArray

Methods

mzero :: SmallArray a

mplus :: SmallArray a -> SmallArray a -> SmallArray a

Arr SmallMutableArray SmallArray a

Defined in Std.Data.Array

Associated Types

type IArr SmallMutableArray = (ar :: Type -> Type)

type MArr SmallArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (SmallMutableArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (SmallMutableArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> a -> m ()

indexArr :: SmallArray a -> Int -> a

indexArr' :: SmallArray a -> Int -> (#a#)

indexArrM :: Monad m => SmallArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> m (SmallArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> Int -> Int -> m (SmallMutableArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> m (SmallArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> m (SmallMutableArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallMutableArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallMutableArray s a -> Int -> Int -> m ()

cloneArr :: SmallArray a -> Int -> Int -> SmallArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> m (SmallMutableArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m (SmallMutableArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m ()

sameMutableArr :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

sizeofArr :: SmallArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> m Int

sameArr :: SmallArray a -> SmallArray a -> Bool

IsList (SmallArray a)

Defined in Data.Primitive.SmallArray

Associated Types

type Item (SmallArray a) :: Type

Methods

fromList :: [Item (SmallArray a)] -> SmallArray a

fromListN :: Int -> [Item (SmallArray a)] -> SmallArray a

toList :: SmallArray a -> [Item (SmallArray a)]

Eq a => Eq (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

(==) :: SmallArray a -> SmallArray a -> Bool

(/=) :: SmallArray a -> SmallArray a -> Bool

Data a => Data (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SmallArray a -> c (SmallArray a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SmallArray a)

toConstr :: SmallArray a -> Constr

dataTypeOf :: SmallArray a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SmallArray a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SmallArray a))

gmapT :: (forall b. Data b => b -> b) -> SmallArray a -> SmallArray a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SmallArray a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SmallArray a -> r

gmapQ :: (forall d. Data d => d -> u) -> SmallArray a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SmallArray a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a)

Ord a => Ord (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

compare :: SmallArray a -> SmallArray a -> Ordering

(<) :: SmallArray a -> SmallArray a -> Bool

(<=) :: SmallArray a -> SmallArray a -> Bool

(>) :: SmallArray a -> SmallArray a -> Bool

(>=) :: SmallArray a -> SmallArray a -> Bool

max :: SmallArray a -> SmallArray a -> SmallArray a

min :: SmallArray a -> SmallArray a -> SmallArray a

Read a => Read (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

readsPrec :: Int -> ReadS (SmallArray a)

readList :: ReadS [SmallArray a]

readPrec :: ReadPrec (SmallArray a)

readListPrec :: ReadPrec [SmallArray a]

Show a => Show (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

showsPrec :: Int -> SmallArray a -> ShowS

show :: SmallArray a -> String

showList :: [SmallArray a] -> ShowS

Semigroup (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

(<>) :: SmallArray a -> SmallArray a -> SmallArray a

sconcat :: NonEmpty (SmallArray a) -> SmallArray a

stimes :: Integral b => b -> SmallArray a -> SmallArray a

Monoid (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

mempty :: SmallArray a

mappend :: SmallArray a -> SmallArray a -> SmallArray a

mconcat :: [SmallArray a] -> SmallArray a

PrimUnlifted (SmallArray a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: SmallArray a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> SmallArray a

type MArr SmallArray

Defined in Std.Data.Array

type MArr SmallArray = SmallMutableArray

type Item (SmallArray a)

Defined in Data.Primitive.SmallArray

type Item (SmallArray a) = a

data SmallMutableArray s a

Constructors

SmallMutableArray (SmallMutableArray# s a)

Instances

Arr SmallMutableArray SmallArray a

Defined in Std.Data.Array

Associated Types

type IArr SmallMutableArray = (ar :: Type -> Type)

type MArr SmallArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (SmallMutableArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (SmallMutableArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> a -> m ()

indexArr :: SmallArray a -> Int -> a

indexArr' :: SmallArray a -> Int -> (#a#)

indexArrM :: Monad m => SmallArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> m (SmallArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> Int -> Int -> m (SmallMutableArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> m (SmallArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> m (SmallMutableArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallMutableArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> SmallMutableArray s a -> Int -> Int -> m ()

cloneArr :: SmallArray a -> Int -> Int -> SmallArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> Int -> m (SmallMutableArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m (SmallMutableArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> Int -> m ()

sameMutableArr :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

sizeofArr :: SmallArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => SmallMutableArray s a -> m Int

sameArr :: SmallArray a -> SmallArray a -> Bool

Eq (SmallMutableArray s a)

Defined in Data.Primitive.SmallArray

Methods

(==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

(/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

(Typeable s, Typeable a) => Data (SmallMutableArray s a)

Defined in Data.Primitive.SmallArray

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SmallMutableArray s a -> c (SmallMutableArray s a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SmallMutableArray s a)

toConstr :: SmallMutableArray s a -> Constr

dataTypeOf :: SmallMutableArray s a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SmallMutableArray s a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SmallMutableArray s a))

gmapT :: (forall b. Data b => b -> b) -> SmallMutableArray s a -> SmallMutableArray s a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SmallMutableArray s a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SmallMutableArray s a -> r

gmapQ :: (forall d. Data d => d -> u) -> SmallMutableArray s a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SmallMutableArray s a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a)

PrimUnlifted (SmallMutableArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: SmallMutableArray s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> SmallMutableArray s a

type IArr SmallMutableArray

Defined in Std.Data.Array

type IArr SmallMutableArray = SmallArray

uninitialized :: a

Bottom value (throw (UndefinedElement "Data.Array.uninitialized")) for initialize new boxed array(Array, SmallArray..).

NOTE: These functions may segfault when used with indices which are out of bounds.

Primitive array type

data PrimArray a

Constructors

PrimArray ByteArray#

Instances

Prim a => Arr MutablePrimArray PrimArray a

Defined in Std.Data.Array

Associated Types

type IArr MutablePrimArray = (ar :: Type -> Type)

type MArr PrimArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutablePrimArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutablePrimArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> a -> m ()

indexArr :: PrimArray a -> Int -> a

indexArr' :: PrimArray a -> Int -> (#a#)

indexArrM :: Monad m => PrimArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> m (PrimArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> Int -> Int -> m (MutablePrimArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> m (PrimArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> m (MutablePrimArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> PrimArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> MutablePrimArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> MutablePrimArray s a -> Int -> Int -> m ()

cloneArr :: PrimArray a -> Int -> Int -> PrimArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> m (MutablePrimArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m (MutablePrimArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m ()

sameMutableArr :: MutablePrimArray s a -> MutablePrimArray s a -> Bool

sizeofArr :: PrimArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> m Int

sameArr :: PrimArray a -> PrimArray a -> Bool

Prim a => IsList (PrimArray a)

Defined in Data.Primitive.PrimArray

Associated Types

type Item (PrimArray a) :: Type

Methods

fromList :: [Item (PrimArray a)] -> PrimArray a

fromListN :: Int -> [Item (PrimArray a)] -> PrimArray a

toList :: PrimArray a -> [Item (PrimArray a)]

(Eq a, Prim a) => Eq (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

(==) :: PrimArray a -> PrimArray a -> Bool

(/=) :: PrimArray a -> PrimArray a -> Bool

(Ord a, Prim a) => Ord (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

compare :: PrimArray a -> PrimArray a -> Ordering

(<) :: PrimArray a -> PrimArray a -> Bool

(<=) :: PrimArray a -> PrimArray a -> Bool

(>) :: PrimArray a -> PrimArray a -> Bool

(>=) :: PrimArray a -> PrimArray a -> Bool

max :: PrimArray a -> PrimArray a -> PrimArray a

min :: PrimArray a -> PrimArray a -> PrimArray a

(Show a, Prim a) => Show (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

showsPrec :: Int -> PrimArray a -> ShowS

show :: PrimArray a -> String

showList :: [PrimArray a] -> ShowS

Semigroup (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

(<>) :: PrimArray a -> PrimArray a -> PrimArray a

sconcat :: NonEmpty (PrimArray a) -> PrimArray a

stimes :: Integral b => b -> PrimArray a -> PrimArray a

Monoid (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

mempty :: PrimArray a

mappend :: PrimArray a -> PrimArray a -> PrimArray a

mconcat :: [PrimArray a] -> PrimArray a

PrimUnlifted (PrimArray a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: PrimArray a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> PrimArray a

type MArr PrimArray

Defined in Std.Data.Array

type MArr PrimArray = MutablePrimArray

type Item (PrimArray a)

Defined in Data.Primitive.PrimArray

type Item (PrimArray a) = a

data MutablePrimArray s a

Constructors

MutablePrimArray (MutableByteArray# s)

Instances

Prim a => Arr MutablePrimArray PrimArray a

Defined in Std.Data.Array

Associated Types

type IArr MutablePrimArray = (ar :: Type -> Type)

type MArr PrimArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutablePrimArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutablePrimArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> a -> m ()

indexArr :: PrimArray a -> Int -> a

indexArr' :: PrimArray a -> Int -> (#a#)

indexArrM :: Monad m => PrimArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> m (PrimArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> Int -> Int -> m (MutablePrimArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> m (PrimArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> m (MutablePrimArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> PrimArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> MutablePrimArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> MutablePrimArray s a -> Int -> Int -> m ()

cloneArr :: PrimArray a -> Int -> Int -> PrimArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> Int -> m (MutablePrimArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m (MutablePrimArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> Int -> m ()

sameMutableArr :: MutablePrimArray s a -> MutablePrimArray s a -> Bool

sizeofArr :: PrimArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutablePrimArray s a -> m Int

sameArr :: PrimArray a -> PrimArray a -> Bool

PrimUnlifted (MutablePrimArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutablePrimArray s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutablePrimArray s a

type IArr MutablePrimArray

Defined in Std.Data.Array

type IArr MutablePrimArray = PrimArray

class Prim a where

Methods

sizeOf# :: a -> Int#

alignment# :: a -> Int#

indexByteArray# :: ByteArray# -> Int# -> a

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, a#)

writeByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> a

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, a#)

writeOffAddr# :: Addr# -> Int# -> a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> a -> State# s -> State# s

Instances

Prim Char

Defined in Data.Primitive.Types

Methods

sizeOf# :: Char -> Int#

alignment# :: Char -> Int#

indexByteArray# :: ByteArray# -> Int# -> Char

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Char#)

writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Char

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Char#)

writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s

Prim Double

Defined in Data.Primitive.Types

Methods

sizeOf# :: Double -> Int#

alignment# :: Double -> Int#

indexByteArray# :: ByteArray# -> Int# -> Double

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Double#)

writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Double

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Double#)

writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s

Prim Float

Defined in Data.Primitive.Types

Methods

sizeOf# :: Float -> Int#

alignment# :: Float -> Int#

indexByteArray# :: ByteArray# -> Int# -> Float

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Float#)

writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Float

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Float#)

writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s

Prim Int

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int -> Int#

alignment# :: Int -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int#)

writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s

Prim Int8

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int8 -> Int#

alignment# :: Int8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int8#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int8

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int8#)

writeOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int8 -> State# s -> State# s

Prim Int16

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int16 -> Int#

alignment# :: Int16 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int16

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int16#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int16

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int16#)

writeOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int16 -> State# s -> State# s

Prim Int32

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int32 -> Int#

alignment# :: Int32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int32#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int32

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int32#)

writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s

Prim Int64

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int64 -> Int#

alignment# :: Int64 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int64

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int64#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int64

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int64#)

writeOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int64 -> State# s -> State# s

Prim Word

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word -> Int#

alignment# :: Word -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word#)

writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s

Prim Word8

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word8 -> Int#

alignment# :: Word8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word8#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word8

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word8#)

writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s

Prim Word16

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word16 -> Int#

alignment# :: Word16 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word16

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word16#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word16

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word16#)

writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s

Prim Word32

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word32 -> Int#

alignment# :: Word32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word32#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word32

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word32#)

writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s

Prim Word64

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word64 -> Int#

alignment# :: Word64 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word64

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word64#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word64

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word64#)

writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s

Prim CDev

Defined in Data.Primitive.Types

Methods

sizeOf# :: CDev -> Int#

alignment# :: CDev -> Int#

indexByteArray# :: ByteArray# -> Int# -> CDev

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CDev#)

writeByteArray# :: MutableByteArray# s -> Int# -> CDev -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CDev -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CDev

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CDev#)

writeOffAddr# :: Addr# -> Int# -> CDev -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CDev -> State# s -> State# s

Prim CIno

Defined in Data.Primitive.Types

Methods

sizeOf# :: CIno -> Int#

alignment# :: CIno -> Int#

indexByteArray# :: ByteArray# -> Int# -> CIno

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CIno#)

writeByteArray# :: MutableByteArray# s -> Int# -> CIno -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CIno -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CIno

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CIno#)

writeOffAddr# :: Addr# -> Int# -> CIno -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CIno -> State# s -> State# s

Prim CMode

Defined in Data.Primitive.Types

Methods

sizeOf# :: CMode -> Int#

alignment# :: CMode -> Int#

indexByteArray# :: ByteArray# -> Int# -> CMode

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CMode#)

writeByteArray# :: MutableByteArray# s -> Int# -> CMode -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CMode -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CMode

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CMode#)

writeOffAddr# :: Addr# -> Int# -> CMode -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CMode -> State# s -> State# s

Prim COff

Defined in Data.Primitive.Types

Methods

sizeOf# :: COff -> Int#

alignment# :: COff -> Int#

indexByteArray# :: ByteArray# -> Int# -> COff

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, COff#)

writeByteArray# :: MutableByteArray# s -> Int# -> COff -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> COff -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> COff

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, COff#)

writeOffAddr# :: Addr# -> Int# -> COff -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> COff -> State# s -> State# s

Prim CPid

Defined in Data.Primitive.Types

Methods

sizeOf# :: CPid -> Int#

alignment# :: CPid -> Int#

indexByteArray# :: ByteArray# -> Int# -> CPid

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CPid#)

writeByteArray# :: MutableByteArray# s -> Int# -> CPid -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CPid -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CPid

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CPid#)

writeOffAddr# :: Addr# -> Int# -> CPid -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CPid -> State# s -> State# s

Prim CSsize

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSsize -> Int#

alignment# :: CSsize -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSsize

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSsize#)

writeByteArray# :: MutableByteArray# s -> Int# -> CSsize -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSsize -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSsize

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSsize#)

writeOffAddr# :: Addr# -> Int# -> CSsize -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSsize -> State# s -> State# s

Prim CGid

Defined in Data.Primitive.Types

Methods

sizeOf# :: CGid -> Int#

alignment# :: CGid -> Int#

indexByteArray# :: ByteArray# -> Int# -> CGid

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CGid#)

writeByteArray# :: MutableByteArray# s -> Int# -> CGid -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CGid -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CGid

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CGid#)

writeOffAddr# :: Addr# -> Int# -> CGid -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CGid -> State# s -> State# s

Prim CNlink

Defined in Data.Primitive.Types

Methods

sizeOf# :: CNlink -> Int#

alignment# :: CNlink -> Int#

indexByteArray# :: ByteArray# -> Int# -> CNlink

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CNlink#)

writeByteArray# :: MutableByteArray# s -> Int# -> CNlink -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CNlink -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CNlink

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CNlink#)

writeOffAddr# :: Addr# -> Int# -> CNlink -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CNlink -> State# s -> State# s

Prim CUid

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUid -> Int#

alignment# :: CUid -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUid

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUid#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUid -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUid -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUid

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUid#)

writeOffAddr# :: Addr# -> Int# -> CUid -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUid -> State# s -> State# s

Prim CCc

Defined in Data.Primitive.Types

Methods

sizeOf# :: CCc -> Int#

alignment# :: CCc -> Int#

indexByteArray# :: ByteArray# -> Int# -> CCc

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CCc#)

writeByteArray# :: MutableByteArray# s -> Int# -> CCc -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CCc -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CCc

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CCc#)

writeOffAddr# :: Addr# -> Int# -> CCc -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CCc -> State# s -> State# s

Prim CSpeed

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSpeed -> Int#

alignment# :: CSpeed -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSpeed

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSpeed#)

writeByteArray# :: MutableByteArray# s -> Int# -> CSpeed -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSpeed -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSpeed

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSpeed#)

writeOffAddr# :: Addr# -> Int# -> CSpeed -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSpeed -> State# s -> State# s

Prim CTcflag

Defined in Data.Primitive.Types

Methods

sizeOf# :: CTcflag -> Int#

alignment# :: CTcflag -> Int#

indexByteArray# :: ByteArray# -> Int# -> CTcflag

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CTcflag#)

writeByteArray# :: MutableByteArray# s -> Int# -> CTcflag -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CTcflag -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CTcflag

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CTcflag#)

writeOffAddr# :: Addr# -> Int# -> CTcflag -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CTcflag -> State# s -> State# s

Prim CRLim

Defined in Data.Primitive.Types

Methods

sizeOf# :: CRLim -> Int#

alignment# :: CRLim -> Int#

indexByteArray# :: ByteArray# -> Int# -> CRLim

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CRLim#)

writeByteArray# :: MutableByteArray# s -> Int# -> CRLim -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CRLim -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CRLim

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CRLim#)

writeOffAddr# :: Addr# -> Int# -> CRLim -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CRLim -> State# s -> State# s

Prim CBlkSize

Defined in Data.Primitive.Types

Methods

sizeOf# :: CBlkSize -> Int#

alignment# :: CBlkSize -> Int#

indexByteArray# :: ByteArray# -> Int# -> CBlkSize

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CBlkSize#)

writeByteArray# :: MutableByteArray# s -> Int# -> CBlkSize -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CBlkSize -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CBlkSize

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CBlkSize#)

writeOffAddr# :: Addr# -> Int# -> CBlkSize -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CBlkSize -> State# s -> State# s

Prim CBlkCnt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CBlkCnt -> Int#

alignment# :: CBlkCnt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CBlkCnt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CBlkCnt#)

writeByteArray# :: MutableByteArray# s -> Int# -> CBlkCnt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CBlkCnt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CBlkCnt

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CBlkCnt#)

writeOffAddr# :: Addr# -> Int# -> CBlkCnt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CBlkCnt -> State# s -> State# s

Prim CClockId

Defined in Data.Primitive.Types

Methods

sizeOf# :: CClockId -> Int#

alignment# :: CClockId -> Int#

indexByteArray# :: ByteArray# -> Int# -> CClockId

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CClockId#)

writeByteArray# :: MutableByteArray# s -> Int# -> CClockId -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CClockId -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CClockId

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CClockId#)

writeOffAddr# :: Addr# -> Int# -> CClockId -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CClockId -> State# s -> State# s

Prim CFsBlkCnt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CFsBlkCnt -> Int#

alignment# :: CFsBlkCnt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CFsBlkCnt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CFsBlkCnt#)

writeByteArray# :: MutableByteArray# s -> Int# -> CFsBlkCnt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CFsBlkCnt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CFsBlkCnt

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CFsBlkCnt#)

writeOffAddr# :: Addr# -> Int# -> CFsBlkCnt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CFsBlkCnt -> State# s -> State# s

Prim CFsFilCnt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CFsFilCnt -> Int#

alignment# :: CFsFilCnt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CFsFilCnt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CFsFilCnt#)

writeByteArray# :: MutableByteArray# s -> Int# -> CFsFilCnt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CFsFilCnt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CFsFilCnt

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CFsFilCnt#)

writeOffAddr# :: Addr# -> Int# -> CFsFilCnt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CFsFilCnt -> State# s -> State# s

Prim CId

Defined in Data.Primitive.Types

Methods

sizeOf# :: CId -> Int#

alignment# :: CId -> Int#

indexByteArray# :: ByteArray# -> Int# -> CId

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CId#)

writeByteArray# :: MutableByteArray# s -> Int# -> CId -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CId -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CId

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CId#)

writeOffAddr# :: Addr# -> Int# -> CId -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CId -> State# s -> State# s

Prim CKey

Defined in Data.Primitive.Types

Methods

sizeOf# :: CKey -> Int#

alignment# :: CKey -> Int#

indexByteArray# :: ByteArray# -> Int# -> CKey

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CKey#)

writeByteArray# :: MutableByteArray# s -> Int# -> CKey -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CKey -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CKey

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CKey#)

writeOffAddr# :: Addr# -> Int# -> CKey -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CKey -> State# s -> State# s

Prim Fd

Defined in Data.Primitive.Types

Methods

sizeOf# :: Fd -> Int#

alignment# :: Fd -> Int#

indexByteArray# :: ByteArray# -> Int# -> Fd

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Fd#)

writeByteArray# :: MutableByteArray# s -> Int# -> Fd -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Fd -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Fd

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Fd#)

writeOffAddr# :: Addr# -> Int# -> Fd -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Fd -> State# s -> State# s

Prim CChar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CChar -> Int#

alignment# :: CChar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CChar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CChar#)

writeByteArray# :: MutableByteArray# s -> Int# -> CChar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CChar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CChar

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CChar#)

writeOffAddr# :: Addr# -> Int# -> CChar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CChar -> State# s -> State# s

Prim CSChar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSChar -> Int#

alignment# :: CSChar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSChar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSChar#)

writeByteArray# :: MutableByteArray# s -> Int# -> CSChar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSChar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSChar

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSChar#)

writeOffAddr# :: Addr# -> Int# -> CSChar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSChar -> State# s -> State# s

Prim CUChar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUChar -> Int#

alignment# :: CUChar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUChar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUChar#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUChar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUChar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUChar

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUChar#)

writeOffAddr# :: Addr# -> Int# -> CUChar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUChar -> State# s -> State# s

Prim CShort

Defined in Data.Primitive.Types

Methods

sizeOf# :: CShort -> Int#

alignment# :: CShort -> Int#

indexByteArray# :: ByteArray# -> Int# -> CShort

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CShort#)

writeByteArray# :: MutableByteArray# s -> Int# -> CShort -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CShort -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CShort

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CShort#)

writeOffAddr# :: Addr# -> Int# -> CShort -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CShort -> State# s -> State# s

Prim CUShort

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUShort -> Int#

alignment# :: CUShort -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUShort

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUShort#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUShort -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUShort -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUShort

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUShort#)

writeOffAddr# :: Addr# -> Int# -> CUShort -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUShort -> State# s -> State# s

Prim CInt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CInt -> Int#

alignment# :: CInt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CInt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CInt#)

writeByteArray# :: MutableByteArray# s -> Int# -> CInt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CInt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CInt

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CInt#)

writeOffAddr# :: Addr# -> Int# -> CInt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CInt -> State# s -> State# s

Prim CUInt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUInt -> Int#

alignment# :: CUInt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUInt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUInt#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUInt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUInt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUInt

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUInt#)

writeOffAddr# :: Addr# -> Int# -> CUInt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUInt -> State# s -> State# s

Prim CLong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CLong -> Int#

alignment# :: CLong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CLong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CLong#)

writeByteArray# :: MutableByteArray# s -> Int# -> CLong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CLong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CLong

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CLong#)

writeOffAddr# :: Addr# -> Int# -> CLong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CLong -> State# s -> State# s

Prim CULong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CULong -> Int#

alignment# :: CULong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CULong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CULong#)

writeByteArray# :: MutableByteArray# s -> Int# -> CULong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CULong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CULong

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CULong#)

writeOffAddr# :: Addr# -> Int# -> CULong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CULong -> State# s -> State# s

Prim CLLong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CLLong -> Int#

alignment# :: CLLong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CLLong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CLLong#)

writeByteArray# :: MutableByteArray# s -> Int# -> CLLong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CLLong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CLLong

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CLLong#)

writeOffAddr# :: Addr# -> Int# -> CLLong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CLLong -> State# s -> State# s

Prim CULLong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CULLong -> Int#

alignment# :: CULLong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CULLong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CULLong#)

writeByteArray# :: MutableByteArray# s -> Int# -> CULLong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CULLong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CULLong

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CULLong#)

writeOffAddr# :: Addr# -> Int# -> CULLong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CULLong -> State# s -> State# s

Prim CBool

Defined in Data.Primitive.Types

Methods

sizeOf# :: CBool -> Int#

alignment# :: CBool -> Int#

indexByteArray# :: ByteArray# -> Int# -> CBool

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CBool#)

writeByteArray# :: MutableByteArray# s -> Int# -> CBool -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CBool -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CBool

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CBool#)

writeOffAddr# :: Addr# -> Int# -> CBool -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CBool -> State# s -> State# s

Prim CFloat

Defined in Data.Primitive.Types

Methods

sizeOf# :: CFloat -> Int#

alignment# :: CFloat -> Int#

indexByteArray# :: ByteArray# -> Int# -> CFloat

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CFloat#)

writeByteArray# :: MutableByteArray# s -> Int# -> CFloat -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CFloat -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CFloat

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CFloat#)

writeOffAddr# :: Addr# -> Int# -> CFloat -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CFloat -> State# s -> State# s

Prim CDouble

Defined in Data.Primitive.Types

Methods

sizeOf# :: CDouble -> Int#

alignment# :: CDouble -> Int#

indexByteArray# :: ByteArray# -> Int# -> CDouble

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CDouble#)

writeByteArray# :: MutableByteArray# s -> Int# -> CDouble -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CDouble -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CDouble

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CDouble#)

writeOffAddr# :: Addr# -> Int# -> CDouble -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CDouble -> State# s -> State# s

Prim CPtrdiff

Defined in Data.Primitive.Types

Methods

sizeOf# :: CPtrdiff -> Int#

alignment# :: CPtrdiff -> Int#

indexByteArray# :: ByteArray# -> Int# -> CPtrdiff

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CPtrdiff#)

writeByteArray# :: MutableByteArray# s -> Int# -> CPtrdiff -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CPtrdiff -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CPtrdiff

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CPtrdiff#)

writeOffAddr# :: Addr# -> Int# -> CPtrdiff -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CPtrdiff -> State# s -> State# s

Prim CSize

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSize -> Int#

alignment# :: CSize -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSize

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSize#)

writeByteArray# :: MutableByteArray# s -> Int# -> CSize -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSize -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSize

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSize#)

writeOffAddr# :: Addr# -> Int# -> CSize -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSize -> State# s -> State# s

Prim CWchar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CWchar -> Int#

alignment# :: CWchar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CWchar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CWchar#)

writeByteArray# :: MutableByteArray# s -> Int# -> CWchar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CWchar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CWchar

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CWchar#)

writeOffAddr# :: Addr# -> Int# -> CWchar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CWchar -> State# s -> State# s

Prim CSigAtomic

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSigAtomic -> Int#

alignment# :: CSigAtomic -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSigAtomic

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSigAtomic#)

writeByteArray# :: MutableByteArray# s -> Int# -> CSigAtomic -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSigAtomic -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSigAtomic

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSigAtomic#)

writeOffAddr# :: Addr# -> Int# -> CSigAtomic -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSigAtomic -> State# s -> State# s

Prim CClock

Defined in Data.Primitive.Types

Methods

sizeOf# :: CClock -> Int#

alignment# :: CClock -> Int#

indexByteArray# :: ByteArray# -> Int# -> CClock

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CClock#)

writeByteArray# :: MutableByteArray# s -> Int# -> CClock -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CClock -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CClock

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CClock#)

writeOffAddr# :: Addr# -> Int# -> CClock -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CClock -> State# s -> State# s

Prim CTime

Defined in Data.Primitive.Types

Methods

sizeOf# :: CTime -> Int#

alignment# :: CTime -> Int#

indexByteArray# :: ByteArray# -> Int# -> CTime

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CTime#)

writeByteArray# :: MutableByteArray# s -> Int# -> CTime -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CTime -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CTime

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CTime#)

writeOffAddr# :: Addr# -> Int# -> CTime -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CTime -> State# s -> State# s

Prim CUSeconds

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUSeconds -> Int#

alignment# :: CUSeconds -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUSeconds

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUSeconds#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUSeconds -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUSeconds -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUSeconds

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUSeconds#)

writeOffAddr# :: Addr# -> Int# -> CUSeconds -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUSeconds -> State# s -> State# s

Prim CSUSeconds

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSUSeconds -> Int#

alignment# :: CSUSeconds -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSUSeconds

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSUSeconds#)

writeByteArray# :: MutableByteArray# s -> Int# -> CSUSeconds -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSUSeconds -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSUSeconds

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSUSeconds#)

writeOffAddr# :: Addr# -> Int# -> CSUSeconds -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSUSeconds -> State# s -> State# s

Prim CIntPtr

Defined in Data.Primitive.Types

Methods

sizeOf# :: CIntPtr -> Int#

alignment# :: CIntPtr -> Int#

indexByteArray# :: ByteArray# -> Int# -> CIntPtr

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CIntPtr#)

writeByteArray# :: MutableByteArray# s -> Int# -> CIntPtr -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CIntPtr -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CIntPtr

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CIntPtr#)

writeOffAddr# :: Addr# -> Int# -> CIntPtr -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CIntPtr -> State# s -> State# s

Prim CUIntPtr

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUIntPtr -> Int#

alignment# :: CUIntPtr -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUIntPtr

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUIntPtr#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUIntPtr -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUIntPtr -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUIntPtr

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUIntPtr#)

writeOffAddr# :: Addr# -> Int# -> CUIntPtr -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUIntPtr -> State# s -> State# s

Prim CIntMax

Defined in Data.Primitive.Types

Methods

sizeOf# :: CIntMax -> Int#

alignment# :: CIntMax -> Int#

indexByteArray# :: ByteArray# -> Int# -> CIntMax

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CIntMax#)

writeByteArray# :: MutableByteArray# s -> Int# -> CIntMax -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CIntMax -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CIntMax

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CIntMax#)

writeOffAddr# :: Addr# -> Int# -> CIntMax -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CIntMax -> State# s -> State# s

Prim CUIntMax

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUIntMax -> Int#

alignment# :: CUIntMax -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUIntMax

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUIntMax#)

writeByteArray# :: MutableByteArray# s -> Int# -> CUIntMax -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUIntMax -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUIntMax

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUIntMax#)

writeOffAddr# :: Addr# -> Int# -> CUIntMax -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUIntMax -> State# s -> State# s

Prim Addr

Defined in Data.Primitive.Types

Methods

sizeOf# :: Addr -> Int#

alignment# :: Addr -> Int#

indexByteArray# :: ByteArray# -> Int# -> Addr

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Addr#)

writeByteArray# :: MutableByteArray# s -> Int# -> Addr -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Addr -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Addr

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Addr#)

writeOffAddr# :: Addr# -> Int# -> Addr -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Addr -> State# s -> State# s

Prim (Ptr a)

Defined in Data.Primitive.Types

Methods

sizeOf# :: Ptr a -> Int#

alignment# :: Ptr a -> Int#

indexByteArray# :: ByteArray# -> Int# -> Ptr a

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Ptr a#)

writeByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Ptr a -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Ptr a

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Ptr a#)

writeOffAddr# :: Addr# -> Int# -> Ptr a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Ptr a -> State# s -> State# s

Prim (FunPtr a)

Defined in Data.Primitive.Types

Methods

sizeOf# :: FunPtr a -> Int#

alignment# :: FunPtr a -> Int#

indexByteArray# :: ByteArray# -> Int# -> FunPtr a

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, FunPtr a#)

writeByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> FunPtr a -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> FunPtr a

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, FunPtr a#)

writeOffAddr# :: Addr# -> Int# -> FunPtr a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> FunPtr a -> State# s -> State# s

Prim a => Prim (RadixDown a)

Defined in Std.Data.Vector.Sort

Methods

sizeOf# :: RadixDown a -> Int#

alignment# :: RadixDown a -> Int#

indexByteArray# :: ByteArray# -> Int# -> RadixDown a

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, RadixDown a#)

writeByteArray# :: MutableByteArray# s -> Int# -> RadixDown a -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> RadixDown a -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> RadixDown a

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, RadixDown a#)

writeOffAddr# :: Addr# -> Int# -> RadixDown a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> RadixDown a -> State# s -> State# s

newPinnedPrimArray :: forall m a. (PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)

Create a pinned byte array of the specified size, The garbage collector is guaranteed not to move it.

newAlignedPinnedPrimArray :: forall m a. (PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)

Create a pinned primitive array of the specified size and respect given primitive type's alignment. The garbage collector is guaranteed not to move it.

copyPrimArrayToPtr :: (PrimMonad m, Prim a) => Ptr a -> PrimArray a -> Int -> Int -> m ()

copyMutablePrimArrayToPtr :: (PrimMonad m, Prim a) => Ptr a -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()

copyPtrToMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> Ptr a -> Int -> m ()

primArrayContents :: PrimArray a -> Ptr a

Yield a pointer to the array's data.

This operation is only safe on pinned primitive arrays allocated by newPinnedPrimArray or newAlignedPinnedPrimArray, and you have to make sure the PrimArray can outlive the Ptr.

mutablePrimArrayContents :: MutablePrimArray s a -> Ptr a

Yield a pointer to the array's data.

This operation is only safe on pinned primitive arrays allocated by newPinnedPrimArray or newAlignedPinnedPrimArray. and you have to make sure the PrimArray can outlive the Ptr.

withPrimArrayContents :: PrimArray a -> (Ptr a -> IO b) -> IO b

Yield a pointer to the array's data and do computation with it.

This operation is only safe on pinned primitive arrays allocated by newPinnedPrimArray or newAlignedPinnedPrimArray.

Don't pass a forever loop to this function, see #14346.

withMutablePrimArrayContents :: MutablePrimArray RealWorld a -> (Ptr a -> IO b) -> IO b

Yield a pointer to the array's data and do computation with it.

This operation is only safe on pinned primitive arrays allocated by newPinnedPrimArray or newAlignedPinnedPrimArray.

Don't pass a forever loop to this function, see #14346.

isPrimArrayPinned :: PrimArray a -> Bool

Check if a primitive array is pinned.

isMutablePrimArrayPinned :: MutablePrimArray s a -> Bool

Check if a mutable primitive array is pinned.

Unlifted array type

data UnliftedArray e

Constructors

UnliftedArray ArrayArray#

Instances

PrimUnlifted a => Arr MutableUnliftedArray UnliftedArray a

Defined in Std.Data.Array

Associated Types

type IArr MutableUnliftedArray = (ar :: Type -> Type)

type MArr UnliftedArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutableUnliftedArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutableUnliftedArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> a -> m ()

indexArr :: UnliftedArray a -> Int -> a

indexArr' :: UnliftedArray a -> Int -> (#a#)

indexArrM :: Monad m => UnliftedArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> m (UnliftedArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => UnliftedArray a -> Int -> Int -> m (MutableUnliftedArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> m (UnliftedArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => UnliftedArray a -> m (MutableUnliftedArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> UnliftedArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> MutableUnliftedArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> MutableUnliftedArray s a -> Int -> Int -> m ()

cloneArr :: UnliftedArray a -> Int -> Int -> UnliftedArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> m (MutableUnliftedArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m (MutableUnliftedArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m ()

sameMutableArr :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

sizeofArr :: UnliftedArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> m Int

sameArr :: UnliftedArray a -> UnliftedArray a -> Bool

PrimUnlifted a => IsList (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Associated Types

type Item (UnliftedArray a) :: Type

Methods

fromList :: [Item (UnliftedArray a)] -> UnliftedArray a

fromListN :: Int -> [Item (UnliftedArray a)] -> UnliftedArray a

toList :: UnliftedArray a -> [Item (UnliftedArray a)]

(Eq a, PrimUnlifted a) => Eq (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

(==) :: UnliftedArray a -> UnliftedArray a -> Bool

(/=) :: UnliftedArray a -> UnliftedArray a -> Bool

(Ord a, PrimUnlifted a) => Ord (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

compare :: UnliftedArray a -> UnliftedArray a -> Ordering

(<) :: UnliftedArray a -> UnliftedArray a -> Bool

(<=) :: UnliftedArray a -> UnliftedArray a -> Bool

(>) :: UnliftedArray a -> UnliftedArray a -> Bool

(>=) :: UnliftedArray a -> UnliftedArray a -> Bool

max :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

min :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

(Show a, PrimUnlifted a) => Show (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

showsPrec :: Int -> UnliftedArray a -> ShowS

show :: UnliftedArray a -> String

showList :: [UnliftedArray a] -> ShowS

PrimUnlifted a => Semigroup (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

(<>) :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

sconcat :: NonEmpty (UnliftedArray a) -> UnliftedArray a

stimes :: Integral b => b -> UnliftedArray a -> UnliftedArray a

PrimUnlifted a => Monoid (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

mempty :: UnliftedArray a

mappend :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

mconcat :: [UnliftedArray a] -> UnliftedArray a

PrimUnlifted (UnliftedArray e)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: UnliftedArray e -> ArrayArray#

fromArrayArray# :: ArrayArray# -> UnliftedArray e

type MArr UnliftedArray

Defined in Std.Data.Array

type MArr UnliftedArray = MutableUnliftedArray

type Item (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

type Item (UnliftedArray a) = a

data MutableUnliftedArray s e

Constructors

MutableUnliftedArray (MutableArrayArray# s)

Instances

PrimUnlifted a => Arr MutableUnliftedArray UnliftedArray a

Defined in Std.Data.Array

Associated Types

type IArr MutableUnliftedArray = (ar :: Type -> Type)

type MArr UnliftedArray = (mar :: Type -> Type -> Type)

Methods

newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MutableUnliftedArray s a)

newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MutableUnliftedArray s a)

readArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m a

writeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> a -> m ()

setArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> a -> m ()

indexArr :: UnliftedArray a -> Int -> a

indexArr' :: UnliftedArray a -> Int -> (#a#)

indexArrM :: Monad m => UnliftedArray a -> Int -> m a

freezeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> m (UnliftedArray a)

thawArr :: (PrimMonad m, PrimState m ~ s) => UnliftedArray a -> Int -> Int -> m (MutableUnliftedArray s a)

unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> m (UnliftedArray a)

unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => UnliftedArray a -> m (MutableUnliftedArray s a)

copyArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> UnliftedArray a -> Int -> Int -> m ()

copyMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> MutableUnliftedArray s a -> Int -> Int -> m ()

moveArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> MutableUnliftedArray s a -> Int -> Int -> m ()

cloneArr :: UnliftedArray a -> Int -> Int -> UnliftedArray a

cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> Int -> m (MutableUnliftedArray s a)

resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m (MutableUnliftedArray s a)

shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> Int -> m ()

sameMutableArr :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

sizeofArr :: UnliftedArray a -> Int

sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MutableUnliftedArray s a -> m Int

sameArr :: UnliftedArray a -> UnliftedArray a -> Bool

Eq (MutableUnliftedArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

(==) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

(/=) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

PrimUnlifted (MutableUnliftedArray s e)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutableUnliftedArray s e -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutableUnliftedArray s e

type IArr MutableUnliftedArray

Defined in Std.Data.Array

type IArr MutableUnliftedArray = UnliftedArray

class PrimUnlifted a where

Methods

toArrayArray# :: a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> a

Instances

PrimUnlifted ThreadId

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: ThreadId -> ArrayArray#

fromArrayArray# :: ArrayArray# -> ThreadId

PrimUnlifted ByteArray

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: ByteArray -> ArrayArray#

fromArrayArray# :: ArrayArray# -> ByteArray

PrimUnlifted (StablePtr a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: StablePtr a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> StablePtr a

PrimUnlifted (TVar a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: TVar a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> TVar a

PrimUnlifted (Weak a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: Weak a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> Weak a

PrimUnlifted (MVar a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MVar a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MVar a

PrimUnlifted (MutableByteArray s)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutableByteArray s -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutableByteArray s

PrimUnlifted (PrimArray a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: PrimArray a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> PrimArray a

PrimUnlifted (Array a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: Array a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> Array a

PrimUnlifted (SmallArray a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: SmallArray a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> SmallArray a

PrimUnlifted (UnliftedArray e)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: UnliftedArray e -> ArrayArray#

fromArrayArray# :: ArrayArray# -> UnliftedArray e

PrimUnlifted (MutablePrimArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutablePrimArray s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutablePrimArray s a

PrimUnlifted (MutableArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutableArray s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutableArray s a

PrimUnlifted (SmallMutableArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: SmallMutableArray s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> SmallMutableArray s a

PrimUnlifted (MutableUnliftedArray s e)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutableUnliftedArray s e -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutableUnliftedArray s e

PrimUnlifted (MutVar s a)

Defined in Data.Primitive.UnliftedArray

Methods

toArrayArray# :: MutVar s a -> ArrayArray#

fromArrayArray# :: ArrayArray# -> MutVar s a

The ArrayException type

data ArrayException

Exceptions generated by array operations

Constructors

IndexOutOfBounds String

An attempt was made to index an array outside its declared bounds.

UndefinedElement String

An attempt was made to evaluate an element of an array that had not been initialized.

Instances

Eq ArrayException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

Methods

(==) :: ArrayException -> ArrayException -> Bool

(/=) :: ArrayException -> ArrayException -> Bool

Ord ArrayException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

Methods

compare :: ArrayException -> ArrayException -> Ordering

(<) :: ArrayException -> ArrayException -> Bool

(<=) :: ArrayException -> ArrayException -> Bool

(>) :: ArrayException -> ArrayException -> Bool

(>=) :: ArrayException -> ArrayException -> Bool

max :: ArrayException -> ArrayException -> ArrayException

min :: ArrayException -> ArrayException -> ArrayException

Show ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ArrayException -> ShowS

show :: ArrayException -> String

showList :: [ArrayException] -> ShowS

Exception ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> String

Cast between primitive arrays

castArray :: (Arr marr arr a, Cast a b) => arr a -> arr b

Cast between arrays

castMutableArray :: (Arr marr arr a, Cast a b) => marr s a -> marr s b