Data.Mutable

mutable-containers-0.3.4.1: Abstactions and concrete implementations of mutable containers

Safe Haskell | None
Language | Haskell2010

Data.Mutable

Contents

- Data types
  - Single-cell mutable references
    - Standard re-exports
  - Collections/queues
- Type classes
- Constraint kinds
- Convenience re-exports

Description

Classes and concrete implementations for mutable data structures.

For more information on the design of this library, see the README file, also available at http://www.stackage.org/package/mutable-containers.

Synopsis

- data PRef s a
- type IOPRef = PRef (PrimState IO)
- asPRef :: PRef s a -> PRef s a
- data URef s a
- type IOURef = URef (PrimState IO)
- asURef :: URef s a -> URef s a
- data SRef s a
- type IOSRef = SRef (PrimState IO)
- asSRef :: SRef s a -> SRef s a
- data BRef s a
- type IOBRef = BRef (PrimState IO)
- asBRef :: BRef s a -> BRef s a
- data IORef a
- asIORef :: IORef a -> IORef a
- data STRef s a
- asSTRef :: STRef s a -> STRef s a
- data MutVar s a
- asMutVar :: MutVar s a -> MutVar s a
- data Deque (v :: Type -> Type -> Type) s a
- type UDeque = Deque MVector
- asUDeque :: UDeque s a -> UDeque s a
- type SDeque = Deque MVector
- asSDeque :: SDeque s a -> SDeque s a
- type BDeque = Deque MVector
- asBDeque :: BDeque s a -> BDeque s a
- data DLList s a
- asDLList :: DLList s a -> DLList s a
- class MutableContainer c where
  - type MCState c
- class MutableContainer c => MutableRef c where
  - type RefElement c
  - newRef :: (PrimMonad m, PrimState m ~ MCState c) => RefElement c -> m c
  - readRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (RefElement c)
  - writeRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> RefElement c -> m ()
  - modifyRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m ()
  - modifyRef' :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m ()
- class MutableRef c => MutableAtomicRef c where
  - atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a
  - atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a
- class MutableContainer c => MutableCollection c where
  - type CollElement c
  - newColl :: (PrimMonad m, PrimState m ~ MCState c) => m c
