Data.Mutable

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.

Data types

Single-cell mutable references

data PRef s a

A primitive ByteArray reference, supporting any monad.

Since 0.2.0

Instances

Prim a => MutableRef (PRef s a)

Associated Types

type RefElement (PRef s 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 ()

MutableContainer (PRef s a)

Associated Types

type MCState (PRef s a) :: *

type RefElement (PRef s a)

type RefElement (PRef s a) = a

type MCState (PRef s a)

type MCState (PRef s a) = s

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

Unbox a => MutableRef (URef s a)

Associated Types

type RefElement (URef s 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 ()

MutableContainer (URef s a)

Associated Types

type MCState (URef s a) :: *

type RefElement (URef s a)

type RefElement (URef s a) = a

type MCState (URef s a)

type MCState (URef s a) = s

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

Storable a => MutableRef (SRef s a)

Associated Types

type RefElement (SRef s 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 ()

MutableContainer (SRef s a)

Associated Types

type MCState (SRef s a) :: *

type RefElement (SRef s a)

type RefElement (SRef s a) = a

type MCState (SRef s a)

type MCState (SRef s a) = s

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

IsSequence seq => MutablePushBack (BRef s seq)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> CollElement (BRef s seq) -> m ()

IsSequence seq => MutablePopBack (BRef s seq)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> m (Maybe (CollElement (BRef s seq)))

IsSequence seq => MutablePushFront (BRef s seq)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> CollElement (BRef s seq) -> m ()

IsSequence seq => MutablePopFront (BRef s seq)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> m (Maybe (CollElement (BRef s seq)))

Monoid w => MutableCollection (BRef s w)

Associated Types

type CollElement (BRef s w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s w))) => m (BRef s w)

MutableRef (BRef s a)

Associated Types

type RefElement (BRef s 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 ()

MutableContainer (BRef s a)

Associated Types

type MCState (BRef s a) :: *

type CollElement (BRef s w)

type CollElement (BRef s w) = Element w

type RefElement (BRef s a)

type RefElement (BRef s a) = a

type MCState (BRef s a)

type MCState (BRef s a) = s

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

Instances

Eq (IORef a)

Since: 4.1.0.0

Methods

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

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

IsSequence a => MutablePushBack (IORef a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> CollElement (IORef a) -> m ()

IsSequence a => MutablePopBack (IORef a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> m (Maybe (CollElement (IORef a)))

IsSequence a => MutablePushFront (IORef a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> CollElement (IORef a) -> m ()

IsSequence a => MutablePopFront (IORef a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> m (Maybe (CollElement (IORef a)))

Monoid w => MutableCollection (IORef w)

Associated Types

type CollElement (IORef w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef w))) => m (IORef w)

MutableAtomicRef (IORef a)

Methods

atomicModifyRef :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> (RefElement (IORef a) -> (RefElement (IORef a), a)) -> m a

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

MutableRef (IORef a)

Associated Types

type RefElement (IORef 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 ()

MutableContainer (IORef a)

Associated Types

type MCState (IORef a) :: *

type CollElement (IORef w)

type CollElement (IORef w) = Element w

type RefElement (IORef a)

type RefElement (IORef a) = a

type MCState (IORef a)

type MCState (IORef a) = PrimState IO

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

Instances

Eq (STRef s a)

Since: 2.1

Methods

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

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

IsSequence a => MutablePushBack (STRef s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> CollElement (STRef s a) -> m ()

IsSequence a => MutablePopBack (STRef s a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> m (Maybe (CollElement (STRef s a)))

IsSequence a => MutablePushFront (STRef s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> CollElement (STRef s a) -> m ()

IsSequence a => MutablePopFront (STRef s a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> m (Maybe (CollElement (STRef s a)))

Monoid w => MutableCollection (STRef s w)

Associated Types

type CollElement (STRef s w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s w))) => m (STRef s w)

MutableRef (STRef s a)

Associated Types

type RefElement (STRef s 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 ()

MutableContainer (STRef s a)

Associated Types

type MCState (STRef s a) :: *

type CollElement (STRef s w)

type CollElement (STRef s w) = Element w

type RefElement (STRef s a)

type RefElement (STRef s a) = a

type MCState (STRef s a)

type MCState (STRef s a) = s

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

Eq (MutVar s a)

Methods

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

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

IsSequence a => MutablePushBack (MutVar s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> CollElement (MutVar s a) -> m ()

IsSequence a => MutablePopBack (MutVar s a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> m (Maybe (CollElement (MutVar s a)))

IsSequence a => MutablePushFront (MutVar s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> CollElement (MutVar s a) -> m ()

IsSequence a => MutablePopFront (MutVar s a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> m (Maybe (CollElement (MutVar s a)))

Monoid w => MutableCollection (MutVar s w)

Associated Types

type CollElement (MutVar s w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s w))) => m (MutVar s w)

MutableAtomicRef (MutVar s a)

Methods

atomicModifyRef :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a)) -> m a

atomicModifyRef' :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a)) -> m a

MutableRef (MutVar s a)

Associated Types

type RefElement (MutVar s 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 ()

MutableContainer (MutVar s a)

Associated Types

type MCState (MutVar s a) :: *

type CollElement (MutVar s w)

type CollElement (MutVar s w) = Element w

type RefElement (MutVar s a)

type RefElement (MutVar s a) = a

type MCState (MutVar s a)

type MCState (MutVar s a) = s

asMutVar :: MutVar s a -> MutVar s a

Since 0.2.0

Collections/queues

data Deque v 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

MVector v a => MutablePushBack (Deque v s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (Deque v s a))) => Deque v s a -> CollElement (Deque v s a) -> m ()

MVector v a => MutablePopBack (Deque v s a)

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 => MutablePushFront (Deque v s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (Deque v s a))) => Deque v s a -> CollElement (Deque v s a) -> m ()

MVector v a => MutablePopFront (Deque v s a)

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 => MutableCollection (Deque v s a)

Associated Types

type CollElement (Deque v s a) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (Deque v s a))) => m (Deque v s a)

MutableContainer (Deque v s a)

Associated Types

type MCState (Deque v s a) :: *

type CollElement (Deque v s a)

type CollElement (Deque v s a) = a

type MCState (Deque v s a)

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

MutablePushBack (DLList s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> CollElement (DLList s a) -> m ()

MutablePopBack (DLList s a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> m (Maybe (CollElement (DLList s a)))

MutablePushFront (DLList s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> CollElement (DLList s a) -> m ()

MutablePopFront (DLList s a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> m (Maybe (CollElement (DLList s a)))

MutableCollection (DLList s a)

Associated Types

type CollElement (DLList s a) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => m (DLList s a)

MutableContainer (DLList s a)

Associated Types

type MCState (DLList s a) :: *

type CollElement (DLList s a)

type CollElement (DLList s a) = a

type MCState (DLList s a)

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

MutableContainer (IORef a)

Associated Types

type MCState (IORef a) :: *

MutableContainer (STRef s a)

Associated Types

type MCState (STRef s a) :: *

MutableContainer (MutVar s a)

Associated Types

type MCState (MutVar s a) :: *

MutableContainer (BRef s a)

Associated Types

type MCState (BRef s a) :: *

MutableContainer (DLList s a)

Associated Types

type MCState (DLList s a) :: *

MutableContainer (PRef s a)

Associated Types

type MCState (PRef s a) :: *

MutableContainer (SRef s a)

Associated Types

type MCState (SRef s a) :: *

MutableContainer (URef s a)

Associated Types

type MCState (URef s a) :: *

MutableContainer (Deque v s a)

Associated Types

type MCState (Deque v s a) :: *

class MutableContainer c => MutableRef c where

Typeclass for single-cell mutable references.

Since 0.2.0

Minimal complete definition

newRef, readRef, writeRef, modifyRef, modifyRef'

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

MutableRef (IORef a)

Associated Types

type RefElement (IORef 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)

Associated Types

type RefElement (STRef s 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 (MutVar s a)

Associated Types

type RefElement (MutVar s 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 ()

MutableRef (BRef s a)

Associated Types

type RefElement (BRef s 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)

Associated Types

type RefElement (PRef s 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)

Associated Types

type RefElement (SRef s 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)

Associated Types

type RefElement (URef s 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 ()

class MutableRef c => MutableAtomicRef c where

MutableRefs that provide for atomic modifications of their contents.

Since 0.2.0

Minimal complete definition

atomicModifyRef, atomicModifyRef'

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

MutableAtomicRef (IORef a)

Methods

atomicModifyRef :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> (RefElement (IORef a) -> (RefElement (IORef a), a)) -> m a

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

MutableAtomicRef (MutVar s a)

Methods

atomicModifyRef :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a)) -> m a

atomicModifyRef' :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> (RefElement (MutVar s a) -> (RefElement (MutVar s a), a)) -> m a

class MutableContainer c => MutableCollection c where

Containers which contain 0 or more values.

Since 0.2.0

Minimal complete definition

newColl

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

Monoid w => MutableCollection (IORef w)

Associated Types

type CollElement (IORef w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef w))) => m (IORef w)

Monoid w => MutableCollection (STRef s w)

Associated Types

type CollElement (STRef s w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s w))) => m (STRef s w)

Monoid w => MutableCollection (MutVar s w)

Associated Types

type CollElement (MutVar s w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s w))) => m (MutVar s w)

Monoid w => MutableCollection (BRef s w)

Associated Types

type CollElement (BRef s w) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s w))) => m (BRef s w)

MutableCollection (DLList s a)

Associated Types

type CollElement (DLList s a) :: *

Methods

newColl :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => m (DLList s a)

MVector v a => MutableCollection (Deque v s a)

Associated Types

type CollElement (Deque v s 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

Minimal complete definition

pushFront

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

IsSequence a => MutablePushFront (IORef a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> CollElement (IORef a) -> m ()

IsSequence a => MutablePushFront (STRef s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> CollElement (STRef s a) -> m ()

IsSequence a => MutablePushFront (MutVar s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> CollElement (MutVar s a) -> m ()

IsSequence seq => MutablePushFront (BRef s seq)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> CollElement (BRef s seq) -> m ()

MutablePushFront (DLList s a)

Methods

pushFront :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> CollElement (DLList s a) -> m ()

MVector v a => MutablePushFront (Deque v s a)

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

Minimal complete definition

pushBack

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

IsSequence a => MutablePushBack (IORef a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> CollElement (IORef a) -> m ()

IsSequence a => MutablePushBack (STRef s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> CollElement (STRef s a) -> m ()

IsSequence a => MutablePushBack (MutVar s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> CollElement (MutVar s a) -> m ()

IsSequence seq => MutablePushBack (BRef s seq)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> CollElement (BRef s seq) -> m ()

MutablePushBack (DLList s a)

Methods

pushBack :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> CollElement (DLList s a) -> m ()

MVector v a => MutablePushBack (Deque v s a)

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

Minimal complete definition

popFront

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

IsSequence a => MutablePopFront (IORef a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> m (Maybe (CollElement (IORef a)))

IsSequence a => MutablePopFront (STRef s a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> m (Maybe (CollElement (STRef s a)))

IsSequence a => MutablePopFront (MutVar s a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> m (Maybe (CollElement (MutVar s a)))

IsSequence seq => MutablePopFront (BRef s seq)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> m (Maybe (CollElement (BRef s seq)))

MutablePopFront (DLList s a)

Methods

popFront :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> m (Maybe (CollElement (DLList s a)))

MVector v a => MutablePopFront (Deque v s a)

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

Minimal complete definition

popBack

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

IsSequence a => MutablePopBack (IORef a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (IORef a))) => IORef a -> m (Maybe (CollElement (IORef a)))

IsSequence a => MutablePopBack (STRef s a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (STRef s a))) => STRef s a -> m (Maybe (CollElement (STRef s a)))

IsSequence a => MutablePopBack (MutVar s a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (MutVar s a))) => MutVar s a -> m (Maybe (CollElement (MutVar s a)))

IsSequence seq => MutablePopBack (BRef s seq)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (BRef s seq))) => BRef s seq -> m (Maybe (CollElement (BRef s seq)))

MutablePopBack (DLList s a)

Methods

popBack :: (PrimMonad m, (* ~ PrimState m) (MCState (DLList s a))) => DLList s a -> m (Maybe (CollElement (DLList s a)))

MVector v a => MutablePopBack (Deque v s a)

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 :: * -> *)

Class of monads which can perform primitive state-transformer actions

Minimal complete definition

primitive

Associated Types

type PrimState (m :: * -> *) :: *

State token type

Instances

PrimMonad IO

Associated Types

type PrimState (IO :: * -> *) :: *

Methods

primitive :: (State# (PrimState IO) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState IO), a#)) -> IO a

PrimMonad (ST s)

Associated Types

type PrimState (ST s :: * -> *) :: *

Methods

primitive :: (State# (PrimState (ST s)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (ST s)), a#)) -> ST s a

PrimMonad m => PrimMonad (MaybeT m)

Associated Types

type PrimState (MaybeT m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (MaybeT m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (MaybeT m)), a#)) -> MaybeT m a

PrimMonad m => PrimMonad (ListT m)

Associated Types

type PrimState (ListT m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (ListT m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (ListT m)), a#)) -> ListT m a

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

Associated Types

type PrimState (WriterT w m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (WriterT w m)), a#)) -> WriterT w m a

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

Associated Types

type PrimState (WriterT w m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (WriterT w m)), a#)) -> WriterT w m a

PrimMonad m => PrimMonad (StateT s m)

Associated Types

type PrimState (StateT s m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (StateT s m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (StateT s m)), a#)) -> StateT s m a

PrimMonad m => PrimMonad (StateT s m)

Associated Types

type PrimState (StateT s m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (StateT s m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (StateT s m)), a#)) -> StateT s m a

PrimMonad m => PrimMonad (IdentityT * m)

Associated Types

type PrimState (IdentityT * m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (IdentityT * m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (IdentityT * m)), a#)) -> IdentityT * m a

PrimMonad m => PrimMonad (ExceptT e m)

Associated Types

type PrimState (ExceptT e m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (ExceptT e m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (ExceptT e m)), a#)) -> ExceptT e m a

(Error e, PrimMonad m) => PrimMonad (ErrorT e m)

Associated Types

type PrimState (ErrorT e m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (ErrorT e m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (ErrorT e m)), a#)) -> ErrorT e m a

PrimMonad m => PrimMonad (ReaderT * r m)

Associated Types

type PrimState (ReaderT * r m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (ReaderT * r m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (ReaderT * r m)), a#)) -> ReaderT * r m a

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

Associated Types

type PrimState (RWST r w s m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (RWST r w s m)), a#)) -> RWST r w s m a

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

Associated Types

type PrimState (RWST r w s m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (RWST r w s m)), a#)) -> RWST r w s m a

type family PrimState (m :: * -> *) :: *

State token type

Instances

type PrimState IO

type PrimState IO = RealWorld

type PrimState (ST s)

type PrimState (ST s) = s

type PrimState (MaybeT m)

type PrimState (MaybeT m) = PrimState m

type PrimState (ListT m)

type PrimState (ListT m) = PrimState m

type PrimState (WriterT w m)

type PrimState (WriterT w m) = PrimState m

type PrimState (WriterT w m)

type PrimState (WriterT w m) = PrimState m

type PrimState (StateT s m)

type PrimState (StateT s m) = PrimState m

type PrimState (StateT s m)

type PrimState (StateT s m) = PrimState m

type PrimState (IdentityT * m)

type PrimState (IdentityT * m) = PrimState m

type PrimState (ExceptT e m)

type PrimState (ExceptT e m) = PrimState m

type PrimState (ErrorT e m)

type PrimState (ErrorT e m) = PrimState m

type PrimState (ReaderT * r m)

type PrimState (ReaderT * r m) = PrimState m

type PrimState (RWST r w s m)

type PrimState (RWST r w s m) = PrimState m

type PrimState (RWST r w s m)

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

Minimal complete definition

sizeOf#, alignment#, indexByteArray#, readByteArray#, writeByteArray#, setByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#, setOffAddr#

Instances

Prim Char

Methods

sizeOf# :: Char -> Int#

alignment# :: Char -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#)

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

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

Prim Double

Methods

sizeOf# :: Double -> Int#

alignment# :: Double -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Double#)

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

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

Prim Float

Methods

sizeOf# :: Float -> Int#

alignment# :: Float -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Float#)

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

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

Prim Int

Methods

sizeOf# :: Int -> Int#

alignment# :: Int -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int#)

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

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

Prim Int8

Methods

sizeOf# :: Int8 -> Int#

alignment# :: Int8 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int8#)

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

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

Prim Int16

Methods

sizeOf# :: Int16 -> Int#

alignment# :: Int16 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int16#)

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

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

Prim Int32

Methods

sizeOf# :: Int32 -> Int#

alignment# :: Int32 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#)

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

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

Prim Int64

Methods

sizeOf# :: Int64 -> Int#

alignment# :: Int64 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#)

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

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

Prim Word

Methods

sizeOf# :: Word -> Int#

alignment# :: Word -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word#)

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

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

Prim Word8

Methods

sizeOf# :: Word8 -> Int#

alignment# :: Word8 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#)

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

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

Prim Word16

Methods

sizeOf# :: Word16 -> Int#

alignment# :: Word16 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#)

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

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

Prim Word32

Methods

sizeOf# :: Word32 -> Int#

alignment# :: Word32 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#)

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

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

Prim Word64

Methods

sizeOf# :: Word64 -> Int#

alignment# :: Word64 -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#)

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

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

Prim Addr

Methods

sizeOf# :: Addr -> Int#

alignment# :: Addr -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Addr#)

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

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

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

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Addr#)

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

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

Prim (Ptr a)

Methods

sizeOf# :: Ptr a -> Int#

alignment# :: Ptr a -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#)

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

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

Prim (FunPtr a)

Methods

sizeOf# :: FunPtr a -> Int#

alignment# :: FunPtr a -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FunPtr a#)

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

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

class (Vector Vector a, MVector MVector a) => Unbox a

Instances

Unbox Bool

Unbox Char

Unbox Double

Unbox Float

Unbox Int

Unbox Int8

Unbox Int16

Unbox Int32

Unbox Int64

Unbox Word

Unbox Word8

Unbox Word16

Unbox Word32

Unbox Word64

Unbox ()

Unbox a => Unbox (Complex a)

(Unbox a, Unbox b) => Unbox (a, b)

(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)

(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e)

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)

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

Storable Bool

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

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: 2.1

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 Int8

Since: 2.1

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 Int16

Since: 2.1

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: 2.1

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: 2.1

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 Word

Since: 2.1

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 Word8

Since: 2.1

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 Word16

Since: 2.1

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: 2.1

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: 2.1

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 ()

Since: 4.9.0.0

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 Fingerprint

Since: 4.4.0.0

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 a, Integral a) => Storable (Ratio a)

Since: 4.8.0.0

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: 2.1

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 ()

Storable (Ptr a)

Since: 2.1

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 (FunPtr a)

Since: 2.1

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 a => Storable (Identity a)

Methods

sizeOf :: Identity a -> Int

alignment :: Identity a -> Int

peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a)

pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Identity a)

pokeByteOff :: Ptr b -> Int -> Identity a -> IO ()

peek :: Ptr (Identity a) -> IO (Identity a)

poke :: Ptr (Identity a) -> Identity a -> IO ()

Storable a => Storable (Const k a b)

Methods

sizeOf :: Const k a b -> Int

alignment :: Const k a b -> Int

peekElemOff :: Ptr (Const k a b) -> Int -> IO (Const k a b)

pokeElemOff :: Ptr (Const k a b) -> Int -> Const k a b -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Const k a b)

pokeByteOff :: Ptr b -> Int -> Const k a b -> IO ()

peek :: Ptr (Const k a b) -> IO (Const k a b)

poke :: Ptr (Const k a b) -> Const k a b -> IO ()