Data.Mutable.Class

Various typeclasses for mutable containers.

Documentation

class Monad m => PrimMonad m

Class of primitive state-transformer monads

Minimal complete definition

primitive, internal

Associated Types

type PrimState m :: *

State token type

Instances

PrimMonad IO

PrimMonad (ST s)

type family PrimState m :: *

State token type

Instances

type PrimState IO = RealWorld

type PrimState (ST s) = s

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

type MutableStack c = (MutablePopFront c, MutablePushFront c)

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

data IORef a :: * -> *

A mutable variable in the IO monad

Instances

Eq (IORef a)

IsSequence a => MutablePushBack (IORef a)

IsSequence a => MutablePopBack (IORef a)

IsSequence a => MutablePushFront (IORef a)

IsSequence a => MutablePopFront (IORef a)

Monoid w => MutableCollection (IORef w)

MutableAtomicRef (IORef a)

MutableRef (IORef a)

MutableContainer (IORef a)

Typeable (* -> *) IORef

type CollElement (IORef w) = Element w

type RefElement (IORef a) = a

type MCState (IORef a) = PrimState IO

asIORef :: IORef a -> IORef a

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)

IsSequence a => MutablePushBack (STRef s a)

IsSequence a => MutablePopBack (STRef s a)

IsSequence a => MutablePushFront (STRef s a)

IsSequence a => MutablePopFront (STRef s a)

Monoid w => MutableCollection (STRef s w)

MutableRef (STRef s a)

MutableContainer (STRef s a)

type CollElement (STRef s w) = Element w

type RefElement (STRef s a) = a

type MCState (STRef s a) = s

asSTRef :: STRef s a -> STRef s a

data MutVar s a :: * -> * -> *

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

Instances

Eq (MutVar s a)

IsSequence a => MutablePushBack (MutVar s a)

IsSequence a => MutablePopBack (MutVar s a)

IsSequence a => MutablePushFront (MutVar s a)

IsSequence a => MutablePopFront (MutVar s a)

Monoid w => MutableCollection (MutVar s w)

MutableAtomicRef (MutVar s a)

MutableRef (MutVar s a)

MutableContainer (MutVar s a)

Typeable (* -> * -> *) MutVar

type CollElement (MutVar s w) = Element w

type RefElement (MutVar s a) = a

type MCState (MutVar s a) = s

asMutVar :: MutVar s a -> MutVar s a

class MutableContainer c

Associated Types

type MCState c

Instances

MutableContainer (IORef a)

MutableContainer (STRef s a)

MutableContainer (MutVar s a)

MutableContainer (URef s a)

MutableContainer (PRef s a)

MutableContainer (VRef s a)

MutableContainer (DList s a)

MutableContainer (SRef s a)

MutableContainer (Deque v s a)

class MutableContainer c => MutableRef c where

Associated Types

type RefElement c

Methods

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

Instances

MutableRef (IORef a)

MutableRef (STRef s a)

MutableRef (MutVar s a)

Unbox a => MutableRef (URef s a)

Prim a => MutableRef (PRef s a)

MutableRef (VRef s a)

Storable a => MutableRef (SRef s a)

class MutableRef c => MutableAtomicRef c where

Methods

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

Instances

MutableAtomicRef (IORef a)

MutableAtomicRef (MutVar s a)

class MutableContainer c => MutableCollection c where

Associated Types

type CollElement c

Methods

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

Instances

Monoid w => MutableCollection (IORef w)

Monoid w => MutableCollection (STRef s w)

Monoid w => MutableCollection (MutVar s w)

MutableCollection (DList s a)

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

class MutableCollection c => MutablePushFront c where

Methods

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

Instances

IsSequence a => MutablePushFront (IORef a)

IsSequence a => MutablePushFront (STRef s a)

IsSequence a => MutablePushFront (MutVar s a)

MutablePushFront (DList s a)

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

class MutableCollection c => MutablePushBack c where

Methods

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

Instances

IsSequence a => MutablePushBack (IORef a)

IsSequence a => MutablePushBack (STRef s a)

IsSequence a => MutablePushBack (MutVar s a)

MutablePushBack (DList s a)

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

class MutableCollection c => MutablePopFront c where

Methods

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

Instances

IsSequence a => MutablePopFront (IORef a)

IsSequence a => MutablePopFront (STRef s a)

IsSequence a => MutablePopFront (MutVar s a)

MutablePopFront (DList s a)

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

class MutableCollection c => MutablePopBack c where

Methods

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

Instances

IsSequence a => MutablePopBack (IORef a)

IsSequence a => MutablePopBack (STRef s a)

IsSequence a => MutablePopBack (MutVar s a)

MutablePopBack (DList s a)

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