- class MutableCollection c => MutablePushFront c where
  - pushFront :: (PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m ()
- class MutableCollection c => MutablePushBack c where
  - pushBack :: (PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m ()
- class MutableCollection c => MutablePopFront c where
  - popFront :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (Maybe (CollElement c))
- class MutableCollection c => MutablePopBack c where
  - popBack :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (Maybe (CollElement c))
- type MutableQueue c = (MutablePopFront c, MutablePushBack c)
- type MutableStack c = (MutablePopFront c, MutablePushFront c)
- type MutableDeque c = (MutableQueue c, MutablePushFront c, MutablePopBack c)
- class Monad m => PrimMonad (m :: Type -> Type)
- type family PrimState (m :: Type -> Type)
- data RealWorld
- class Prim a
- class (Vector Vector a, MVector MVector a) => Unbox a
- class Storable a

# Data types

## Single-cell mutable references

data PRef s a #

A primitive ByteArray reference, supporting any monad.

Since 0.2.0

#### Instances

Instances details

MutableContainer (PRef s a) # |
Instance details Defined in Data.Mutable.PRef Associated Types
type MCState (PRef s a) |
Instance details Defined in Data.Mutable.PRef type MCState (PRef s a) = s
Prim a => MutableRef (PRef s a) # |
Instance details Defined in Data.Mutable.PRef Associated Types
type RefElement (PRef s a) |
Instance details Defined in Data.Mutable.PRef type RefElement (PRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => RefElement (PRef s a) -> m (PRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> m (RefElement (PRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> RefElement (PRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> (RefElement (PRef s a) -> RefElement (PRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> (RefElement (PRef s a) -> RefElement (PRef s a)) -> m () #
type MCState (PRef s a) # |
Instance details Defined in Data.Mutable.PRef type MCState (PRef s a) = s
type RefElement (PRef s a) # |
Instance details Defined in Data.Mutable.PRef type RefElement (PRef s a) = a

type IOPRef = PRef (PrimState IO) #

A primitive ByteArray IO reference.

asPRef :: PRef s a -> PRef s a #

Since 0.2.0

data URef s a #

An unboxed vector reference, supporting any monad.

Since 0.2.0

#### Instances

Instances details

MutableContainer (URef s a) # |
Instance details Defined in Data.Mutable.URef Associated Types
type MCState (URef s a) |
Instance details Defined in Data.Mutable.URef type MCState (URef s a) = s
Unbox a => MutableRef (URef s a) # |
Instance details Defined in Data.Mutable.URef Associated Types
type RefElement (URef s a) |
Instance details Defined in Data.Mutable.URef type RefElement (URef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => RefElement (URef s a) -> m (URef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> m (RefElement (URef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> RefElement (URef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> (RefElement (URef s a) -> RefElement (URef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> (RefElement (URef s a) -> RefElement (URef s a)) -> m () #
type MCState (URef s a) # |
Instance details Defined in Data.Mutable.URef type MCState (URef s a) = s
type RefElement (URef s a) # |
Instance details Defined in Data.Mutable.URef type RefElement (URef s a) = a

type IOURef = URef (PrimState IO) #

An unboxed IO vector reference.

asURef :: URef s a -> URef s a #

Since 0.2.0

data SRef s a #

A storable vector reference, supporting any monad.

Since 0.2.0

#### Instances

Instances details

MutableContainer (SRef s a) # |
Instance details Defined in Data.Mutable.SRef Associated Types
type MCState (SRef s a) |
Instance details Defined in Data.Mutable.SRef type MCState (SRef s a) = s
Storable a => MutableRef (SRef s a) # |
Instance details Defined in Data.Mutable.SRef Associated Types
type RefElement (SRef s a) |
Instance details Defined in Data.Mutable.SRef type RefElement (SRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => RefElement (SRef s a) -> m (SRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> m (RefElement (SRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> RefElement (SRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> (RefElement (SRef s a) -> RefElement (SRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> (RefElement (SRef s a) -> RefElement (SRef s a)) -> m () #
type MCState (SRef s a) # |
Instance details Defined in Data.Mutable.SRef type MCState (SRef s a) = s
type RefElement (SRef s a) # |
Instance details Defined in Data.Mutable.SRef type RefElement (SRef s a) = a

type IOSRef = SRef (PrimState IO) #

A storable IO vector reference.

asSRef :: SRef s a -> SRef s a #

Since 0.2.0

data BRef s a #

A boxed vector reference, supporting any monad.

Since 0.2.0

#### Instances

Instances details

Monoid w => MutableCollection (BRef s w) # |
Instance details Defined in Data.Mutable.BRef Associated Types
type CollElement (BRef s w) |
Instance details Defined in Data.Mutable.BRef type CollElement (BRef s w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (BRef s w)) => m (BRef s w) #
MutableContainer (BRef s a) # |
Instance details Defined in Data.Mutable.BRef Associated Types
type MCState (BRef s a) |
Instance details Defined in Data.Mutable.BRef type MCState (BRef s a) = s
IsSequence seq => MutablePopBack (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods popBack :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> m (Maybe (CollElement (BRef s seq))) #
IsSequence seq => MutablePopFront (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods popFront :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> m (Maybe (CollElement (BRef s seq))) #
IsSequence seq => MutablePushBack (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> CollElement (BRef s seq) -> m () #
IsSequence seq => MutablePushFront (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> CollElement (BRef s seq) -> m () #
MutableRef (BRef s a) # |
Instance details Defined in Data.Mutable.BRef Associated Types
type RefElement (BRef s a) |
Instance details Defined in Data.Mutable.BRef type RefElement (BRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => RefElement (BRef s a) -> m (BRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> m (RefElement (BRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> RefElement (BRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> (RefElement (BRef s a) -> RefElement (BRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> (RefElement (BRef s a) -> RefElement (BRef s a)) -> m () #
type CollElement (BRef s w) # |
Instance details Defined in Data.Mutable.BRef type CollElement (BRef s w) = Element w
type MCState (BRef s a) # |
Instance details Defined in Data.Mutable.BRef type MCState (BRef s a) = s
type RefElement (BRef s a) # |
Instance details Defined in Data.Mutable.BRef type RefElement (BRef s a) = a

type IOBRef = BRef (PrimState IO) #

A boxed IO vector reference.

asBRef :: BRef s a -> BRef s a #

Since 0.2.0

### Standard re-exports

data IORef a #

A mutable variable in the `IO` monad.

    >>> import GHC.Internal.Data.IORef
    >>> r <- newIORef 0
    >>> readIORef r
    0
    >>> writeIORef r 1
    >>> readIORef r
    1
    >>> atomicWriteIORef r 2
    >>> readIORef r
    2
    >>> modifyIORef' r (+ 1)
    >>> readIORef r
    3
    >>> atomicModifyIORef' r (\a -> (a + 1, ()))
    >>> readIORef r
    4

See also `STRef` and `MVar`.

#### Instances

Instances details

Eq (IORef a) | Pointer equality. @since base-4.0.0.0
Instance details Defined in GHC.Internal.IORef Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #
MutableAtomicRef (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> (RefElement (IORef a), a0)) -> m a0 # atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> (RefElement (IORef a), a0)) -> m a0 #
Monoid w => MutableCollection (IORef w) # |
Instance details Defined in Data.Mutable.Class Associated Types
type CollElement (IORef w) |
Instance details Defined in Data.Mutable.Class type CollElement (IORef w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (IORef w)) => m (IORef w) #
MutableContainer (IORef a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type MCState (IORef a) |
Instance details Defined in Data.Mutable.Class type MCState (IORef a) = PrimState IO
IsSequence a => MutablePopBack (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods popBack :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> m (Maybe (CollElement (IORef a))) #
IsSequence a => MutablePopFront (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods popFront :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> m (Maybe (CollElement (IORef a))) #
IsSequence a => MutablePushBack (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> CollElement (IORef a) -> m () #
IsSequence a => MutablePushFront (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> CollElement (IORef a) -> m () #
MutableRef (IORef a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type RefElement (IORef a) |
Instance details Defined in Data.Mutable.Class type RefElement (IORef a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => RefElement (IORef a) -> m (IORef a) # readRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> m (RefElement (IORef a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> RefElement (IORef a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> RefElement (IORef a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> RefElement (IORef a)) -> m () #
type CollElement (IORef w) # |
Instance details Defined in Data.Mutable.Class type CollElement (IORef w) = Element w
type MCState (IORef a) # |
Instance details Defined in Data.Mutable.Class type MCState (IORef a) = PrimState IO
type RefElement (IORef a) # |
Instance details Defined in Data.Mutable.Class type RefElement (IORef a) = a

asIORef :: IORef a -> IORef a #

Since 0.2.0

data STRef s a #

a value of type `STRef s a` is a mutable variable in state thread `s`, containing a value of type `a`

    >>> :{
    runST (do
        ref <- newSTRef "hello"
        x <- readSTRef ref
        writeSTRef ref (x ++ "world")
        readSTRef ref )
    :}
    "helloworld"

#### Instances

Instances details

Eq (STRef s a) | Pointer equality. @since base-2.01
Instance details Defined in GHC.Internal.STRef Methods (==) :: STRef s a -> STRef s a -> Bool # (/=) :: STRef s a -> STRef s a -> Bool #
Monoid w => MutableCollection (STRef s w) # |
Instance details Defined in Data.Mutable.Class Associated Types
type CollElement (STRef s w) |
Instance details Defined in Data.Mutable.Class type CollElement (STRef s w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (STRef s w)) => m (STRef s w) #
MutableContainer (STRef s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type MCState (STRef s a) |
Instance details Defined in Data.Mutable.Class type MCState (STRef s a) = s
IsSequence a => MutablePopBack (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods popBack :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> m (Maybe (CollElement (STRef s a))) #
IsSequence a => MutablePopFront (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods popFront :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> m (Maybe (CollElement (STRef s a))) #
IsSequence a => MutablePushBack (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> CollElement (STRef s a) -> m () #
IsSequence a => MutablePushFront (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> CollElement (STRef s a) -> m () #
MutableRef (STRef s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type RefElement (STRef s a) |
Instance details Defined in Data.Mutable.Class type RefElement (STRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => RefElement (STRef s a) -> m (STRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> m (RefElement (STRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> RefElement (STRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> (RefElement (STRef s a) -> RefElement (STRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> (RefElement (STRef s a) -> RefElement (STRef s a)) -> m () #
type CollElement (STRef s w) # |
Instance details Defined in Data.Mutable.Class type CollElement (STRef s w) = Element w
type MCState (STRef s a) # |
Instance details Defined in Data.Mutable.Class type MCState (STRef s a) = s
type RefElement (STRef s a) # |
Instance details Defined in Data.Mutable.Class type RefElement (STRef s a) = a

asSTRef :: STRef s a -> STRef s a #

Since 0.2.0

data MutVar s a #

A `MutVar` behaves like a single-element mutable array associated with a primitive state token.

#### Instances

Instances details

Eq (MutVar s a) |
Instance details Defined in Data.Primitive.MutVar Methods (==) :: MutVar s a -> MutVar s a -> Bool # (/=) :: MutVar s a -> MutVar s a -> Bool #
MutableAtomicRef (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a0)) -> m a0 # atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a0)) -> m a0 #
Monoid w => MutableCollection (MutVar s w) # |
Instance details Defined in Data.Mutable.Class Associated Types
type CollElement (MutVar s w) |
Instance details Defined in Data.Mutable.Class type CollElement (MutVar s w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (MutVar s w)) => m (MutVar s w) #
MutableContainer (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type MCState (MutVar s a) |
Instance details Defined in Data.Mutable.Class type MCState (MutVar s a) = s
IsSequence a => MutablePopBack (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods popBack :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> m (Maybe (CollElement (MutVar s a))) #
IsSequence a => MutablePopFront (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods popFront :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> m (Maybe (CollElement (MutVar s a))) #
IsSequence a => MutablePushBack (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> CollElement (MutVar s a) -> m () #
IsSequence a => MutablePushFront (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> CollElement (MutVar s a) -> m () #
MutableRef (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type RefElement (MutVar s a) |
Instance details Defined in Data.Mutable.Class type RefElement (MutVar s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => RefElement (MutVar s a) -> m (MutVar s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> m (RefElement (MutVar s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> RefElement (MutVar s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> RefElement (MutVar s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> RefElement (MutVar s a)) -> m () #
type CollElement (MutVar s w) # |
Instance details Defined in Data.Mutable.Class type CollElement (MutVar s w) = Element w
type MCState (MutVar s a) # |
Instance details Defined in Data.Mutable.Class type MCState (MutVar s a) = s
type RefElement (MutVar s a) # |
Instance details Defined in Data.Mutable.Class type RefElement (MutVar s a) = a

asMutVar :: MutVar s a -> MutVar s a #

Since 0.2.0

## Collections/queues

data Deque (v :: Type -> Type -> Type) s a #

A double-ended queue supporting any underlying vector type and any monad.

This implements a circular double-ended queue with exponential growth.

Since 0.2.0

#### Instances

Instances details

MVector v a => MutableCollection (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Associated Types
type CollElement (Deque v s a) |
Instance details Defined in Data.Mutable.Deque type CollElement (Deque v s a) = a
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => m (Deque v s a) #
MutableContainer (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Associated Types
type MCState (Deque v s a) |
Instance details Defined in Data.Mutable.Deque type MCState (Deque v s a) = s
MVector v a => MutablePopBack (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods popBack :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> m (Maybe (CollElement (Deque v s a))) #
MVector v a => MutablePopFront (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods popFront :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> m (Maybe (CollElement (Deque v s a))) #
MVector v a => MutablePushBack (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> CollElement (Deque v s a) -> m () #
MVector v a => MutablePushFront (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> CollElement (Deque v s a) -> m () #
type CollElement (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque type CollElement (Deque v s a) = a
type MCState (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque type MCState (Deque v s a) = s

type UDeque = Deque MVector #

A `Deque` specialized to unboxed vectors.

Since 0.2.0

asUDeque :: UDeque s a -> UDeque s a #

Since 0.2.0

type SDeque = Deque MVector #

A `Deque` specialized to storable vectors.

Since 0.2.0

asSDeque :: SDeque s a -> SDeque s a #

Since 0.2.0

type BDeque = Deque MVector #

A `Deque` specialized to boxed vectors.

Since 0.2.0

asBDeque :: BDeque s a -> BDeque s a #

Since 0.2.0

data DLList s a #

A doubly-linked list.

Since 0.3.0

#### Instances

Instances details

MutableCollection (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Associated Types
type CollElement (DLList s a) |
Instance details Defined in Data.Mutable.DLList type CollElement (DLList s a) = a
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => m (DLList s a) #
MutableContainer (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Associated Types
type MCState (DLList s a) |
Instance details Defined in Data.Mutable.DLList type MCState (DLList s a) = s
MutablePopBack (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods popBack :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> m (Maybe (CollElement (DLList s a))) #
MutablePopFront (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods popFront :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> m (Maybe (CollElement (DLList s a))) #
MutablePushBack (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> CollElement (DLList s a) -> m () #
MutablePushFront (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> CollElement (DLList s a) -> m () #
type CollElement (DLList s a) # |
Instance details Defined in Data.Mutable.DLList type CollElement (DLList s a) = a
type MCState (DLList s a) # |
Instance details Defined in Data.Mutable.DLList type MCState (DLList s a) = s

asDLList :: DLList s a -> DLList s a #

Since 0.2.0

# Type classes

class MutableContainer c #

The parent typeclass for all mutable containers.

Since 0.2.0

Associated Types

type MCState c #

Associated type giving the primitive state token for the given container, much like `PrimState` from primitive.

Since 0.2.0

#### Instances

Instances details

MutableContainer (IORef a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type MCState (IORef a) |
Instance details Defined in Data.Mutable.Class type MCState (IORef a) = PrimState IO
MutableContainer (STRef s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type MCState (STRef s a) |
Instance details Defined in Data.Mutable.Class type MCState (STRef s a) = s
MutableContainer (BRef s a) # |
Instance details Defined in Data.Mutable.BRef Associated Types
type MCState (BRef s a) |
Instance details Defined in Data.Mutable.BRef type MCState (BRef s a) = s
MutableContainer (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Associated Types
type MCState (DLList s a) |
Instance details Defined in Data.Mutable.DLList type MCState (DLList s a) = s
MutableContainer (PRef s a) # |
Instance details Defined in Data.Mutable.PRef Associated Types
type MCState (PRef s a) |
Instance details Defined in Data.Mutable.PRef type MCState (PRef s a) = s
MutableContainer (SRef s a) # |
Instance details Defined in Data.Mutable.SRef Associated Types
type MCState (SRef s a) |
Instance details Defined in Data.Mutable.SRef type MCState (SRef s a) = s
MutableContainer (URef s a) # |
Instance details Defined in Data.Mutable.URef Associated Types
type MCState (URef s a) |
Instance details Defined in Data.Mutable.URef type MCState (URef s a) = s
MutableContainer (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type MCState (MutVar s a) |
Instance details Defined in Data.Mutable.Class type MCState (MutVar s a) = s
MutableContainer (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Associated Types
type MCState (Deque v s a) |
Instance details Defined in Data.Mutable.Deque type MCState (Deque v s a) = s

class MutableContainer c => MutableRef c where #

Typeclass for single-cell mutable references.

Since 0.2.0

Associated Types

type RefElement c #

Associated type giving the type of the value inside the mutable reference.

Since 0.2.0

Methods

newRef :: (PrimMonad m, PrimState m ~ MCState c) => RefElement c -> m c #

Create a new mutable reference with the given value.

Since 0.2.0

readRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (RefElement c) #

Read the current value in the mutable reference.

Since 0.2.0

writeRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> RefElement c -> m () #

Write a new value to the mutable reference.

Since 0.2.0

modifyRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m () #

Modify the value in the mutable reference, without necessarily forcing the result.

Note: some implementations will force the result, in particular `PRef`, `SRef`, and `URef`.

Since 0.2.0

modifyRef' :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m () #

Modify the value in the mutable reference, forcing the result.

Since 0.2.0

#### Instances

Instances details

MutableRef (IORef a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type RefElement (IORef a) |
Instance details Defined in Data.Mutable.Class type RefElement (IORef a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => RefElement (IORef a) -> m (IORef a) # readRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> m (RefElement (IORef a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> RefElement (IORef a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> RefElement (IORef a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> RefElement (IORef a)) -> m () #
MutableRef (STRef s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type RefElement (STRef s a) |
Instance details Defined in Data.Mutable.Class type RefElement (STRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => RefElement (STRef s a) -> m (STRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> m (RefElement (STRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> RefElement (STRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> (RefElement (STRef s a) -> RefElement (STRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> (RefElement (STRef s a) -> RefElement (STRef s a)) -> m () #
MutableRef (BRef s a) # |
Instance details Defined in Data.Mutable.BRef Associated Types
type RefElement (BRef s a) |
Instance details Defined in Data.Mutable.BRef type RefElement (BRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => RefElement (BRef s a) -> m (BRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> m (RefElement (BRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> RefElement (BRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> (RefElement (BRef s a) -> RefElement (BRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (BRef s a)) => BRef s a -> (RefElement (BRef s a) -> RefElement (BRef s a)) -> m () #
Prim a => MutableRef (PRef s a) # |
Instance details Defined in Data.Mutable.PRef Associated Types
type RefElement (PRef s a) |
Instance details Defined in Data.Mutable.PRef type RefElement (PRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => RefElement (PRef s a) -> m (PRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> m (RefElement (PRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> RefElement (PRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> (RefElement (PRef s a) -> RefElement (PRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (PRef s a)) => PRef s a -> (RefElement (PRef s a) -> RefElement (PRef s a)) -> m () #
Storable a => MutableRef (SRef s a) # |
Instance details Defined in Data.Mutable.SRef Associated Types
type RefElement (SRef s a) |
Instance details Defined in Data.Mutable.SRef type RefElement (SRef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => RefElement (SRef s a) -> m (SRef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> m (RefElement (SRef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> RefElement (SRef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> (RefElement (SRef s a) -> RefElement (SRef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (SRef s a)) => SRef s a -> (RefElement (SRef s a) -> RefElement (SRef s a)) -> m () #
Unbox a => MutableRef (URef s a) # |
Instance details Defined in Data.Mutable.URef Associated Types
type RefElement (URef s a) |
Instance details Defined in Data.Mutable.URef type RefElement (URef s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => RefElement (URef s a) -> m (URef s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> m (RefElement (URef s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> RefElement (URef s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> (RefElement (URef s a) -> RefElement (URef s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (URef s a)) => URef s a -> (RefElement (URef s a) -> RefElement (URef s a)) -> m () #
MutableRef (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Associated Types
type RefElement (MutVar s a) |
Instance details Defined in Data.Mutable.Class type RefElement (MutVar s a) = a
Methods newRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => RefElement (MutVar s a) -> m (MutVar s a) # readRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> m (RefElement (MutVar s a)) # writeRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> RefElement (MutVar s a) -> m () # modifyRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> RefElement (MutVar s a)) -> m () # modifyRef' :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> RefElement (MutVar s a)) -> m () #

class MutableRef c => MutableAtomicRef c where #

`MutableRef`s that provide for atomic modifications of their contents.

Since 0.2.0

Methods

atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a #

Modify the value without necessarily forcing the result.

Since 0.2.0

atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a #

Modify the value, forcing the result.

Since 0.2.0

#### Instances

Instances details

MutableAtomicRef (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> (RefElement (IORef a), a0)) -> m a0 # atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> (RefElement (IORef a) -> (RefElement (IORef a), a0)) -> m a0 #
MutableAtomicRef (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a0)) -> m a0 # atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a0)) -> m a0 #

class MutableContainer c => MutableCollection c where #

Containers which contain 0 or more values.

Since 0.2.0

Associated Types

type CollElement c #

The type of each value in the collection.

Since 0.2.0

Methods

newColl :: (PrimMonad m, PrimState m ~ MCState c) => m c #

Create a new, empty collection.

Since 0.2.0

#### Instances

Instances details

Monoid w => MutableCollection (IORef w) # |
Instance details Defined in Data.Mutable.Class Associated Types
type CollElement (IORef w) |
Instance details Defined in Data.Mutable.Class type CollElement (IORef w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (IORef w)) => m (IORef w) #
Monoid w => MutableCollection (STRef s w) # |
Instance details Defined in Data.Mutable.Class Associated Types
type CollElement (STRef s w) |
Instance details Defined in Data.Mutable.Class type CollElement (STRef s w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (STRef s w)) => m (STRef s w) #
Monoid w => MutableCollection (BRef s w) # |
Instance details Defined in Data.Mutable.BRef Associated Types
type CollElement (BRef s w) |
Instance details Defined in Data.Mutable.BRef type CollElement (BRef s w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (BRef s w)) => m (BRef s w) #
MutableCollection (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Associated Types
type CollElement (DLList s a) |
Instance details Defined in Data.Mutable.DLList type CollElement (DLList s a) = a
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => m (DLList s a) #
Monoid w => MutableCollection (MutVar s w) # |
Instance details Defined in Data.Mutable.Class Associated Types
type CollElement (MutVar s w) |
Instance details Defined in Data.Mutable.Class type CollElement (MutVar s w) = Element w
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (MutVar s w)) => m (MutVar s w) #
MVector v a => MutableCollection (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Associated Types
type CollElement (Deque v s a) |
Instance details Defined in Data.Mutable.Deque type CollElement (Deque v s a) = a
Methods newColl :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => m (Deque v s a) #

class MutableCollection c => MutablePushFront c where #

Place a value at the front of the collection.

Since 0.2.0

Methods

pushFront :: (PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m () #

Place a value at the front of the collection.

Since 0.2.0

#### Instances

Instances details

IsSequence a => MutablePushFront (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> CollElement (IORef a) -> m () #
IsSequence a => MutablePushFront (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> CollElement (STRef s a) -> m () #
IsSequence seq => MutablePushFront (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> CollElement (BRef s seq) -> m () #
MutablePushFront (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> CollElement (DLList s a) -> m () #
IsSequence a => MutablePushFront (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> CollElement (MutVar s a) -> m () #
MVector v a => MutablePushFront (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods pushFront :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> CollElement (Deque v s a) -> m () #

class MutableCollection c => MutablePushBack c where #

Place a value at the back of the collection.

Since 0.2.0

Methods

pushBack :: (PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m () #

Place a value at the back of the collection.

Since 0.2.0

#### Instances

Instances details

IsSequence a => MutablePushBack (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> CollElement (IORef a) -> m () #
IsSequence a => MutablePushBack (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> CollElement (STRef s a) -> m () #
IsSequence seq => MutablePushBack (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> CollElement (BRef s seq) -> m () #
MutablePushBack (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> CollElement (DLList s a) -> m () #
IsSequence a => MutablePushBack (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> CollElement (MutVar s a) -> m () #
MVector v a => MutablePushBack (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods pushBack :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> CollElement (Deque v s a) -> m () #

class MutableCollection c => MutablePopFront c where #

Take a value from the front of the collection, if available.

Since 0.2.0

Methods

popFront :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (Maybe (CollElement c)) #

Take a value from the front of the collection, if available.

Since 0.2.0

#### Instances

Instances details

IsSequence a => MutablePopFront (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods popFront :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> m (Maybe (CollElement (IORef a))) #
IsSequence a => MutablePopFront (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods popFront :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> m (Maybe (CollElement (STRef s a))) #
IsSequence seq => MutablePopFront (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods popFront :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> m (Maybe (CollElement (BRef s seq))) #
MutablePopFront (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods popFront :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> m (Maybe (CollElement (DLList s a))) #
IsSequence a => MutablePopFront (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods popFront :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> m (Maybe (CollElement (MutVar s a))) #
MVector v a => MutablePopFront (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods popFront :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> m (Maybe (CollElement (Deque v s a))) #

class MutableCollection c => MutablePopBack c where #

Take a value from the back of the collection, if available.

Since 0.2.0

Methods

popBack :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (Maybe (CollElement c)) #

Take a value from the back of the collection, if available.

Since 0.2.0

#### Instances

Instances details

IsSequence a => MutablePopBack (IORef a) # |
Instance details Defined in Data.Mutable.Class Methods popBack :: (PrimMonad m, PrimState m ~ MCState (IORef a)) => IORef a -> m (Maybe (CollElement (IORef a))) #
IsSequence a => MutablePopBack (STRef s a) # |
Instance details Defined in Data.Mutable.Class Methods popBack :: (PrimMonad m, PrimState m ~ MCState (STRef s a)) => STRef s a -> m (Maybe (CollElement (STRef s a))) #
IsSequence seq => MutablePopBack (BRef s seq) # |
Instance details Defined in Data.Mutable.BRef Methods popBack :: (PrimMonad m, PrimState m ~ MCState (BRef s seq)) => BRef s seq -> m (Maybe (CollElement (BRef s seq))) #
MutablePopBack (DLList s a) # |
Instance details Defined in Data.Mutable.DLList Methods popBack :: (PrimMonad m, PrimState m ~ MCState (DLList s a)) => DLList s a -> m (Maybe (CollElement (DLList s a))) #
IsSequence a => MutablePopBack (MutVar s a) # |
Instance details Defined in Data.Mutable.Class Methods popBack :: (PrimMonad m, PrimState m ~ MCState (MutVar s a)) => MutVar s a -> m (Maybe (CollElement (MutVar s a))) #
MVector v a => MutablePopBack (Deque v s a) # |
Instance details Defined in Data.Mutable.Deque Methods popBack :: (PrimMonad m, PrimState m ~ MCState (Deque v s a)) => Deque v s a -> m (Maybe (CollElement (Deque v s a))) #

# Constraint kinds

type MutableQueue c = (MutablePopFront c, MutablePushBack c) #

Collections which allow pushing and popping at the front (aka FIFOs).

Since 0.2.0

type MutableStack c = (MutablePopFront c, MutablePushFront c) #

Collections which allow pushing at the back and popping at the front (aka FILOs).

Since 0.2.0

type MutableDeque c = (MutableQueue c, MutablePushFront c, MutablePopBack c) #

Collections which allow pushing and popping at the front and back.

Since 0.2.0

# Convenience re-exports

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

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 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 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 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 (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 (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 (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 (Vector Vector a, MVector MVector a) => Unbox a #

#### Instances

Instances details

Unbox All |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Any |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int16 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int32 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int64 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int8 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word16 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word32 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word64 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word8 |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox () |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Bool |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Char |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Double |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Float |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Complex a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (First a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Last a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Max a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Min a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (WrappedMonoid a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Identity a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Down a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Dual a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Product a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Sum a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (DoNotUnboxLazy a) |
Instance details Defined in Data.Vector.Unboxed.Base
NFData a => Unbox (DoNotUnboxNormalForm a) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (DoNotUnboxStrict a) |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (Arg a b) |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (a, b) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Const a b) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (f a) => Unbox (Alt f a) |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (f (g a)) => Unbox (Compose f g a) |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e) |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f) |
Instance details Defined in Data.Vector.Unboxed.Base

class Storable a #

The member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.

Memory addresses are represented as values of type ``Ptr` a`, for some `a` which is an instance of class `Storable`. The type argument to `Ptr` helps provide some valuable type safety in FFI code (you can't mix pointers of different types without an explicit cast), while helping the Haskell type system figure out which marshalling method is needed for a given pointer.

All marshalling between Haskell and a foreign language ultimately boils down to translating Haskell data structures into the binary representation of a corresponding data structure of the foreign language and vice versa. To code this marshalling in Haskell, it is necessary to manipulate primitive data types stored in unstructured memory blocks. The class `Storable` facilitates this manipulation on all types for which it is instantiated, which are the standard basic types of Haskell, the fixed size `Int` types (`Int8`, `Int16`, `Int32`, `Int64`), the fixed size `Word` types (`Word8`, `Word16`, `Word32`, `Word64`), `StablePtr`, all types from Foreign.C.Types, as well as `Ptr`.

Minimal complete definition

sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff)

#### Instances

Instances details

Storable Fingerprint | @since base-4.4.0.0
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Fingerprint -> Int # alignment :: Fingerprint -> Int # peekElemOff :: Ptr Fingerprint -> Int -> IO Fingerprint # pokeElemOff :: Ptr Fingerprint -> Int -> Fingerprint -> IO () # peekByteOff :: Ptr b -> Int -> IO Fingerprint # pokeByteOff :: Ptr b -> Int -> Fingerprint -> IO () # peek :: Ptr Fingerprint -> IO Fingerprint # poke :: Ptr Fingerprint -> Fingerprint -> IO () #
Storable Int16 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Int16 -> Int # alignment :: Int16 -> Int # peekElemOff :: Ptr Int16 -> Int -> IO Int16 # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int16 # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () # peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Storable Int32 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Storable Int64 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Storable Int8 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Int8 -> Int # alignment :: Int8 -> Int # peekElemOff :: Ptr Int8 -> Int -> IO Int8 # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int8 # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () # peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Storable Word16 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Word16 -> Int # alignment :: Word16 -> Int # peekElemOff :: Ptr Word16 -> Int -> IO Word16 # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word16 # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () # peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Storable Word32 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Storable Word64 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Storable Word8 | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Word8 -> Int # alignment :: Word8 -> Int # peekElemOff :: Ptr Word8 -> Int -> IO Word8 # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word8 # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () # peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Storable () | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: () -> Int # alignment :: () -> Int # peekElemOff :: Ptr () -> Int -> IO () # pokeElemOff :: Ptr () -> Int -> () -> IO () # peekByteOff :: Ptr b -> Int -> IO () # pokeByteOff :: Ptr b -> Int -> () -> IO () # peek :: Ptr () -> IO () # poke :: Ptr () -> () -> IO () #
Storable Bool | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Storable Char | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Char -> Int # alignment :: Char -> Int # peekElemOff :: Ptr Char -> Int -> IO Char # pokeElemOff :: Ptr Char -> Int -> Char -> IO () # peekByteOff :: Ptr b -> Int -> IO Char # pokeByteOff :: Ptr b -> Int -> Char -> IO () # peek :: Ptr Char -> IO Char # poke :: Ptr Char -> Char -> IO () #
Storable Double | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
Storable Float | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
Storable Int | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Int -> Int # alignment :: Int -> Int # peekElemOff :: Ptr Int -> Int -> IO Int # pokeElemOff :: Ptr Int -> Int -> Int -> IO () # peekByteOff :: Ptr b -> Int -> IO Int # pokeByteOff :: Ptr b -> Int -> Int -> IO () # peek :: Ptr Int -> IO Int # poke :: Ptr Int -> Int -> IO () #
Storable Word | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Word -> Int # alignment :: Word -> Int # peekElemOff :: Ptr Word -> Int -> IO Word # pokeElemOff :: Ptr Word -> Int -> Word -> IO () # peekByteOff :: Ptr b -> Int -> IO Word # pokeByteOff :: Ptr b -> Int -> Word -> IO () # peek :: Ptr Word -> IO Word # poke :: Ptr Word -> Word -> IO () #
Storable a => Storable (Complex a) | Since: base-4.8.0.0
Instance details Defined in Data.Complex Methods sizeOf :: Complex a -> Int # alignment :: Complex a -> Int # peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) # pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Complex a) # pokeByteOff :: Ptr b -> Int -> Complex a -> IO () # peek :: Ptr (Complex a) -> IO (Complex a) # poke :: Ptr (Complex a) -> Complex a -> IO () #
Storable (ConstPtr a) |
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: ConstPtr a -> Int # alignment :: ConstPtr a -> Int # peekElemOff :: Ptr (ConstPtr a) -> Int -> IO (ConstPtr a) # pokeElemOff :: Ptr (ConstPtr a) -> Int -> ConstPtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (ConstPtr a) # pokeByteOff :: Ptr b -> Int -> ConstPtr a -> IO () # peek :: Ptr (ConstPtr a) -> IO (ConstPtr a) # poke :: Ptr (ConstPtr a) -> ConstPtr a -> IO () #
Storable (FunPtr a) | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: FunPtr a -> Int # alignment :: FunPtr a -> Int # peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) # pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (FunPtr a) # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () # peek :: Ptr (FunPtr a) -> IO (FunPtr a) # poke :: Ptr (FunPtr a) -> FunPtr a -> IO () #
Storable (Ptr a) | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Ptr a -> Int # alignment :: Ptr a -> Int # peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) # pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Ptr a) # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () # peek :: Ptr (Ptr a) -> IO (Ptr a) # poke :: Ptr (Ptr a) -> Ptr a -> IO () #
(Storable a, Integral a) => Storable (Ratio a) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Ratio a -> Int # alignment :: Ratio a -> Int # peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a) # pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Ratio a) # pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () # peek :: Ptr (Ratio a) -> IO (Ratio a) # poke :: Ptr (Ratio a) -> Ratio a -> IO () #
Storable (StablePtr a) | @since base-2.01
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: StablePtr a -> Int # alignment :: StablePtr a -> Int # peekElemOff :: Ptr (StablePtr a) -> Int -> IO (StablePtr a) # pokeElemOff :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (StablePtr a) # pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO () # peek :: Ptr (StablePtr a) -> IO (StablePtr a) # poke :: Ptr (StablePtr a) -> StablePtr a -> IO () #
Prim a => Storable (PrimStorable a) |
Instance details Defined in Data.Primitive.Types Methods sizeOf :: PrimStorable a -> Int # alignment :: PrimStorable a -> Int # peekElemOff :: Ptr (PrimStorable a) -> Int -> IO (PrimStorable a) # pokeElemOff :: Ptr (PrimStorable a) -> Int -> PrimStorable a -> IO () # peekByteOff :: Ptr b -> Int -> IO (PrimStorable a) # pokeByteOff :: Ptr b -> Int -> PrimStorable a -> IO () # peek :: Ptr (PrimStorable a) -> IO (PrimStorable a) # poke :: Ptr (PrimStorable a) -> PrimStorable a -> IO () #