vector-0.13.1.0: Efficient Arrays

Copyright | (c) Roman Leshchinskiy 2008-2010 Alexey Kuleshevich 2020-2022 Aleksey Khudyakov 2020-2022 Andrew Lelechenko 2020-2022
License | BSD-style
Maintainer | Haskell Libraries Team <libraries@haskell.org>
Stability | experimental
Portability | non-portable
Safe Haskell | None
Language | Haskell2010

Data.Vector.Primitive.Mutable

Contents

- Mutable vectors of primitive types
- Accessors
  - Length information
  - Extracting subvectors
  - Overlapping
- Construction
  - Initialisation
  - Growing
  - Restricting memory usage
- Accessing individual elements
- Folds
- Modifying vectors
  - Filling and copying
- Unsafe conversions
- Re-exports

Description

Mutable primitive vectors.

Synopsis

- data MVector s a = MVector !Int !Int !(MutableByteArray s)
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- length :: Prim a => MVector s a -> Int
- null :: Prim a => MVector s a -> Bool
- slice :: Prim a => Int -> Int -> MVector s a -> MVector s a
- init :: Prim a => MVector s a -> MVector s a
- tail :: Prim a => MVector s a -> MVector s a
- take :: Prim a => Int -> MVector s a -> MVector s a
- drop :: Prim a => Int -> MVector s a -> MVector s a
- splitAt :: Prim a => Int -> MVector s a -> (MVector s a, MVector s a)
- unsafeSlice :: Prim a => Int -> Int -> MVector s a -> MVector s a
- unsafeInit :: Prim a => MVector s a -> MVector s a
- unsafeTail :: Prim a => MVector s a -> MVector s a
- unsafeTake :: Prim a => Int -> MVector s a -> MVector s a
- unsafeDrop :: Prim a => Int -> MVector s a -> MVector s a
- overlaps :: Prim a => MVector s a -> MVector s a -> Bool
- new :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
- unsafeNew :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
- replicate :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
- replicateM :: (PrimMonad m, Prim a) => Int -> m a -> m (MVector (PrimState m) a)
- generate :: (PrimMonad m, Prim a) => Int -> (Int -> a) -> m (MVector (PrimState m) a)
- generateM :: (PrimMonad m, Prim a) => Int -> (Int -> m a) -> m (MVector (PrimState m) a)
- clone :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m (MVector (PrimState m) a)
- grow :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- unsafeGrow :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- clear :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m ()
- read :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
- readMaybe :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (Maybe a)
- write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
- modify :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- modifyM :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m ()
- swap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m ()
- exchange :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m a
- unsafeRead :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
- unsafeWrite :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
- unsafeModify :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- unsafeModifyM :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m ()
- unsafeSwap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m ()
- unsafeExchange :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m a
- mapM_ :: (PrimMonad m, Prim a) => (a -> m b) -> MVector (PrimState m) a -> m ()
- imapM_ :: (PrimMonad m, Prim a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m ()
- forM_ :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> m b) -> m ()
- iforM_ :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (Int -> a -> m b) -> m ()
- foldl :: (PrimMonad m, Prim a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b
- foldl' :: (PrimMonad m, Prim a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b
- foldM :: (PrimMonad m, Prim a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- foldM' :: (PrimMonad m, Prim a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- foldr :: (PrimMonad m, Prim a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- foldr' :: (PrimMonad m, Prim a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- foldrM :: (PrimMonad m, Prim a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- foldrM' :: (PrimMonad m, Prim a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldl :: (PrimMonad m, Prim a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldl' :: (PrimMonad m, Prim a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldM :: (PrimMonad m, Prim a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldM' :: (PrimMonad m, Prim a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldr :: (PrimMonad m, Prim a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldr' :: (PrimMonad m, Prim a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldrM :: (PrimMonad m, Prim a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldrM' :: (PrimMonad m, Prim a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- nextPermutation :: (PrimMonad m, Ord e, Prim e) => MVector (PrimState m) e -> m Bool
- set :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> a -> m ()
- copy :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- move :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCopy :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeMove :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCoerceMVector :: Coercible a b => MVector s a -> MVector s b
- unsafeCast :: (HasCallStack, Prim a, Prim b) => MVector s a -> MVector s b
- class Prim a
- class Monad m => PrimMonad (m :: Type -> Type)
- type family PrimState (m :: Type -> Type)
- data RealWorld

# Mutable vectors of primitive types

data MVector s a #

Mutable vectors of primitive types.

Constructors

MVector |

Fields

- !Int

  offset

- !Int

  length

- !(MutableByteArray s)

  underlying mutable byte array

#### Instances

Instances details

Prim a => MVector MVector a # |

Instance details

Defined in Data.Vector.Primitive.Mutable

Methods

basicLength :: MVector s a -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s a -> MVector s a #

basicOverlaps :: MVector s a -> MVector s a -> Bool #

basicUnsafeNew :: Int -> ST s (MVector s a) #

basicInitialize :: MVector s a -> ST s () #

basicUnsafeReplicate :: Int -> a -> ST s (MVector s a) #

basicUnsafeRead :: MVector s a -> Int -> ST s a #

basicUnsafeWrite :: MVector s a -> Int -> a -> ST s () #

basicClear :: MVector s a -> ST s () #

basicSet :: MVector s a -> a -> ST s () #

basicUnsafeCopy :: MVector s a -> MVector s a -> ST s () #

basicUnsafeMove :: MVector s a -> MVector s a -> ST s () #

basicUnsafeGrow :: MVector s a -> Int -> ST s (MVector s a) #

NFData1 (MVector s) # |
Instance details Defined in Data.Vector.Primitive.Mutable Methods liftRnf :: (a -> ()) -> MVector s a -> () #
NFData (MVector s a) # |
Instance details Defined in Data.Vector.Primitive.Mutable Methods rnf :: MVector s a -> () #

type IOVector = MVector RealWorld #

type STVector s = MVector s #

# Accessors

## Length information

length :: Prim a => MVector s a -> Int #

Length of the mutable vector.

null :: Prim a => MVector s a -> Bool #

Check whether the vector is empty.

## Extracting subvectors

slice #

Arguments

:: Prim a |
=> Int | `i` starting index
-> Int | `n` length
-> MVector s a |
-> MVector s a |

Yield a part of the mutable vector without copying it. The vector must contain at least `i+n` elements.

init :: Prim a => MVector s a -> MVector s a #

Drop the last element of the mutable vector without making a copy. If the vector is empty, an exception is thrown.

tail :: Prim a => MVector s a -> MVector s a #

Drop the first element of the mutable vector without making a copy. If the vector is empty, an exception is thrown.

take :: Prim a => Int -> MVector s a -> MVector s a #

Take the `n` first elements of the mutable vector without making a copy. For negative `n`, the empty vector is returned. If `n` is larger than the vector's length, the vector is returned unchanged.

drop :: Prim a => Int -> MVector s a -> MVector s a #

Drop the `n` first element of the mutable vector without making a copy. For negative `n`, the vector is returned unchanged. If `n` is larger than the vector's length, the empty vector is returned.

splitAt :: Prim a => Int -> MVector s a -> (MVector s a, MVector s a) #

O(1) Split the mutable vector into the first `n` elements and the remainder, without copying.

Note that ``splitAt` n v` is equivalent to `(`take` n v, `drop` n v)`, but slightly more efficient.

unsafeSlice #

Arguments

:: Prim a |
=> Int | starting index
-> Int | length of the slice
-> MVector s a |
-> MVector s a |

Yield a part of the mutable vector without copying it. No bounds checks are performed.

unsafeInit :: Prim a => MVector s a -> MVector s a #

Same as `init`, but doesn't do range checks.

unsafeTail :: Prim a => MVector s a -> MVector s a #

Same as `tail`, but doesn't do range checks.

unsafeTake :: Prim a => Int -> MVector s a -> MVector s a #

Unsafe variant of `take`. If `n` is out of range, it will simply create an invalid slice that likely violate memory safety.

unsafeDrop :: Prim a => Int -> MVector s a -> MVector s a #

Unsafe variant of `drop`. If `n` is out of range, it will simply create an invalid slice that likely violate memory safety.

## Overlapping

overlaps :: Prim a => MVector s a -> MVector s a -> Bool #

Check whether two vectors overlap.

# Construction

## Initialisation

new :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length.

unsafeNew :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length. The vector content is uninitialized, which means it is filled with whatever the underlying memory buffer happens to contain.

Since: 0.5

replicate :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length (0 if the length is negative) and fill it with an initial value.

replicateM :: (PrimMonad m, Prim a) => Int -> m a -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length (0 if the length is negative) and fill it with values produced by repeatedly executing the monadic action.

generate :: (PrimMonad m, Prim a) => Int -> (Int -> a) -> m (MVector (PrimState m) a) #

O(n) Create a mutable vector of the given length (0 if the length is negative) and fill it with the results of applying the function to each index. Iteration starts at index 0.

Since: 0.12.3.0

generateM :: (PrimMonad m, Prim a) => Int -> (Int -> m a) -> m (MVector (PrimState m) a) #

O(n) Create a mutable vector of the given length (0 if the length is negative) and fill it with the results of applying the monadic function to each index. Iteration starts at index 0.

Since: 0.12.3.0

clone :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m (MVector (PrimState m) a) #

Create a copy of a mutable vector.

## Growing

grow :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #

Grow a primitive vector by the given number of elements. The number must be non-negative. This has the same semantics as `grow` for generic vectors.

#### Examples

Expand

    >>> import qualified Data.Vector.Primitive as VP
    >>> import qualified Data.Vector.Primitive.Mutable as MVP
    >>> mv <- VP.thaw $ VP.fromList ([10, 20, 30] :: [Int])
    >>> mv' <- MVP.grow mv 2

Extra memory at the end of the newly allocated vector is initialized to 0 bytes, which for `Prim` instances will usually correspond to some default value for a particular type, e.g. `0` for `Int`, `NUL` for `Char`, etc. However, if `unsafeGrow` was used instead, this would not have been guaranteed and some garbage would be there instead.

    >>> VP.freeze mv'
    [10,20,30,0,0]

Having the extra space we can write new values in there:

    >>> MVP.write mv' 3 999
    >>> VP.freeze mv'
    [10,20,30,999,0]

It is important to note that the source mutable vector is not affected when the newly allocated one is mutated.

    >>> MVP.write mv' 2 888
    >>> VP.freeze mv'
    [10,20,888,999,0]
    >>> VP.freeze mv
    [10,20,30]

Since: 0.5

unsafeGrow :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #

Grow a vector by the given number of elements. The number must be non-negative, but this is not checked. This has the same semantics as `unsafeGrow` for generic vectors.

Since: 0.5

## Restricting memory usage

clear :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m () #

Reset all elements of the vector to some undefined value, clearing all references to external objects. This is a noop.

# Accessing individual elements

read :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a #

Yield the element at the given position. Will throw an exception if the index is out of range.

#### Examples

Expand

    >>> import qualified Data.Vector.Primitive.Mutable as MVP
    >>> v <- MVP.generate 10 (\x -> x*x)
    >>> MVP.read v 3
    9

readMaybe :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m (Maybe a) #

Yield the element at the given position. Returns `Nothing` if the index is out of range.

#### Examples

Expand

    >>> import qualified Data.Vector.Primitive.Mutable as MVP
    >>> v <- MVP.generate 10 (\x -> x*x)
    >>> MVP.readMaybe v 3
    Just 9
    >>> MVP.readMaybe v 13
    Nothing

Since: 0.13

write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m () #

Replace the element at the given position.

modify :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () #

Modify the element at the given position.

modifyM :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () #

Modify the element at the given position using a monadic function.

Since: 0.12.3.0

swap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m () #

Swap the elements at the given positions.

exchange :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m a #

Replace the element at the given position and return the old element.

unsafeRead :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a #

Yield the element at the given position. No bounds checks are performed.

unsafeWrite :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m () #

Replace the element at the given position. No bounds checks are performed.

unsafeModify :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () #

Modify the element at the given position. No bounds checks are performed.

unsafeModifyM :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () #

Modify the element at the given position using a monadic function. No bounds checks are performed.

Since: 0.12.3.0

unsafeSwap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m () #

Swap the elements at the given positions. No bounds checks are performed.

unsafeExchange :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m a #

Replace the element at the given position and return the old element. No bounds checks are performed.

# Folds

mapM_ :: (PrimMonad m, Prim a) => (a -> m b) -> MVector (PrimState m) a -> m () #

O(n) Apply the monadic action to every element of the vector, discarding the results.

Since: 0.12.3.0

imapM_ :: (PrimMonad m, Prim a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m () #

O(n) Apply the monadic action to every element of the vector and its index, discarding the results.

Since: 0.12.3.0

forM_ :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (a -> m b) -> m () #

O(n) Apply the monadic action to every element of the vector, discarding the results. It's the same as `flip mapM_`.

Since: 0.12.3.0

iforM_ :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> (Int -> a -> m b) -> m () #

O(n) Apply the monadic action to every element of the vector and its index, discarding the results. It's the same as `flip imapM_`.

Since: 0.12.3.0

foldl :: (PrimMonad m, Prim a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold.

Since: 0.12.3.0

foldl' :: (PrimMonad m, Prim a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold with strict accumulator.

Since: 0.12.3.0

foldM :: (PrimMonad m, Prim a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold.

Since: 0.12.3.0

foldM' :: (PrimMonad m, Prim a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold with strict accumulator.

Since: 0.12.3.0

foldr :: (PrimMonad m, Prim a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold.

Since: 0.12.3.0

foldr' :: (PrimMonad m, Prim a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold with strict accumulator.

Since: 0.12.3.0

foldrM :: (PrimMonad m, Prim a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold.

Since: 0.12.3.0

foldrM' :: (PrimMonad m, Prim a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold with strict accumulator.

Since: 0.12.3.0

ifoldl :: (PrimMonad m, Prim a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldl' :: (PrimMonad m, Prim a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

ifoldM :: (PrimMonad m, Prim a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldM' :: (PrimMonad m, Prim a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

ifoldr :: (PrimMonad m, Prim a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldr' :: (PrimMonad m, Prim a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

ifoldrM :: (PrimMonad m, Prim a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldrM' :: (PrimMonad m, Prim a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

# Modifying vectors

nextPermutation :: (PrimMonad m, Ord e, Prim e) => MVector (PrimState m) e -> m Bool #

Compute the (lexicographically) next permutation of the given vector in-place. Returns False when the input is the last permutation.

## Filling and copying

set :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> a -> m () #

Set all elements of the vector to the given value.

copy #

Arguments

:: (PrimMonad m, Prim a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Copy a vector. The two vectors must have the same length and may not overlap.

move #

Arguments

:: (PrimMonad m, Prim a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Move the contents of a vector. The two vectors must have the same length.

If the vectors do not overlap, then this is equivalent to `copy`. Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.

unsafeCopy #

Arguments

:: (PrimMonad m, Prim a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Copy a vector. The two vectors must have the same length and may not overlap, but this is not checked.

unsafeMove #

Arguments

:: (PrimMonad m, Prim a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Move the contents of a vector. The two vectors must have the same length, but this is not checked.

If the vectors do not overlap, then this is equivalent to `unsafeCopy`. Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.

# Unsafe conversions

unsafeCoerceMVector :: Coercible a b => MVector s a -> MVector s b #

O(1) Unsafely coerce a mutable vector from one element type to another, representationally equal type. The operation just changes the type of the underlying pointer and does not modify the elements.

Note that this function is unsafe. The `Coercible` constraint guarantees that the element types are representationally equal. It however cannot guarantee that their respective `Prim` instances are compatible.

unsafeCast :: (HasCallStack, Prim a, Prim b) => MVector s a -> MVector s b #

O(1) Unsafely cast a vector from one element type to another. This operation just changes the type of the vector and does not modify the elements.

This function will throw an error if elements are of mismatching sizes.

| @since 0.13.0.0

# Re-exports

class Prim a #

Class of types supporting primitive array operations. This includes interfacing with GC-managed memory (functions suffixed with `ByteArray#`) and interfacing with unmanaged memory (functions suffixed with `Addr#`). Endianness is platform-dependent.

Minimal complete definition

(sizeOfType# | sizeOf#), (alignmentOfType# | alignment#), indexByteArray#, readByteArray#, writeByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#

#### Instances

Instances details

Prim CBool |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CBool -> Int# #

sizeOf# :: CBool -> Int# #

alignmentOfType# :: Proxy 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 CChar |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CChar -> Int# #

sizeOf# :: CChar -> Int# #

alignmentOfType# :: Proxy 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 CClock |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CClock -> Int# #

sizeOf# :: CClock -> Int# #

alignmentOfType# :: Proxy 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 CDouble |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CDouble -> Int# #

sizeOf# :: CDouble -> Int# #

alignmentOfType# :: Proxy 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 CFloat |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CFloat -> Int# #

sizeOf# :: CFloat -> Int# #

alignmentOfType# :: Proxy 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 CInt |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CInt -> Int# #

sizeOf# :: CInt -> Int# #

alignmentOfType# :: Proxy 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 CIntMax |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CIntMax -> Int# #

sizeOf# :: CIntMax -> Int# #

alignmentOfType# :: Proxy 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 CIntPtr |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CIntPtr -> Int# #

sizeOf# :: CIntPtr -> Int# #

alignmentOfType# :: Proxy 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 CLLong |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CLLong -> Int# #

sizeOf# :: CLLong -> Int# #

alignmentOfType# :: Proxy 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 CLong |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CLong -> Int# #

sizeOf# :: CLong -> Int# #

alignmentOfType# :: Proxy 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 CPtrdiff |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CPtrdiff -> Int# #

sizeOf# :: CPtrdiff -> Int# #

alignmentOfType# :: Proxy 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 CSChar |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CSChar -> Int# #

sizeOf# :: CSChar -> Int# #

alignmentOfType# :: Proxy 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 CSUSeconds |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CSUSeconds -> Int# #

sizeOf# :: CSUSeconds -> Int# #

alignmentOfType# :: Proxy 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 CShort |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CShort -> Int# #

sizeOf# :: CShort -> Int# #

alignmentOfType# :: Proxy 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 CSigAtomic |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CSigAtomic -> Int# #

sizeOf# :: CSigAtomic -> Int# #

alignmentOfType# :: Proxy 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 CSize |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CSize -> Int# #

sizeOf# :: CSize -> Int# #

alignmentOfType# :: Proxy 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 CTime |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CTime -> Int# #

sizeOf# :: CTime -> Int# #

alignmentOfType# :: Proxy 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 CUChar |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUChar -> Int# #

sizeOf# :: CUChar -> Int# #

alignmentOfType# :: Proxy 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 CUInt |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUInt -> Int# #

sizeOf# :: CUInt -> Int# #

alignmentOfType# :: Proxy 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 CUIntMax |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUIntMax -> Int# #

sizeOf# :: CUIntMax -> Int# #

alignmentOfType# :: Proxy 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 CUIntPtr |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUIntPtr -> Int# #

sizeOf# :: CUIntPtr -> Int# #

alignmentOfType# :: Proxy 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 CULLong |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CULLong -> Int# #

sizeOf# :: CULLong -> Int# #

alignmentOfType# :: Proxy 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 CULong |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CULong -> Int# #

sizeOf# :: CULong -> Int# #

alignmentOfType# :: Proxy 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 CUSeconds |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUSeconds -> Int# #

sizeOf# :: CUSeconds -> Int# #

alignmentOfType# :: Proxy 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 CUShort |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUShort -> Int# #

sizeOf# :: CUShort -> Int# #

alignmentOfType# :: Proxy 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 CWchar |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CWchar -> Int# #

sizeOf# :: CWchar -> Int# #

alignmentOfType# :: Proxy 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 IntPtr | Since: primitive-0.7.1.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy IntPtr -> Int# #

sizeOf# :: IntPtr -> Int# #

alignmentOfType# :: Proxy IntPtr -> Int# #

alignment# :: IntPtr -> Int# #

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

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

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

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

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

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

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

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

Prim WordPtr | Since: primitive-0.7.1.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy WordPtr -> Int# #

sizeOf# :: WordPtr -> Int# #

alignmentOfType# :: Proxy WordPtr -> Int# #

alignment# :: WordPtr -> Int# #

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

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

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

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

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

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

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

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

Prim Int16 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Int16 -> Int# #

sizeOf# :: Int16 -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Int32 -> Int# #

sizeOf# :: Int32 -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Int64 -> Int# #

sizeOf# :: Int64 -> Int# #

alignmentOfType# :: Proxy 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 Int8 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Int8 -> Int# #

sizeOf# :: Int8 -> Int# #

alignmentOfType# :: Proxy 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 Word16 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Word16 -> Int# #

sizeOf# :: Word16 -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Word32 -> Int# #

sizeOf# :: Word32 -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Word64 -> Int# #

sizeOf# :: Word64 -> Int# #

alignmentOfType# :: Proxy 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 Word8 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Word8 -> Int# #

sizeOf# :: Word8 -> Int# #

alignmentOfType# :: Proxy 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 CBlkCnt |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CBlkCnt -> Int# #

sizeOf# :: CBlkCnt -> Int# #

alignmentOfType# :: Proxy 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 CBlkSize |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CBlkSize -> Int# #

sizeOf# :: CBlkSize -> Int# #

alignmentOfType# :: Proxy 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 CCc |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CCc -> Int# #

sizeOf# :: CCc -> Int# #

alignmentOfType# :: Proxy 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 CClockId |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CClockId -> Int# #

sizeOf# :: CClockId -> Int# #

alignmentOfType# :: Proxy 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 CDev |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CDev -> Int# #

sizeOf# :: CDev -> Int# #

alignmentOfType# :: Proxy 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 CFsBlkCnt |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CFsBlkCnt -> Int# #

sizeOf# :: CFsBlkCnt -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CFsFilCnt -> Int# #

sizeOf# :: CFsFilCnt -> Int# #

alignmentOfType# :: Proxy 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 CGid |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CGid -> Int# #

sizeOf# :: CGid -> Int# #

alignmentOfType# :: Proxy 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 CId |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CId -> Int# #

sizeOf# :: CId -> Int# #

alignmentOfType# :: Proxy 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 CIno |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CIno -> Int# #

sizeOf# :: CIno -> Int# #

alignmentOfType# :: Proxy 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 CKey |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CKey -> Int# #

sizeOf# :: CKey -> Int# #

alignmentOfType# :: Proxy 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 CMode |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CMode -> Int# #

sizeOf# :: CMode -> Int# #

alignmentOfType# :: Proxy 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 CNlink |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CNlink -> Int# #

sizeOf# :: CNlink -> Int# #

alignmentOfType# :: Proxy 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 COff |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy COff -> Int# #

sizeOf# :: COff -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CPid -> Int# #

sizeOf# :: CPid -> Int# #

alignmentOfType# :: Proxy 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 CRLim |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CRLim -> Int# #

sizeOf# :: CRLim -> Int# #

alignmentOfType# :: Proxy 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 CSpeed |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CSpeed -> Int# #

sizeOf# :: CSpeed -> Int# #

alignmentOfType# :: Proxy 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 CSsize |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CSsize -> Int# #

sizeOf# :: CSsize -> Int# #

alignmentOfType# :: Proxy 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 CTcflag |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CTcflag -> Int# #

sizeOf# :: CTcflag -> Int# #

alignmentOfType# :: Proxy 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 CTimer |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CTimer -> Int# #

sizeOf# :: CTimer -> Int# #

alignmentOfType# :: Proxy CTimer -> Int# #

alignment# :: CTimer -> Int# #

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

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

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

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

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

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

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

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

Prim CUid |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy CUid -> Int# #

sizeOf# :: CUid -> Int# #

alignmentOfType# :: Proxy 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 Fd |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Fd -> Int# #

sizeOf# :: Fd -> Int# #

alignmentOfType# :: Proxy 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 Char |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Char -> Int# #

sizeOf# :: Char -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Double -> Int# #

sizeOf# :: Double -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Float -> Int# #

sizeOf# :: Float -> Int# #

alignmentOfType# :: Proxy 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 |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Int -> Int# #

sizeOf# :: Int -> Int# #

alignmentOfType# :: Proxy 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 Word |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy Word -> Int# #

sizeOf# :: Word -> Int# #

alignmentOfType# :: Proxy 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 a => Prim (Complex a) | Since: primitive-0.9.0.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Complex a) -> Int# #

sizeOf# :: Complex a -> Int# #

alignmentOfType# :: Proxy (Complex a) -> Int# #

alignment# :: Complex a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Identity a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Identity a) -> Int# #

sizeOf# :: Identity a -> Int# #

alignmentOfType# :: Proxy (Identity a) -> Int# #

alignment# :: Identity a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Down a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Down a) -> Int# #

sizeOf# :: Down a -> Int# #

alignmentOfType# :: Proxy (Down a) -> Int# #

alignment# :: Down a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (First a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (First a) -> Int# #

sizeOf# :: First a -> Int# #

alignmentOfType# :: Proxy (First a) -> Int# #

alignment# :: First a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Last a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Last a) -> Int# #

sizeOf# :: Last a -> Int# #

alignmentOfType# :: Proxy (Last a) -> Int# #

alignment# :: Last a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Max a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Max a) -> Int# #

sizeOf# :: Max a -> Int# #

alignmentOfType# :: Proxy (Max a) -> Int# #

alignment# :: Max a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Min a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Min a) -> Int# #

sizeOf# :: Min a -> Int# #

alignmentOfType# :: Proxy (Min a) -> Int# #

alignment# :: Min a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Dual a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Dual a) -> Int# #

sizeOf# :: Dual a -> Int# #

alignmentOfType# :: Proxy (Dual a) -> Int# #

alignment# :: Dual a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Product a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Product a) -> Int# #

sizeOf# :: Product a -> Int# #

alignmentOfType# :: Proxy (Product a) -> Int# #

alignment# :: Product a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Sum a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Sum a) -> Int# #

sizeOf# :: Sum a -> Int# #

alignmentOfType# :: Proxy (Sum a) -> Int# #

alignment# :: Sum a -> Int# #

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

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

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

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

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

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

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

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

Prim (FunPtr a) |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (FunPtr a) -> Int# #

sizeOf# :: FunPtr a -> Int# #

alignmentOfType# :: Proxy (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 (Ptr a) |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Ptr a) -> Int# #

sizeOf# :: Ptr a -> Int# #

alignmentOfType# :: Proxy (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 (StablePtr a) |

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (StablePtr a) -> Int# #

sizeOf# :: StablePtr a -> Int# #

alignmentOfType# :: Proxy (StablePtr a) -> Int# #

alignment# :: StablePtr a -> Int# #

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

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

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

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

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

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

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

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

Prim a => Prim (Const a b) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Const a b) -> Int# #

sizeOf# :: Const a b -> Int# #

alignmentOfType# :: Proxy (Const a b) -> Int# #

alignment# :: Const a b -> Int# #

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

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

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

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

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

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

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

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

class Monad m => PrimMonad (m :: Type -> Type) #

Class of monads which can perform primitive state-transformer actions.

Minimal complete definition

primitive

#### Instances

Instances details

PrimMonad IO |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState IO |
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld

Methods

primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a #

PrimMonad (ST s) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s

Methods

primitive :: (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)) -> ST s a #

PrimMonad (ST s) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s

Methods

primitive :: (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)) -> ST s a #

PrimMonad m => PrimMonad (MaybeT m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (MaybeT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (MaybeT m) = PrimState m

Methods

primitive :: (State# (PrimState (MaybeT m)) -> (# State# (PrimState (MaybeT m)), a #)) -> MaybeT m a #

(Monoid w, PrimMonad m) => PrimMonad (AccumT w m) | Since: primitive-0.6.3.0

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (AccumT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (AccumT w m) = PrimState m

Methods

primitive :: (State# (PrimState (AccumT w m)) -> (# State# (PrimState (AccumT w m)), a #)) -> AccumT w m a #

PrimMonad m => PrimMonad (ExceptT e m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ExceptT e m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ExceptT e m) = PrimState m

Methods

primitive :: (State# (PrimState (ExceptT e m)) -> (# State# (PrimState (ExceptT e m)), a #)) -> ExceptT e m a #

PrimMonad m => PrimMonad (IdentityT m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (IdentityT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (IdentityT m) = PrimState m

Methods

primitive :: (State# (PrimState (IdentityT m)) -> (# State# (PrimState (IdentityT m)), a #)) -> IdentityT m a #

PrimMonad m => PrimMonad (ReaderT r m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ReaderT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ReaderT r m) = PrimState m

Methods

primitive :: (State# (PrimState (ReaderT r m)) -> (# State# (PrimState (ReaderT r m)), a #)) -> ReaderT r m a #

PrimMonad m => PrimMonad (SelectT r m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (SelectT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (SelectT r m) = PrimState m

Methods

primitive :: (State# (PrimState (SelectT r m)) -> (# State# (PrimState (SelectT r m)), a #)) -> SelectT r m a #

PrimMonad m => PrimMonad (StateT s m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m

Methods

primitive :: (State# (PrimState (StateT s m)) -> (# State# (PrimState (StateT s m)), a #)) -> StateT s m a #

PrimMonad m => PrimMonad (StateT s m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m

Methods

primitive :: (State# (PrimState (StateT s m)) -> (# State# (PrimState (StateT s m)), a #)) -> StateT s m a #

(Monoid w, PrimMonad m) => PrimMonad (WriterT w m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (# State# (PrimState (WriterT w m)), a #)) -> WriterT w m a #

(Monoid w, PrimMonad m) => PrimMonad (WriterT w m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (# State# (PrimState (WriterT w m)), a #)) -> WriterT w m a #

(Monoid w, PrimMonad m) => PrimMonad (WriterT w m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (# State# (PrimState (WriterT w m)), a #)) -> WriterT w m a #

PrimMonad m => PrimMonad (ContT r m) | Since: primitive-0.6.3.0

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ContT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ContT r m) = PrimState m

Methods

primitive :: (State# (PrimState (ContT r m)) -> (# State# (PrimState (ContT r m)), a #)) -> ContT r m a #

(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (# State# (PrimState (RWST r w s m)), a #)) -> RWST r w s m a #

(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (# State# (PrimState (RWST r w s m)), a #)) -> RWST r w s m a #

(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) |

Instance details

Defined in Control.Monad.Primitive

Associated Types

type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (# State# (PrimState (RWST r w s m)), a #)) -> RWST r w s m a #

type family PrimState (m :: Type -> Type) #

State token type.

#### Instances

Instances details

type PrimState IO |
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld
type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s
type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s
type PrimState (MaybeT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (MaybeT m) = PrimState m
type PrimState (AccumT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (AccumT w m) = PrimState m
type PrimState (ExceptT e m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ExceptT e m) = PrimState m
type PrimState (IdentityT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (IdentityT m) = PrimState m
type PrimState (ReaderT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ReaderT r m) = PrimState m
type PrimState (SelectT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (SelectT r m) = PrimState m
type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
type PrimState (ContT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ContT r m) = PrimState m
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m

data RealWorld #

`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#`.