type STM IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type STM IO = STM
type TVar IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TVar IO = TVar
type TMVar IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TMVar IO = TMVar
type TQueue IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TQueue IO = TQueue
type TBQueue IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TBQueue IO = TBQueue
type TArray IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TArray IO = TArray
type TSem IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TSem IO = TSem
type TChan IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TChan IO = TChan

Methods

atomically :: HasCallStack => STM IO a -> IO a Source #

newTVar :: a -> STM IO (TVar IO a) Source #

readTVar :: TVar IO a -> STM IO a Source #

writeTVar :: TVar IO a -> a -> STM IO () Source #

retry :: STM IO a Source #

orElse :: STM IO a -> STM IO a -> STM IO a Source #

modifyTVar :: TVar IO a -> (a -> a) -> STM IO () Source #

modifyTVar' :: TVar IO a -> (a -> a) -> STM IO () Source #

stateTVar :: TVar IO s -> (s -> (a, s)) -> STM IO a Source #

swapTVar :: TVar IO a -> a -> STM IO a Source #

check :: Bool -> STM IO () Source #

newTMVar :: a -> STM IO (TMVar IO a) Source #

newEmptyTMVar :: STM IO (TMVar IO a) Source #

takeTMVar :: TMVar IO a -> STM IO a Source #

tryTakeTMVar :: TMVar IO a -> STM IO (Maybe a) Source #

putTMVar :: TMVar IO a -> a -> STM IO () Source #

tryPutTMVar :: TMVar IO a -> a -> STM IO Bool Source #

readTMVar :: TMVar IO a -> STM IO a Source #

tryReadTMVar :: TMVar IO a -> STM IO (Maybe a) Source #

swapTMVar :: TMVar IO a -> a -> STM IO a Source #

writeTMVar :: TMVar IO a -> a -> STM IO () Source #

isEmptyTMVar :: TMVar IO a -> STM IO Bool Source #

newTQueue :: STM IO (TQueue IO a) Source #

readTQueue :: TQueue IO a -> STM IO a Source #

tryReadTQueue :: TQueue IO a -> STM IO (Maybe a) Source #

peekTQueue :: TQueue IO a -> STM IO a Source #

tryPeekTQueue :: TQueue IO a -> STM IO (Maybe a) Source #

flushTQueue :: TQueue IO a -> STM IO [a] Source #

writeTQueue :: TQueue IO a -> a -> STM IO () Source #

isEmptyTQueue :: TQueue IO a -> STM IO Bool Source #

unGetTQueue :: TQueue IO a -> a -> STM IO () Source #

newTBQueue :: Natural -> STM IO (TBQueue IO a) Source #

readTBQueue :: TBQueue IO a -> STM IO a Source #

tryReadTBQueue :: TBQueue IO a -> STM IO (Maybe a) Source #

peekTBQueue :: TBQueue IO a -> STM IO a Source #

tryPeekTBQueue :: TBQueue IO a -> STM IO (Maybe a) Source #

flushTBQueue :: TBQueue IO a -> STM IO [a] Source #

writeTBQueue :: TBQueue IO a -> a -> STM IO () Source #

lengthTBQueue :: TBQueue IO a -> STM IO Natural Source #

isEmptyTBQueue :: TBQueue IO a -> STM IO Bool Source #

isFullTBQueue :: TBQueue IO a -> STM IO Bool Source #

unGetTBQueue :: TBQueue IO a -> a -> STM IO () Source #

newTSem :: Integer -> STM IO (TSem IO) Source #

waitTSem :: TSem IO -> STM IO () Source #

signalTSem :: TSem IO -> STM IO () Source #

signalTSemN :: Natural -> TSem IO -> STM IO () Source #

newTChan :: STM IO (TChan IO a) Source #

newBroadcastTChan :: STM IO (TChan IO a) Source #

dupTChan :: TChan IO a -> STM IO (TChan IO a) Source #

cloneTChan :: TChan IO a -> STM IO (TChan IO a) Source #

readTChan :: TChan IO a -> STM IO a Source #

tryReadTChan :: TChan IO a -> STM IO (Maybe a) Source #

peekTChan :: TChan IO a -> STM IO a Source #

tryPeekTChan :: TChan IO a -> STM IO (Maybe a) Source #

writeTChan :: TChan IO a -> a -> STM IO () Source #

unGetTChan :: TChan IO a -> a -> STM IO () Source #

isEmptyTChan :: TChan IO a -> STM IO Bool Source #

newTVarIO :: a -> IO (TVar IO a) Source #

readTVarIO :: TVar IO a -> IO a Source #

newTMVarIO :: a -> IO (TMVar IO a) Source #

newEmptyTMVarIO :: IO (TMVar IO a) Source #

newTQueueIO :: IO (TQueue IO a) Source #

newTBQueueIO :: Natural -> IO (TBQueue IO a) Source #

newTChanIO :: IO (TChan IO a) Source #

newBroadcastTChanIO :: IO (TChan IO a) Source #

MonadSTM m => MonadSTM (ReaderT r m) Source #

The underlying stm monad is also transformed.

Instance details

Defined in Control.Monad.Class.MonadSTM.Internal

Associated Types

type STM (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type STM (ReaderT r m) = ReaderT r (STM m)
type TVar (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TVar (ReaderT r m) = TVar m
type TMVar (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TMVar (ReaderT r m) = TMVar m
type TQueue (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TQueue (ReaderT r m) = TQueue m
type TBQueue (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TBQueue (ReaderT r m) = TBQueue m
type TArray (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TArray (ReaderT r m) = TArray m
type TSem (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TSem (ReaderT r m) = TSem m
type TChan (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type TChan (ReaderT r m) = TChan m

Methods

atomically :: HasCallStack => STM (ReaderT r m) a -> ReaderT r m a Source #

newTVar :: a -> STM (ReaderT r m) (TVar (ReaderT r m) a) Source #

readTVar :: TVar (ReaderT r m) a -> STM (ReaderT r m) a Source #

writeTVar :: TVar (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

retry :: STM (ReaderT r m) a Source #

orElse :: STM (ReaderT r m) a -> STM (ReaderT r m) a -> STM (ReaderT r m) a Source #

modifyTVar :: TVar (ReaderT r m) a -> (a -> a) -> STM (ReaderT r m) () Source #

modifyTVar' :: TVar (ReaderT r m) a -> (a -> a) -> STM (ReaderT r m) () Source #

stateTVar :: TVar (ReaderT r m) s -> (s -> (a, s)) -> STM (ReaderT r m) a Source #

swapTVar :: TVar (ReaderT r m) a -> a -> STM (ReaderT r m) a Source #

check :: Bool -> STM (ReaderT r m) () Source #

newTMVar :: a -> STM (ReaderT r m) (TMVar (ReaderT r m) a) Source #

newEmptyTMVar :: STM (ReaderT r m) (TMVar (ReaderT r m) a) Source #

takeTMVar :: TMVar (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryTakeTMVar :: TMVar (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

putTMVar :: TMVar (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

tryPutTMVar :: TMVar (ReaderT r m) a -> a -> STM (ReaderT r m) Bool Source #

readTMVar :: TMVar (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryReadTMVar :: TMVar (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

swapTMVar :: TMVar (ReaderT r m) a -> a -> STM (ReaderT r m) a Source #

writeTMVar :: TMVar (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

isEmptyTMVar :: TMVar (ReaderT r m) a -> STM (ReaderT r m) Bool Source #

newTQueue :: STM (ReaderT r m) (TQueue (ReaderT r m) a) Source #

readTQueue :: TQueue (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryReadTQueue :: TQueue (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

peekTQueue :: TQueue (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryPeekTQueue :: TQueue (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

flushTQueue :: TQueue (ReaderT r m) a -> STM (ReaderT r m) [a] Source #

writeTQueue :: TQueue (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

isEmptyTQueue :: TQueue (ReaderT r m) a -> STM (ReaderT r m) Bool Source #

unGetTQueue :: TQueue (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

newTBQueue :: Natural -> STM (ReaderT r m) (TBQueue (ReaderT r m) a) Source #

readTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryReadTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

peekTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryPeekTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

flushTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) [a] Source #

writeTBQueue :: TBQueue (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

lengthTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) Natural Source #

isEmptyTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) Bool Source #

isFullTBQueue :: TBQueue (ReaderT r m) a -> STM (ReaderT r m) Bool Source #

unGetTBQueue :: TBQueue (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

newTSem :: Integer -> STM (ReaderT r m) (TSem (ReaderT r m)) Source #

waitTSem :: TSem (ReaderT r m) -> STM (ReaderT r m) () Source #

signalTSem :: TSem (ReaderT r m) -> STM (ReaderT r m) () Source #

signalTSemN :: Natural -> TSem (ReaderT r m) -> STM (ReaderT r m) () Source #

newTChan :: STM (ReaderT r m) (TChan (ReaderT r m) a) Source #

newBroadcastTChan :: STM (ReaderT r m) (TChan (ReaderT r m) a) Source #

dupTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) (TChan (ReaderT r m) a) Source #

cloneTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) (TChan (ReaderT r m) a) Source #

readTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryReadTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

peekTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) a Source #

tryPeekTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) (Maybe a) Source #

writeTChan :: TChan (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

unGetTChan :: TChan (ReaderT r m) a -> a -> STM (ReaderT r m) () Source #

isEmptyTChan :: TChan (ReaderT r m) a -> STM (ReaderT r m) Bool Source #

newTVarIO :: a -> ReaderT r m (TVar (ReaderT r m) a) Source #

readTVarIO :: TVar (ReaderT r m) a -> ReaderT r m a Source #

newTMVarIO :: a -> ReaderT r m (TMVar (ReaderT r m) a) Source #

newEmptyTMVarIO :: ReaderT r m (TMVar (ReaderT r m) a) Source #

newTQueueIO :: ReaderT r m (TQueue (ReaderT r m) a) Source #

newTBQueueIO :: Natural -> ReaderT r m (TBQueue (ReaderT r m) a) Source #

newTChanIO :: ReaderT r m (TChan (ReaderT r m) a) Source #

newBroadcastTChanIO :: ReaderT r m (TChan (ReaderT r m) a) Source #

class MonadSTM m => MonadLabelledSTM (m :: Type -> Type) where Source #

Labelled TVars & friends.

The IO instances is no-op, the IOSim instance enhances simulation trace. This is very useful when analysing low lever concurrency issues (e.g. deadlocks, livelocks etc).

Minimal complete definition

labelTVar

Methods

labelTVar :: TVar m a -> String -> STM m () Source #

Name a TVar.

labelTMVar :: TMVar m a -> String -> STM m () Source #

default labelTMVar :: TMVar m ~ TMVarDefault m => TMVar m a -> String -> STM m () Source #

labelTQueue :: TQueue m a -> String -> STM m () Source #

default labelTQueue :: TQueue m ~ TQueueDefault m => TQueue m a -> String -> STM m () Source #

labelTBQueue :: TBQueue m a -> String -> STM m () Source #

default labelTBQueue :: TBQueue m ~ TBQueueDefault m => TBQueue m a -> String -> STM m () Source #

labelTArray :: (Ix i, Show i) => TArray m i e -> String -> STM m () Source #

default labelTArray :: (TArray m ~ TArrayDefault m, Ix i, Show i) => TArray m i e -> String -> STM m () Source #

labelTSem :: TSem m -> String -> STM m () Source #

default labelTSem :: TSem m ~ TSemDefault m => TSem m -> String -> STM m () Source #

labelTChan :: TChan m a -> String -> STM m () Source #

default labelTChan :: TChan m ~ TChanDefault m => TChan m a -> String -> STM m () Source #

labelTVarIO :: TVar m a -> String -> m () Source #

default labelTVarIO :: TVar m a -> String -> m () Source #

labelTMVarIO :: TMVar m a -> String -> m () Source #

default labelTMVarIO :: TMVar m a -> String -> m () Source #

labelTQueueIO :: TQueue m a -> String -> m () Source #

default labelTQueueIO :: TQueue m a -> String -> m () Source #

labelTBQueueIO :: TBQueue m a -> String -> m () Source #

default labelTBQueueIO :: TBQueue m a -> String -> m () Source #

labelTArrayIO :: (Ix i, Show i) => TArray m i e -> String -> m () Source #

default labelTArrayIO :: (Ix i, Show i) => TArray m i e -> String -> m () Source #

labelTSemIO :: TSem m -> String -> m () Source #

default labelTSemIO :: TSem m -> String -> m () Source #

labelTChanIO :: TChan m a -> String -> m () Source #

default labelTChanIO :: TChan m a -> String -> m () Source #

Instances

Instances details

MonadLabelledSTM IO Source #

noop instance

Instance details

Defined in Control.Monad.Class.MonadSTM.Internal

Methods

labelTVar :: TVar IO a -> String -> STM IO () Source #

labelTMVar :: TMVar IO a -> String -> STM IO () Source #

labelTQueue :: TQueue IO a -> String -> STM IO () Source #

labelTBQueue :: TBQueue IO a -> String -> STM IO () Source #

labelTArray :: (Ix i, Show i) => TArray IO i e -> String -> STM IO () Source #

labelTSem :: TSem IO -> String -> STM IO () Source #

labelTChan :: TChan IO a -> String -> STM IO () Source #

labelTVarIO :: TVar IO a -> String -> IO () Source #

labelTMVarIO :: TMVar IO a -> String -> IO () Source #

labelTQueueIO :: TQueue IO a -> String -> IO () Source #

labelTBQueueIO :: TBQueue IO a -> String -> IO () Source #

labelTArrayIO :: (Ix i, Show i) => TArray IO i e -> String -> IO () Source #

labelTSemIO :: TSem IO -> String -> IO () Source #

labelTChanIO :: TChan IO a -> String -> IO () Source #

class (MonadSTM m, Monad (InspectMonad m)) => MonadInspectSTM (m :: Type -> Type) where Source #

This type class is indented for 'io-sim', where one might want to access a TVar in the underlying ST monad.

Associated Types

type InspectMonad (m :: Type -> Type) :: Type -> Type Source #

Methods

inspectTVar :: proxy m -> TVar m a -> InspectMonad m a Source #

Return the value of a TVar as an InspectMonad computation.

inspectTVar is useful if the value of a TVar observed by traceTVar contains other TVars.

inspectTMVar :: proxy m -> TMVar m a -> InspectMonad m (Maybe a) Source #

Return the value of a TMVar as an InspectMonad computation.

Instances

Instances details

MonadInspectSTM IO Source #

Instance details

Defined in Control.Monad.Class.MonadSTM.Internal

Associated Types

type InspectMonad IO
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type InspectMonad IO = IO

Methods

inspectTVar :: proxy IO -> TVar IO a -> InspectMonad IO a Source #

inspectTMVar :: proxy IO -> TMVar IO a -> InspectMonad IO (Maybe a) Source #

MonadInspectSTM m => MonadInspectSTM (ReaderT r m) Source #

Instance details

Defined in Control.Monad.Class.MonadSTM.Internal

Associated Types

type InspectMonad (ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM.Internal type InspectMonad (ReaderT r m) = InspectMonad m

Methods

inspectTVar :: proxy (ReaderT r m) -> TVar (ReaderT r m) a -> InspectMonad (ReaderT r m) a Source #

inspectTMVar :: proxy (ReaderT r m) -> TMVar (ReaderT r m) a -> InspectMonad (ReaderT r m) (Maybe a) Source #

data TraceValue where Source #

A GADT which instructs how to trace the value. The traceDynamic will use dynamic tracing, e.g. "Control.Monad.IOSim.traceM"; while traceString will be traced with EventSay. The IOSims dynamic tracing allows to recover the value from the simulation trace (see "Control.Monad.IOSim.selectTraceEventsDynamic").

Constructors

TraceValue
Fields :: forall tr. Typeable tr => { traceDynamic :: Maybe tr , traceString :: Maybe String } -> TraceValue

Bundled Patterns

pattern TraceDynamic :: () => Typeable tr => tr -> TraceValue	Use only a dynamic tracer.
pattern TraceString :: String -> TraceValue	Use only string tracing.
pattern DontTrace :: TraceValue	Do not trace the value.

class MonadInspectSTM m => MonadTraceSTM (m :: Type -> Type) where Source #

MonadTraceSTM allows to trace values of stm variables when stm transaction is committed. This allows to verify invariants when a variable is committed.

Minimal complete definition

traceTVar, traceTQueue, traceTBQueue

Methods

traceTVar Source #

Arguments

:: proxy m
-> TVar m a
-> (Maybe a -> a -> InspectMonad m TraceValue)	callback which receives initial value or `Nothing` (if it is a newly created `TVar`), and the committed value.
-> STM m ()

Construct a trace output out of previous & new value of a TVar. The callback is called whenever an stm transaction which modifies the TVar is committed.

This is supported by IOSim (and IOSimPOR); IO has a trivial instance.

The simplest example is:

traceTVar (Proxy @m) tvar (\_ -> TraceString . show)

Note that the interpretation of TraceValue depends on the monad m itself (see TraceValue).

traceTMVar :: proxy m -> TMVar m a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad m TraceValue) -> STM m () Source #

default traceTMVar :: TMVar m a ~ TMVarDefault m a => proxy m -> TMVar m a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad m TraceValue) -> STM m () Source #

traceTQueue :: proxy m -> TQueue m a -> (Maybe [a] -> [a] -> InspectMonad m TraceValue) -> STM m () Source #

traceTBQueue :: proxy m -> TBQueue m a -> (Maybe [a] -> [a] -> InspectMonad m TraceValue) -> STM m () Source #

traceTSem :: proxy m -> TSem m -> (Maybe Integer -> Integer -> InspectMonad m TraceValue) -> STM m () Source #

default traceTSem :: TSem m ~ TSemDefault m => proxy m -> TSem m -> (Maybe Integer -> Integer -> InspectMonad m TraceValue) -> STM m () Source #

traceTVarIO :: TVar m a -> (Maybe a -> a -> InspectMonad m TraceValue) -> m () Source #

default traceTVarIO :: TVar m a -> (Maybe a -> a -> InspectMonad m TraceValue) -> m () Source #

traceTMVarIO :: TMVar m a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad m TraceValue) -> m () Source #

default traceTMVarIO :: TMVar m a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad m TraceValue) -> m () Source #

traceTQueueIO :: TQueue m a -> (Maybe [a] -> [a] -> InspectMonad m TraceValue) -> m () Source #

default traceTQueueIO :: TQueue m a -> (Maybe [a] -> [a] -> InspectMonad m TraceValue) -> m () Source #

traceTBQueueIO :: TBQueue m a -> (Maybe [a] -> [a] -> InspectMonad m TraceValue) -> m () Source #

default traceTBQueueIO :: TBQueue m a -> (Maybe [a] -> [a] -> InspectMonad m TraceValue) -> m () Source #

traceTSemIO :: TSem m -> (Maybe Integer -> Integer -> InspectMonad m TraceValue) -> m () Source #

default traceTSemIO :: TSem m -> (Maybe Integer -> Integer -> InspectMonad m TraceValue) -> m () Source #

Instances

Instances details

MonadTraceSTM IO Source #	noop instance
Instance details Defined in Control.Monad.Class.MonadSTM.Internal Methods traceTVar :: proxy IO -> TVar IO a -> (Maybe a -> a -> InspectMonad IO TraceValue) -> STM IO () Source # traceTMVar :: proxy IO -> TMVar IO a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad IO TraceValue) -> STM IO () Source # traceTQueue :: proxy IO -> TQueue IO a -> (Maybe [a] -> [a] -> InspectMonad IO TraceValue) -> STM IO () Source # traceTBQueue :: proxy IO -> TBQueue IO a -> (Maybe [a] -> [a] -> InspectMonad IO TraceValue) -> STM IO () Source # traceTSem :: proxy IO -> TSem IO -> (Maybe Integer -> Integer -> InspectMonad IO TraceValue) -> STM IO () Source # traceTVarIO :: TVar IO a -> (Maybe a -> a -> InspectMonad IO TraceValue) -> IO () Source # traceTMVarIO :: TMVar IO a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad IO TraceValue) -> IO () Source # traceTQueueIO :: TQueue IO a -> (Maybe [a] -> [a] -> InspectMonad IO TraceValue) -> IO () Source # traceTBQueueIO :: TBQueue IO a -> (Maybe [a] -> [a] -> InspectMonad IO TraceValue) -> IO () Source # traceTSemIO :: TSem IO -> (Maybe Integer -> Integer -> InspectMonad IO TraceValue) -> IO () Source #
MonadTraceSTM m => MonadTraceSTM (ReaderT r m) Source #
Instance details Defined in Control.Monad.Class.MonadSTM.Internal Methods traceTVar :: proxy (ReaderT r m) -> TVar (ReaderT r m) a -> (Maybe a -> a -> InspectMonad (ReaderT r m) TraceValue) -> STM (ReaderT r m) () Source # traceTMVar :: proxy (ReaderT r m) -> TMVar (ReaderT r m) a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad (ReaderT r m) TraceValue) -> STM (ReaderT r m) () Source # traceTQueue :: proxy (ReaderT r m) -> TQueue (ReaderT r m) a -> (Maybe [a] -> [a] -> InspectMonad (ReaderT r m) TraceValue) -> STM (ReaderT r m) () Source # traceTBQueue :: proxy (ReaderT r m) -> TBQueue (ReaderT r m) a -> (Maybe [a] -> [a] -> InspectMonad (ReaderT r m) TraceValue) -> STM (ReaderT r m) () Source # traceTSem :: proxy (ReaderT r m) -> TSem (ReaderT r m) -> (Maybe Integer -> Integer -> InspectMonad (ReaderT r m) TraceValue) -> STM (ReaderT r m) () Source # traceTVarIO :: TVar (ReaderT r m) a -> (Maybe a -> a -> InspectMonad (ReaderT r m) TraceValue) -> ReaderT r m () Source # traceTMVarIO :: TMVar (ReaderT r m) a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad (ReaderT r m) TraceValue) -> ReaderT r m () Source # traceTQueueIO :: TQueue (ReaderT r m) a -> (Maybe [a] -> [a] -> InspectMonad (ReaderT r m) TraceValue) -> ReaderT r m () Source # traceTBQueueIO :: TBQueue (ReaderT r m) a -> (Maybe [a] -> [a] -> InspectMonad (ReaderT r m) TraceValue) -> ReaderT r m () Source # traceTSemIO :: TSem (ReaderT r m) -> (Maybe Integer -> Integer -> InspectMonad (ReaderT r m) TraceValue) -> ReaderT r m () Source #

MonadThrow aliases

throwSTM :: forall (m :: Type -> Type) e a. (MonadSTM m, MonadThrow (STM m), Exception e) => e -> STM m a Source #

throwIO specialised to stm monad.

catchSTM :: forall (m :: Type -> Type) e a. (MonadSTM m, MonadCatch (STM m), Exception e) => STM m a -> (e -> STM m a) -> STM m a Source #

catch specialized for an stm monad.

Default implementations

The default implementations are based on a TVar defined in the class. They are tailored towards IOSim rather than instances which would like to derive from IO or monad transformers.

newtype TMVarDefault (m :: Type -> Type) a Source #

Constructors

TMVar (TVar m (Maybe a))

newTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => a -> STM m (TMVarDefault m a) Source #

newEmptyTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => STM m (TMVarDefault m a) Source #

takeTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> STM m a Source #

tryTakeTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> STM m (Maybe a) Source #

putTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> a -> STM m () Source #

tryPutTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> a -> STM m Bool Source #

readTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> STM m a Source #

tryReadTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> STM m (Maybe a) Source #

swapTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> a -> STM m a Source #

writeTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> a -> STM m () Source #

isEmptyTMVarDefault :: forall (m :: Type -> Type) a. MonadSTM m => TMVarDefault m a -> STM m Bool Source #

labelTMVarDefault :: forall (m :: Type -> Type) a. MonadLabelledSTM m => TMVarDefault m a -> String -> STM m () Source #

traceTMVarDefault :: forall (m :: Type -> Type) proxy a. MonadTraceSTM m => proxy m -> TMVarDefault m a -> (Maybe (Maybe a) -> Maybe a -> InspectMonad m TraceValue) -> STM m () Source #

Default `TQueue` implementation

data TQueueDefault (m :: Type -> Type) a Source #

Constructors

TQueue !(TVar m [a]) !(TVar m [a])

newTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => STM m (TQueueDefault m a) Source #

writeTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> a -> STM m () Source #

readTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> STM m a Source #

tryReadTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> STM m (Maybe a) Source #

isEmptyTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> STM m Bool Source #

peekTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> STM m a Source #

tryPeekTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> STM m (Maybe a) Source #

flushTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> STM m [a] Source #

unGetTQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TQueueDefault m a -> a -> STM m () Source #

labelTQueueDefault :: forall (m :: Type -> Type) a. MonadLabelledSTM m => TQueueDefault m a -> String -> STM m () Source #

Default `TBQueue` implementation

data TBQueueDefault (m :: Type -> Type) a Source #

Constructors

TBQueue !(TVar m Natural) !(TVar m [a]) !(TVar m Natural) !(TVar m [a]) !Natural

newTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => Natural -> STM m (TBQueueDefault m a) Source #

writeTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> a -> STM m () Source #

readTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m a Source #

tryReadTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m (Maybe a) Source #

peekTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m a Source #

tryPeekTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m (Maybe a) Source #

isEmptyTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m Bool Source #

isFullTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m Bool Source #

lengthTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m Natural Source #

flushTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> STM m [a] Source #

unGetTBQueueDefault :: forall (m :: Type -> Type) a. MonadSTM m => TBQueueDefault m a -> a -> STM m () Source #

labelTBQueueDefault :: forall (m :: Type -> Type) a. MonadLabelledSTM m => TBQueueDefault m a -> String -> STM m () Source #

Default `TArray` implementation

data TArrayDefault (m :: Type -> Type) i e Source #

Default implementation of TArray.

Constructors

TArray (Array i (TVar m e))

Instances

Instances details

(Monad stm, MonadSTM m, stm ~ STM m) => MArray (TArrayDefault m) e stm Source #
Instance details Defined in Control.Monad.Class.MonadSTM.Internal Methods getBounds :: Ix i => TArrayDefault m i e -> stm (i, i) # getNumElements :: Ix i => TArrayDefault m i e -> stm Int # newArray :: Ix i => (i, i) -> e -> stm (TArrayDefault m i e) # newArray_ :: Ix i => (i, i) -> stm (TArrayDefault m i e) # unsafeNewArray_ :: Ix i => (i, i) -> stm (TArrayDefault m i e) # unsafeRead :: Ix i => TArrayDefault m i e -> Int -> stm e # unsafeWrite :: Ix i => TArrayDefault m i e -> Int -> e -> stm () #
(Eq (TVar m e), Ix i) => Eq (TArrayDefault m i e) Source #
Instance details Defined in Control.Monad.Class.MonadSTM.Internal Methods (==) :: TArrayDefault m i e -> TArrayDefault m i e -> Bool # (/=) :: TArrayDefault m i e -> TArrayDefault m i e -> Bool #

Default `TSem` implementation

newtype TSemDefault (m :: Type -> Type) Source #

Constructors

TSem (TVar m Integer)

newTSemDefault :: forall (m :: Type -> Type). MonadSTM m => Integer -> STM m (TSemDefault m) Source #

waitTSemDefault :: forall (m :: Type -> Type). MonadSTM m => TSemDefault m -> STM m () Source #

signalTSemDefault :: forall (m :: Type -> Type). MonadSTM m => TSemDefault m -> STM m () Source #

signalTSemNDefault :: forall (m :: Type -> Type). MonadSTM m => Natural -> TSemDefault m -> STM m () Source #

labelTSemDefault :: forall (m :: Type -> Type). MonadLabelledSTM m => TSemDefault m -> String -> STM m () Source #

Default `TChan` implementation

data TChanDefault (m :: Type -> Type) a Source #

Constructors

TChan (TVar m (TVarList m a)) (TVar m (TVarList m a))

newTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => STM m (TChanDefault m a) Source #

newBroadcastTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => STM m (TChanDefault m a) Source #

writeTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> a -> STM m () Source #

readTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m a Source #

tryReadTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m (Maybe a) Source #

peekTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m a Source #

tryPeekTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m (Maybe a) Source #

dupTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m (TChanDefault m a) Source #

unGetTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> a -> STM m () Source #

isEmptyTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m Bool Source #

cloneTChanDefault :: forall (m :: Type -> Type) a. MonadSTM m => TChanDefault m a -> STM m (TChanDefault m a) Source #

labelTChanDefault :: forall (m :: Type -> Type) a. MonadLabelledSTM m => TChanDefault m a -> String -> STM m () Source #

Trace tvar and tmvar

debugTraceTVar :: forall (m :: Type -> Type) a proxy. (MonadTraceSTM m, Show a) => proxy m -> TVar m a -> STM m () Source #

debugTraceTVarIO :: (MonadTraceSTM m, Show a) => TVar m a -> m () Source #

debugTraceTMVar :: forall (m :: Type -> Type) a proxy. (MonadTraceSTM m, Show a) => proxy m -> TMVar m a -> STM m () Source #

debugTraceTMVarIO :: (Show a, MonadTraceSTM m) => TMVar m a -> m () Source #

Documentation

Instances

Instances

Instances

Instances

MonadThrow aliases

Default implementations

Default TQueue implementation

Default TBQueue implementation

Default TArray implementation

Instances

Default TSem implementation

Default TChan implementation

Trace tvar and tmvar

Default `TQueue` implementation

Default `TBQueue` implementation

Default `TArray` implementation

Default `TSem` implementation

Default `TChan` implementation