Safe Haskell	None
Language	Haskell2010

Ouroboros.Consensus.Util.MonadSTM.NormalForm

Contents

Temporary

Synopsis

catchSTM :: forall (m :: Type -> Type ) e a. ( MonadSTM m, MonadCatch ( STM m), Exception e) => STM m a -> (e -> STM m a) -> STM m a
throwSTM :: forall (m :: Type -> Type ) e a. ( MonadSTM m, MonadThrow ( STM m), Exception e) => e -> STM m a
flushTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m [a]
lengthTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m Natural
isFullTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m Bool
isEmptyTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m Bool
writeTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> a -> STM m ()
tryPeekTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m ( Maybe a)
peekTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m a
tryReadTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m ( Maybe a)
readTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TBQueueDefault m a -> STM m a
newTBQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => Natural -> STM m ( TBQueueDefault m a)
labelTBQueueDefault :: forall (m :: Type -> Type ) a. MonadLabelledSTM m => TBQueueDefault m a -> String -> STM m ()
tryPeekTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TQueueDefault m a -> STM m ( Maybe a)
peekTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TQueueDefault m a -> STM m a
isEmptyTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TQueueDefault m a -> STM m Bool
tryReadTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TQueueDefault m a -> STM m ( Maybe a)
readTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TQueueDefault m a -> STM m a
writeTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TQueueDefault m a -> a -> STM m ()
newTQueueDefault :: forall (m :: Type -> Type ) a. MonadSTM m => STM m ( TQueueDefault m a)
labelTQueueDefault :: forall (m :: Type -> Type ) a. MonadLabelledSTM m => TQueueDefault m a -> String -> STM m ()
isEmptyTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> STM m Bool
swapTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> a -> STM m a
tryReadTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> STM m ( Maybe a)
readTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> STM m a
tryPutTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> a -> STM m Bool
putTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> a -> STM m ()
tryTakeTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> STM m ( Maybe a)
takeTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => TMVarDefault m a -> STM m a
newEmptyTMVarMDefault :: MonadSTM m => m ( TMVarDefault m a)
newEmptyTMVarIODefault :: MonadSTM m => m ( TMVarDefault m a)
newEmptyTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => STM m ( TMVarDefault m a)
newTMVarMDefault :: MonadSTM m => a -> m ( TMVarDefault m a)
newTMVarIODefault :: MonadSTM m => a -> m ( TMVarDefault m a)
newTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => a -> STM m ( TMVarDefault m a)
traceTMVarDefault :: forall (m :: Type -> Type ) proxy a. MonadTraceSTM m => proxy m -> TMVarDefault m a -> ( Maybe ( Maybe a) -> Maybe a -> InspectMonad m TraceValue ) -> STM m ()
labelTMVarDefault :: forall (m :: Type -> Type ) a. MonadLabelledSTM m => TMVarDefault m a -> String -> STM m ()
type family TBQueue (m :: Type -> Type ) :: Type -> Type
type family TQueue (m :: Type -> Type ) :: Type -> Type
type family STM (m :: Type -> Type ) = (stm :: Type -> Type ) | stm -> m
class ( Monad m, Alternative ( STM m), MonadPlus ( STM m)) => MonadSTM (m :: Type -> Type ) where
- type STM (m :: Type -> Type ) = (stm :: Type -> Type ) | stm -> m
- type TQueue (m :: Type -> Type ) :: Type -> Type
- type TBQueue (m :: Type -> Type ) :: Type -> Type
- atomically :: HasCallStack => STM m a -> m a
- retry :: STM m a
- orElse :: STM m a -> STM m a -> STM m a
- modifyTVar' :: TVar m a -> (a -> a) -> STM m ()
- check :: Bool -> STM m ()
- newTQueue :: STM m ( TQueue m a)
- readTQueue :: TQueue m a -> STM m a
- tryReadTQueue :: TQueue m a -> STM m ( Maybe a)
- peekTQueue :: TQueue m a -> STM m a
- tryPeekTQueue :: TQueue m a -> STM m ( Maybe a)
- writeTQueue :: TQueue m a -> a -> STM m ()
- isEmptyTQueue :: TQueue m a -> STM m Bool
- newTBQueue :: Natural -> STM m ( TBQueue m a)
- readTBQueue :: TBQueue m a -> STM m a
- tryReadTBQueue :: TBQueue m a -> STM m ( Maybe a)
- peekTBQueue :: TBQueue m a -> STM m a
- tryPeekTBQueue :: TBQueue m a -> STM m ( Maybe a)
- flushTBQueue :: TBQueue m a -> STM m [a]
- writeTBQueue :: TBQueue m a -> a -> STM m ()
- lengthTBQueue :: TBQueue m a -> STM m Natural
- isEmptyTBQueue :: TBQueue m a -> STM m Bool
- isFullTBQueue :: TBQueue m a -> STM m Bool
- newTQueueIO :: m ( TQueue m a)
- newTBQueueIO :: Natural -> m ( TBQueue m a)
class MonadSTM m => MonadLabelledSTM (m :: Type -> Type ) where
- labelTQueue :: TQueue m a -> String -> STM m ()
- labelTBQueue :: TBQueue m a -> String -> STM m ()
- labelTQueueIO :: TQueue m a -> String -> m ()
- labelTBQueueIO :: TBQueue m a -> String -> m ()
type family InspectMonad (m :: Type -> Type ) :: Type -> Type
class ( MonadSTM m, Monad ( InspectMonad m)) => MonadInspectSTM (m :: Type -> Type ) where
- type InspectMonad (m :: Type -> Type ) :: Type -> Type
- inspectTVar :: proxy m -> TVar m a -> InspectMonad m a
- inspectTMVar :: proxy m -> TMVar m a -> InspectMonad m ( Maybe a)
data TraceValue where
- TraceValue :: forall tr. Typeable tr => {..} -> TraceValue
- pattern TraceDynamic :: () => Typeable tr => tr -> TraceValue
- pattern TraceString :: String -> TraceValue
- pattern DontTrace :: TraceValue
class MonadInspectSTM m => MonadTraceSTM (m :: Type -> Type ) where
- traceTQueue :: proxy m -> TQueue m a -> ( Maybe [a] -> [a] -> InspectMonad m TraceValue ) -> STM m ()
- traceTBQueue :: proxy m -> TBQueue m a -> ( Maybe [a] -> [a] -> InspectMonad m TraceValue ) -> STM m ()
- traceTQueueIO :: proxy m -> TQueue m a -> ( Maybe [a] -> [a] -> InspectMonad m TraceValue ) -> m ()
- traceTBQueueIO :: proxy m -> TBQueue m a -> ( Maybe [a] -> [a] -> InspectMonad m TraceValue ) -> m ()
data TMVarDefault (m :: Type -> Type ) a
data TQueueDefault (m :: Type -> Type ) a = TQueue !( TVar m [a]) !( TVar m [a])
data TBQueueDefault (m :: Type -> Type ) a = TBQueue !( TVar m Natural ) !( TVar m [a]) !( TVar m Natural ) !( TVar m [a]) ! Natural
newtype WrappedSTM (t :: Trans) r (m :: Type -> Type ) a = WrappedSTM {
- runWrappedSTM :: STM m a
}
data StrictTVar (m :: Type -> Type ) a
checkInvariant :: HasCallStack => Maybe String -> a -> a
isEmptyTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m Bool
swapTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> a -> STM m a
tryReadTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m ( Maybe a)
readTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m a
tryPutTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> a -> STM m Bool
putTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> a -> STM m ()
tryTakeTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m ( Maybe a)
takeTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m a
newEmptyTMVarM :: MonadSTM m => m ( StrictTMVar m a)
newEmptyTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => STM m ( StrictTMVar m a)
newTMVarM :: MonadSTM m => a -> m ( StrictTMVar m a)
castStrictTMVar :: forall (m :: Type -> Type ) (n :: Type -> Type ) a. LazyTMVar m ~ LazyTMVar n => StrictTMVar m a -> StrictTMVar n a
traceTMVarIO :: MonadTraceSTM m => proxy m -> StrictTMVar m a -> ( Maybe ( Maybe a) -> Maybe a -> InspectMonad m TraceValue ) -> m ()
traceTMVar :: forall (m :: Type -> Type ) proxy a. MonadTraceSTM m => proxy m -> StrictTMVar m a -> ( Maybe ( Maybe a) -> Maybe a -> InspectMonad m TraceValue ) -> STM m ()
labelTMVarIO :: MonadLabelledSTM m => StrictTMVar m a -> String -> m ()
labelTMVar :: forall (m :: Type -> Type ) a. MonadLabelledSTM m => StrictTMVar m a -> String -> STM m ()
fromLazyTMVar :: forall (m :: Type -> Type ) a. LazyTMVar m a -> StrictTMVar m a
updateTVar :: forall (m :: Type -> Type ) s a. MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a
swapTVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTVar m a -> a -> STM m a
stateTVar :: forall (m :: Type -> Type ) s a. MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a
modifyTVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTVar m a -> (a -> a) -> STM m ()
writeTVar :: forall (m :: Type -> Type ) a. ( MonadSTM m, HasCallStack ) => StrictTVar m a -> a -> STM m ()
readTVarIO :: MonadSTM m => StrictTVar m a -> m a
readTVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTVar m a -> STM m a
newTVarWithInvariantM :: ( MonadSTM m, HasCallStack ) => (a -> Maybe String ) -> a -> m ( StrictTVar m a)
newTVarWithInvariant :: forall (m :: Type -> Type ) a. ( MonadSTM m, HasCallStack ) => (a -> Maybe String ) -> a -> STM m ( StrictTVar m a)
newTVarM :: MonadSTM m => a -> m ( StrictTVar m a)
fromLazyTVar :: forall (m :: Type -> Type ) a. LazyTVar m a -> StrictTVar m a
toLazyTVar :: forall (m :: Type -> Type ) a. StrictTVar m a -> LazyTVar m a
castStrictTVar :: forall (m :: Type -> Type ) (n :: Type -> Type ) a. LazyTVar m ~ LazyTVar n => StrictTVar m a -> StrictTVar n a
traceTVarIO :: MonadTraceSTM m => proxy m -> StrictTVar m a -> ( Maybe a -> a -> InspectMonad m TraceValue ) -> m ()
traceTVar :: forall (m :: Type -> Type ) proxy a. MonadTraceSTM m => proxy m -> StrictTVar m a -> ( Maybe a -> a -> InspectMonad m TraceValue ) -> STM m ()
labelTVarIO :: MonadLabelledSTM m => StrictTVar m a -> String -> m ()
labelTVar :: forall (m :: Type -> Type ) a. MonadLabelledSTM m => StrictTVar m a -> String -> STM m ()
type LazyTVar (m :: Type -> Type ) = TVar m
type LazyTMVar (m :: Type -> Type ) = TMVar m
data StrictTMVar (m :: Type -> Type ) a
data StrictMVar m a = StrictMVar {
- invariant :: !(a -> Maybe String )
- tmvar :: !( TMVar m a)
- tvar :: !( TVar m a)
}
castStrictMVar :: ( TMVar m ~ TMVar n, TVar m ~ TVar n) => StrictMVar m a -> StrictMVar n a
takeMVar :: MonadSTM m => StrictMVar m a -> m a
tryTakeMVar :: MonadSTM m => StrictMVar m a -> m ( Maybe a)
putMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> a -> m ()
tryPutMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> a -> m Bool
readMVar :: MonadSTM m => StrictMVar m a -> m a
tryReadMVar :: MonadSTM m => StrictMVar m a -> m ( Maybe a)
readMVarSTM :: MonadSTM m => StrictMVar m a -> STM m a
swapMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> a -> m a
isEmptyMVar :: MonadSTM m => StrictMVar m a -> m Bool
updateMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> (a -> (a, b)) -> m b
updateMVar_ :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> (a -> a) -> m ()
modifyMVar :: ( MonadSTM m, MonadCatch m, HasCallStack ) => StrictMVar m a -> (a -> m (a, b)) -> m b
modifyMVar_ :: ( MonadSTM m, MonadCatch m, HasCallStack ) => StrictMVar m a -> (a -> m a) -> m ()
newEmptyMVar :: ( MonadSTM m, NoThunks a) => a -> m ( StrictMVar m a)
newMVar :: ( MonadSTM m, HasCallStack , NoThunks a) => a -> m ( StrictMVar m a)
newTVar :: ( MonadSTM m, HasCallStack , NoThunks a) => a -> STM m ( StrictTVar m a)
newTVarIO :: ( MonadSTM m, HasCallStack , NoThunks a) => a -> m ( StrictTVar m a)
uncheckedNewEmptyMVar :: MonadSTM m => a -> m ( StrictMVar m a)
uncheckedNewMVar :: MonadSTM m => a -> m ( StrictMVar m a)
uncheckedNewTVarM :: MonadSTM m => a -> m ( StrictTVar m a)

Documentation

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.

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

throwIO specialised to stm monad.

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

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

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

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

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

tryPeekTBQueueDefault :: 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 #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

newEmptyTMVarMDefault :: MonadSTM m => m ( TMVarDefault m a) Source #

newEmptyTMVarIODefault :: MonadSTM m => m ( TMVarDefault m a) Source #

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

newTMVarMDefault :: MonadSTM m => a -> m ( TMVarDefault m a) Source #

newTMVarIODefault :: MonadSTM m => a -> m ( TMVarDefault m a) Source #

newTMVarDefault :: forall (m :: Type -> Type ) a. MonadSTM m => a -> STM m ( TMVarDefault m a) 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 #

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

type family TBQueue (m :: Type -> Type ) :: Type -> Type Source #

Instances

Instances details

type TBQueue IO
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue IO = TBQueue
type TBQueue ( WithEarlyExit m) Source #
Instance details Defined in Ouroboros.Consensus.Util.EarlyExit type TBQueue ( WithEarlyExit m) = TBQueue m
type TBQueue ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( StateT s m) = TBQueue m
type TBQueue ( ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( ReaderT r m) = TBQueue m
type TBQueue ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( ExceptT e m) = TBQueue m
type TBQueue ( WriterT w m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( WriterT w m) = TBQueue m
type TBQueue ( ContT r m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( ContT r m) = TBQueue m
type TBQueue ( RWST r w s m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( RWST r w s m) = TBQueue m

type family TQueue (m :: Type -> Type ) :: Type -> Type Source #

Instances

Instances details

type TQueue IO
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue IO = TQueue
type TQueue ( WithEarlyExit m) Source #
Instance details Defined in Ouroboros.Consensus.Util.EarlyExit type TQueue ( WithEarlyExit m) = TQueue m
type TQueue ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( StateT s m) = TQueue m
type TQueue ( ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( ReaderT r m) = TQueue m
type TQueue ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( ExceptT e m) = TQueue m
type TQueue ( WriterT w m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( WriterT w m) = TQueue m
type TQueue ( ContT r m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( ContT r m) = TQueue m
type TQueue ( RWST r w s m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( RWST r w s m) = TQueue m

type family STM (m :: Type -> Type ) = (stm :: Type -> Type ) | stm -> m Source #

Instances

Instances details

type STM IO
Instance details Defined in Control.Monad.Class.MonadSTM type STM IO = STM
type STM ( WithEarlyExit m) Source #
Instance details Defined in Ouroboros.Consensus.Util.EarlyExit type STM ( WithEarlyExit m) = WithEarlyExit ( STM m)
type STM ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( StateT s m) = WrappedSTM 'State s m
type STM ( ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( ReaderT r m) = WrappedSTM 'Reader r m
type STM ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( ExceptT e m) = WrappedSTM 'Except e m
type STM ( WriterT w m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( WriterT w m) = WrappedSTM 'Writer w m
type STM ( ContT r m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( ContT r m) = WrappedSTM 'Cont r m
type STM ( RWST r w s m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( RWST r w s m) = WrappedSTM 'RWS (r, w, s) m

class ( Monad m, Alternative ( STM m), MonadPlus ( STM m)) => MonadSTM (m :: Type -> Type ) where Source #

Minimal complete definition

atomically , newTVar , readTVar , writeTVar , retry , orElse , newTMVar , newEmptyTMVar , takeTMVar , tryTakeTMVar , putTMVar , tryPutTMVar , readTMVar , tryReadTMVar , swapTMVar , isEmptyTMVar , newTQueue , readTQueue , tryReadTQueue , peekTQueue , tryPeekTQueue , writeTQueue , isEmptyTQueue , newTBQueue , readTBQueue , tryReadTBQueue , peekTBQueue , tryPeekTBQueue , flushTBQueue , writeTBQueue , lengthTBQueue , isEmptyTBQueue , isFullTBQueue

Associated Types

type STM (m :: Type -> Type ) = (stm :: Type -> Type ) | stm -> m Source #

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

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

Methods

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

retry :: STM m a Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Since: io-classes-0.2.0.0

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

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

newTQueueIO :: m ( TQueue m a) Source #

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

Instances

Instances details

MonadSTM IO
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM IO = (stm :: Type -> Type ) Source # type TVar IO :: Type -> Type Source # type TMVar IO :: Type -> Type Source # type TQueue IO :: Type -> Type Source # type TBQueue IO :: Type -> Type Source # 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 # 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 # writeTQueue :: TQueue IO a -> a -> STM IO () Source # isEmptyTQueue :: TQueue IO a -> STM IO Bool 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 # 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 #
MonadSTM m => MonadSTM ( WithEarlyExit m) Source #
Instance details Defined in Ouroboros.Consensus.Util.EarlyExit Associated Types type STM ( WithEarlyExit m) = (stm :: Type -> Type ) Source # type TVar ( WithEarlyExit m) :: Type -> Type Source # type TMVar ( WithEarlyExit m) :: Type -> Type Source # type TQueue ( WithEarlyExit m) :: Type -> Type Source # type TBQueue ( WithEarlyExit m) :: Type -> Type Source # Methods atomically :: HasCallStack => STM ( WithEarlyExit m) a -> WithEarlyExit m a Source # newTVar :: a -> STM ( WithEarlyExit m) ( TVar ( WithEarlyExit m) a) Source # readTVar :: TVar ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # writeTVar :: TVar ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) () Source # retry :: STM ( WithEarlyExit m) a Source # orElse :: STM ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # modifyTVar :: TVar ( WithEarlyExit m) a -> (a -> a) -> STM ( WithEarlyExit m) () Source # modifyTVar' :: TVar ( WithEarlyExit m) a -> (a -> a) -> STM ( WithEarlyExit m) () Source # stateTVar :: TVar ( WithEarlyExit m) s -> (s -> (a, s)) -> STM ( WithEarlyExit m) a Source # swapTVar :: TVar ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) a Source # check :: Bool -> STM ( WithEarlyExit m) () Source # newTMVar :: a -> STM ( WithEarlyExit m) ( TMVar ( WithEarlyExit m) a) Source # newEmptyTMVar :: STM ( WithEarlyExit m) ( TMVar ( WithEarlyExit m) a) Source # takeTMVar :: TMVar ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # tryTakeTMVar :: TMVar ( WithEarlyExit m) a -> STM ( WithEarlyExit m) ( Maybe a) Source # putTMVar :: TMVar ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) () Source # tryPutTMVar :: TMVar ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) Bool Source # readTMVar :: TMVar ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # tryReadTMVar :: TMVar ( WithEarlyExit m) a -> STM ( WithEarlyExit m) ( Maybe a) Source # swapTMVar :: TMVar ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) a Source # isEmptyTMVar :: TMVar ( WithEarlyExit m) a -> STM ( WithEarlyExit m) Bool Source # newTQueue :: STM ( WithEarlyExit m) ( TQueue ( WithEarlyExit m) a) Source # readTQueue :: TQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # tryReadTQueue :: TQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) ( Maybe a) Source # peekTQueue :: TQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # tryPeekTQueue :: TQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) ( Maybe a) Source # writeTQueue :: TQueue ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) () Source # isEmptyTQueue :: TQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) Bool Source # newTBQueue :: Natural -> STM ( WithEarlyExit m) ( TBQueue ( WithEarlyExit m) a) Source # readTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # tryReadTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) ( Maybe a) Source # peekTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) a Source # tryPeekTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) ( Maybe a) Source # flushTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) [a] Source # writeTBQueue :: TBQueue ( WithEarlyExit m) a -> a -> STM ( WithEarlyExit m) () Source # lengthTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) Natural Source # isEmptyTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) Bool Source # isFullTBQueue :: TBQueue ( WithEarlyExit m) a -> STM ( WithEarlyExit m) Bool Source # newTVarIO :: a -> WithEarlyExit m ( TVar ( WithEarlyExit m) a) Source # readTVarIO :: TVar ( WithEarlyExit m) a -> WithEarlyExit m a Source # newTMVarIO :: a -> WithEarlyExit m ( TMVar ( WithEarlyExit m) a) Source # newEmptyTMVarIO :: WithEarlyExit m ( TMVar ( WithEarlyExit m) a) Source # newTQueueIO :: WithEarlyExit m ( TQueue ( WithEarlyExit m) a) Source # newTBQueueIO :: Natural -> WithEarlyExit m ( TBQueue ( WithEarlyExit m) a) Source #
MonadSTM m => MonadSTM ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM ( StateT s m) = (stm :: Type -> Type ) Source # type TVar ( StateT s m) :: Type -> Type Source # type TMVar ( StateT s m) :: Type -> Type Source # type TQueue ( StateT s m) :: Type -> Type Source # type TBQueue ( StateT s m) :: Type -> Type Source # Methods atomically :: HasCallStack => STM ( StateT s m) a -> StateT s m a Source # newTVar :: a -> STM ( StateT s m) ( TVar ( StateT s m) a) Source # readTVar :: TVar ( StateT s m) a -> STM ( StateT s m) a Source # writeTVar :: TVar ( StateT s m) a -> a -> STM ( StateT s m) () Source # retry :: STM ( StateT s m) a Source # orElse :: STM ( StateT s m) a -> STM ( StateT s m) a -> STM ( StateT s m) a Source # modifyTVar :: TVar ( StateT s m) a -> (a -> a) -> STM ( StateT s m) () Source # modifyTVar' :: TVar ( StateT s m) a -> (a -> a) -> STM ( StateT s m) () Source # stateTVar :: TVar ( StateT s m) s0 -> (s0 -> (a, s0)) -> STM ( StateT s m) a Source # swapTVar :: TVar ( StateT s m) a -> a -> STM ( StateT s m) a Source # check :: Bool -> STM ( StateT s m) () Source # newTMVar :: a -> STM ( StateT s m) ( TMVar ( StateT s m) a) Source # newEmptyTMVar :: STM ( StateT s m) ( TMVar ( StateT s m) a) Source # takeTMVar :: TMVar ( StateT s m) a -> STM ( StateT s m) a Source # tryTakeTMVar :: TMVar ( StateT s m) a -> STM ( StateT s m) ( Maybe a) Source # putTMVar :: TMVar ( StateT s m) a -> a -> STM ( StateT s m) () Source # tryPutTMVar :: TMVar ( StateT s m) a -> a -> STM ( StateT s m) Bool Source # readTMVar :: TMVar ( StateT s m) a -> STM ( StateT s m) a Source # tryReadTMVar :: TMVar ( StateT s m) a -> STM ( StateT s m) ( Maybe a) Source # swapTMVar :: TMVar ( StateT s m) a -> a -> STM ( StateT s m) a Source # isEmptyTMVar :: TMVar ( StateT s m) a -> STM ( StateT s m) Bool Source # newTQueue :: STM ( StateT s m) ( TQueue ( StateT s m) a) Source # readTQueue :: TQueue ( StateT s m) a -> STM ( StateT s m) a Source # tryReadTQueue :: TQueue ( StateT s m) a -> STM ( StateT s m) ( Maybe a) Source # peekTQueue :: TQueue ( StateT s m) a -> STM ( StateT s m) a Source # tryPeekTQueue :: TQueue ( StateT s m) a -> STM ( StateT s m) ( Maybe a) Source # writeTQueue :: TQueue ( StateT s m) a -> a -> STM ( StateT s m) () Source # isEmptyTQueue :: TQueue ( StateT s m) a -> STM ( StateT s m) Bool Source # newTBQueue :: Natural -> STM ( StateT s m) ( TBQueue ( StateT s m) a) Source # readTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) a Source # tryReadTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) ( Maybe a) Source # peekTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) a Source # tryPeekTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) ( Maybe a) Source # flushTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) [a] Source # writeTBQueue :: TBQueue ( StateT s m) a -> a -> STM ( StateT s m) () Source # lengthTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) Natural Source # isEmptyTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) Bool Source # isFullTBQueue :: TBQueue ( StateT s m) a -> STM ( StateT s m) Bool Source # newTVarIO :: a -> StateT s m ( TVar ( StateT s m) a) Source # readTVarIO :: TVar ( StateT s m) a -> StateT s m a Source # newTMVarIO :: a -> StateT s m ( TMVar ( StateT s m) a) Source # newEmptyTMVarIO :: StateT s m ( TMVar ( StateT s m) a) Source # newTQueueIO :: StateT s m ( TQueue ( StateT s m) a) Source # newTBQueueIO :: Natural -> StateT s m ( TBQueue ( StateT s m) a) Source #
MonadSTM m => MonadSTM ( ReaderT r m)
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM ( ReaderT r m) = (stm :: Type -> Type ) Source # type TVar ( ReaderT r m) :: Type -> Type Source # type TMVar ( ReaderT r m) :: Type -> Type Source # type TQueue ( ReaderT r m) :: Type -> Type Source # type TBQueue ( ReaderT r m) :: Type -> Type Source # 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 # 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 # writeTQueue :: TQueue ( ReaderT r m) a -> a -> STM ( ReaderT r m) () Source # isEmptyTQueue :: TQueue ( ReaderT r m) a -> STM ( ReaderT r m) Bool 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 # 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 #
MonadSTM m => MonadSTM ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM ( ExceptT e m) = (stm :: Type -> Type ) Source # type TVar ( ExceptT e m) :: Type -> Type Source # type TMVar ( ExceptT e m) :: Type -> Type Source # type TQueue ( ExceptT e m) :: Type -> Type Source # type TBQueue ( ExceptT e m) :: Type -> Type Source # Methods atomically :: HasCallStack => STM ( ExceptT e m) a -> ExceptT e m a Source # newTVar :: a -> STM ( ExceptT e m) ( TVar ( ExceptT e m) a) Source # readTVar :: TVar ( ExceptT e m) a -> STM ( ExceptT e m) a Source # writeTVar :: TVar ( ExceptT e m) a -> a -> STM ( ExceptT e m) () Source # retry :: STM ( ExceptT e m) a Source # orElse :: STM ( ExceptT e m) a -> STM ( ExceptT e m) a -> STM ( ExceptT e m) a Source # modifyTVar :: TVar ( ExceptT e m) a -> (a -> a) -> STM ( ExceptT e m) () Source # modifyTVar' :: TVar ( ExceptT e m) a -> (a -> a) -> STM ( ExceptT e m) () Source # stateTVar :: TVar ( ExceptT e m) s -> (s -> (a, s)) -> STM ( ExceptT e m) a Source # swapTVar :: TVar ( ExceptT e m) a -> a -> STM ( ExceptT e m) a Source # check :: Bool -> STM ( ExceptT e m) () Source # newTMVar :: a -> STM ( ExceptT e m) ( TMVar ( ExceptT e m) a) Source # newEmptyTMVar :: STM ( ExceptT e m) ( TMVar ( ExceptT e m) a) Source # takeTMVar :: TMVar ( ExceptT e m) a -> STM ( ExceptT e m) a Source # tryTakeTMVar :: TMVar ( ExceptT e m) a -> STM ( ExceptT e m) ( Maybe a) Source # putTMVar :: TMVar ( ExceptT e m) a -> a -> STM ( ExceptT e m) () Source # tryPutTMVar :: TMVar ( ExceptT e m) a -> a -> STM ( ExceptT e m) Bool Source # readTMVar :: TMVar ( ExceptT e m) a -> STM ( ExceptT e m) a Source # tryReadTMVar :: TMVar ( ExceptT e m) a -> STM ( ExceptT e m) ( Maybe a) Source # swapTMVar :: TMVar ( ExceptT e m) a -> a -> STM ( ExceptT e m) a Source # isEmptyTMVar :: TMVar ( ExceptT e m) a -> STM ( ExceptT e m) Bool Source # newTQueue :: STM ( ExceptT e m) ( TQueue ( ExceptT e m) a) Source # readTQueue :: TQueue ( ExceptT e m) a -> STM ( ExceptT e m) a Source # tryReadTQueue :: TQueue ( ExceptT e m) a -> STM ( ExceptT e m) ( Maybe a) Source # peekTQueue :: TQueue ( ExceptT e m) a -> STM ( ExceptT e m) a Source # tryPeekTQueue :: TQueue ( ExceptT e m) a -> STM ( ExceptT e m) ( Maybe a) Source # writeTQueue :: TQueue ( ExceptT e m) a -> a -> STM ( ExceptT e m) () Source # isEmptyTQueue :: TQueue ( ExceptT e m) a -> STM ( ExceptT e m) Bool Source # newTBQueue :: Natural -> STM ( ExceptT e m) ( TBQueue ( ExceptT e m) a) Source # readTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) a Source # tryReadTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) ( Maybe a) Source # peekTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) a Source # tryPeekTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) ( Maybe a) Source # flushTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) [a] Source # writeTBQueue :: TBQueue ( ExceptT e m) a -> a -> STM ( ExceptT e m) () Source # lengthTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) Natural Source # isEmptyTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) Bool Source # isFullTBQueue :: TBQueue ( ExceptT e m) a -> STM ( ExceptT e m) Bool Source # newTVarIO :: a -> ExceptT e m ( TVar ( ExceptT e m) a) Source # readTVarIO :: TVar ( ExceptT e m) a -> ExceptT e m a Source # newTMVarIO :: a -> ExceptT e m ( TMVar ( ExceptT e m) a) Source # newEmptyTMVarIO :: ExceptT e m ( TMVar ( ExceptT e m) a) Source # newTQueueIO :: ExceptT e m ( TQueue ( ExceptT e m) a) Source # newTBQueueIO :: Natural -> ExceptT e m ( TBQueue ( ExceptT e m) a) Source #
( Monoid w, MonadSTM m) => MonadSTM ( WriterT w m)
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM ( WriterT w m) = (stm :: Type -> Type ) Source # type TVar ( WriterT w m) :: Type -> Type Source # type TMVar ( WriterT w m) :: Type -> Type Source # type TQueue ( WriterT w m) :: Type -> Type Source # type TBQueue ( WriterT w m) :: Type -> Type Source # Methods atomically :: HasCallStack => STM ( WriterT w m) a -> WriterT w m a Source # newTVar :: a -> STM ( WriterT w m) ( TVar ( WriterT w m) a) Source # readTVar :: TVar ( WriterT w m) a -> STM ( WriterT w m) a Source # writeTVar :: TVar ( WriterT w m) a -> a -> STM ( WriterT w m) () Source # retry :: STM ( WriterT w m) a Source # orElse :: STM ( WriterT w m) a -> STM ( WriterT w m) a -> STM ( WriterT w m) a Source # modifyTVar :: TVar ( WriterT w m) a -> (a -> a) -> STM ( WriterT w m) () Source # modifyTVar' :: TVar ( WriterT w m) a -> (a -> a) -> STM ( WriterT w m) () Source # stateTVar :: TVar ( WriterT w m) s -> (s -> (a, s)) -> STM ( WriterT w m) a Source # swapTVar :: TVar ( WriterT w m) a -> a -> STM ( WriterT w m) a Source # check :: Bool -> STM ( WriterT w m) () Source # newTMVar :: a -> STM ( WriterT w m) ( TMVar ( WriterT w m) a) Source # newEmptyTMVar :: STM ( WriterT w m) ( TMVar ( WriterT w m) a) Source # takeTMVar :: TMVar ( WriterT w m) a -> STM ( WriterT w m) a Source # tryTakeTMVar :: TMVar ( WriterT w m) a -> STM ( WriterT w m) ( Maybe a) Source # putTMVar :: TMVar ( WriterT w m) a -> a -> STM ( WriterT w m) () Source # tryPutTMVar :: TMVar ( WriterT w m) a -> a -> STM ( WriterT w m) Bool Source # readTMVar :: TMVar ( WriterT w m) a -> STM ( WriterT w m) a Source # tryReadTMVar :: TMVar ( WriterT w m) a -> STM ( WriterT w m) ( Maybe a) Source # swapTMVar :: TMVar ( WriterT w m) a -> a -> STM ( WriterT w m) a Source # isEmptyTMVar :: TMVar ( WriterT w m) a -> STM ( WriterT w m) Bool Source # newTQueue :: STM ( WriterT w m) ( TQueue ( WriterT w m) a) Source # readTQueue :: TQueue ( WriterT w m) a -> STM ( WriterT w m) a Source # tryReadTQueue :: TQueue ( WriterT w m) a -> STM ( WriterT w m) ( Maybe a) Source # peekTQueue :: TQueue ( WriterT w m) a -> STM ( WriterT w m) a Source # tryPeekTQueue :: TQueue ( WriterT w m) a -> STM ( WriterT w m) ( Maybe a) Source # writeTQueue :: TQueue ( WriterT w m) a -> a -> STM ( WriterT w m) () Source # isEmptyTQueue :: TQueue ( WriterT w m) a -> STM ( WriterT w m) Bool Source # newTBQueue :: Natural -> STM ( WriterT w m) ( TBQueue ( WriterT w m) a) Source # readTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) a Source # tryReadTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) ( Maybe a) Source # peekTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) a Source # tryPeekTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) ( Maybe a) Source # flushTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) [a] Source # writeTBQueue :: TBQueue ( WriterT w m) a -> a -> STM ( WriterT w m) () Source # lengthTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) Natural Source # isEmptyTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) Bool Source # isFullTBQueue :: TBQueue ( WriterT w m) a -> STM ( WriterT w m) Bool Source # newTVarIO :: a -> WriterT w m ( TVar ( WriterT w m) a) Source # readTVarIO :: TVar ( WriterT w m) a -> WriterT w m a Source # newTMVarIO :: a -> WriterT w m ( TMVar ( WriterT w m) a) Source # newEmptyTMVarIO :: WriterT w m ( TMVar ( WriterT w m) a) Source # newTQueueIO :: WriterT w m ( TQueue ( WriterT w m) a) Source # newTBQueueIO :: Natural -> WriterT w m ( TBQueue ( WriterT w m) a) Source #
MonadSTM m => MonadSTM ( ContT r m)
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM ( ContT r m) = (stm :: Type -> Type ) Source # type TVar ( ContT r m) :: Type -> Type Source # type TMVar ( ContT r m) :: Type -> Type Source # type TQueue ( ContT r m) :: Type -> Type Source # type TBQueue ( ContT r m) :: Type -> Type Source # Methods atomically :: HasCallStack => STM ( ContT r m) a -> ContT r m a Source # newTVar :: a -> STM ( ContT r m) ( TVar ( ContT r m) a) Source # readTVar :: TVar ( ContT r m) a -> STM ( ContT r m) a Source # writeTVar :: TVar ( ContT r m) a -> a -> STM ( ContT r m) () Source # retry :: STM ( ContT r m) a Source # orElse :: STM ( ContT r m) a -> STM ( ContT r m) a -> STM ( ContT r m) a Source # modifyTVar :: TVar ( ContT r m) a -> (a -> a) -> STM ( ContT r m) () Source # modifyTVar' :: TVar ( ContT r m) a -> (a -> a) -> STM ( ContT r m) () Source # stateTVar :: TVar ( ContT r m) s -> (s -> (a, s)) -> STM ( ContT r m) a Source # swapTVar :: TVar ( ContT r m) a -> a -> STM ( ContT r m) a Source # check :: Bool -> STM ( ContT r m) () Source # newTMVar :: a -> STM ( ContT r m) ( TMVar ( ContT r m) a) Source # newEmptyTMVar :: STM ( ContT r m) ( TMVar ( ContT r m) a) Source # takeTMVar :: TMVar ( ContT r m) a -> STM ( ContT r m) a Source # tryTakeTMVar :: TMVar ( ContT r m) a -> STM ( ContT r m) ( Maybe a) Source # putTMVar :: TMVar ( ContT r m) a -> a -> STM ( ContT r m) () Source # tryPutTMVar :: TMVar ( ContT r m) a -> a -> STM ( ContT r m) Bool Source # readTMVar :: TMVar ( ContT r m) a -> STM ( ContT r m) a Source # tryReadTMVar :: TMVar ( ContT r m) a -> STM ( ContT r m) ( Maybe a) Source # swapTMVar :: TMVar ( ContT r m) a -> a -> STM ( ContT r m) a Source # isEmptyTMVar :: TMVar ( ContT r m) a -> STM ( ContT r m) Bool Source # newTQueue :: STM ( ContT r m) ( TQueue ( ContT r m) a) Source # readTQueue :: TQueue ( ContT r m) a -> STM ( ContT r m) a Source # tryReadTQueue :: TQueue ( ContT r m) a -> STM ( ContT r m) ( Maybe a) Source # peekTQueue :: TQueue ( ContT r m) a -> STM ( ContT r m) a Source # tryPeekTQueue :: TQueue ( ContT r m) a -> STM ( ContT r m) ( Maybe a) Source # writeTQueue :: TQueue ( ContT r m) a -> a -> STM ( ContT r m) () Source # isEmptyTQueue :: TQueue ( ContT r m) a -> STM ( ContT r m) Bool Source # newTBQueue :: Natural -> STM ( ContT r m) ( TBQueue ( ContT r m) a) Source # readTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) a Source # tryReadTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) ( Maybe a) Source # peekTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) a Source # tryPeekTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) ( Maybe a) Source # flushTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) [a] Source # writeTBQueue :: TBQueue ( ContT r m) a -> a -> STM ( ContT r m) () Source # lengthTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) Natural Source # isEmptyTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) Bool Source # isFullTBQueue :: TBQueue ( ContT r m) a -> STM ( ContT r m) Bool Source # newTVarIO :: a -> ContT r m ( TVar ( ContT r m) a) Source # readTVarIO :: TVar ( ContT r m) a -> ContT r m a Source # newTMVarIO :: a -> ContT r m ( TMVar ( ContT r m) a) Source # newEmptyTMVarIO :: ContT r m ( TMVar ( ContT r m) a) Source # newTQueueIO :: ContT r m ( TQueue ( ContT r m) a) Source # newTBQueueIO :: Natural -> ContT r m ( TBQueue ( ContT r m) a) Source #
( Monoid w, MonadSTM m) => MonadSTM ( RWST r w s m)
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type STM ( RWST r w s m) = (stm :: Type -> Type ) Source # type TVar ( RWST r w s m) :: Type -> Type Source # type TMVar ( RWST r w s m) :: Type -> Type Source # type TQueue ( RWST r w s m) :: Type -> Type Source # type TBQueue ( RWST r w s m) :: Type -> Type Source # Methods atomically :: HasCallStack => STM ( RWST r w s m) a -> RWST r w s m a Source # newTVar :: a -> STM ( RWST r w s m) ( TVar ( RWST r w s m) a) Source # readTVar :: TVar ( RWST r w s m) a -> STM ( RWST r w s m) a Source # writeTVar :: TVar ( RWST r w s m) a -> a -> STM ( RWST r w s m) () Source # retry :: STM ( RWST r w s m) a Source # orElse :: STM ( RWST r w s m) a -> STM ( RWST r w s m) a -> STM ( RWST r w s m) a Source # modifyTVar :: TVar ( RWST r w s m) a -> (a -> a) -> STM ( RWST r w s m) () Source # modifyTVar' :: TVar ( RWST r w s m) a -> (a -> a) -> STM ( RWST r w s m) () Source # stateTVar :: TVar ( RWST r w s m) s0 -> (s0 -> (a, s0)) -> STM ( RWST r w s m) a Source # swapTVar :: TVar ( RWST r w s m) a -> a -> STM ( RWST r w s m) a Source # check :: Bool -> STM ( RWST r w s m) () Source # newTMVar :: a -> STM ( RWST r w s m) ( TMVar ( RWST r w s m) a) Source # newEmptyTMVar :: STM ( RWST r w s m) ( TMVar ( RWST r w s m) a) Source # takeTMVar :: TMVar ( RWST r w s m) a -> STM ( RWST r w s m) a Source # tryTakeTMVar :: TMVar ( RWST r w s m) a -> STM ( RWST r w s m) ( Maybe a) Source # putTMVar :: TMVar ( RWST r w s m) a -> a -> STM ( RWST r w s m) () Source # tryPutTMVar :: TMVar ( RWST r w s m) a -> a -> STM ( RWST r w s m) Bool Source # readTMVar :: TMVar ( RWST r w s m) a -> STM ( RWST r w s m) a Source # tryReadTMVar :: TMVar ( RWST r w s m) a -> STM ( RWST r w s m) ( Maybe a) Source # swapTMVar :: TMVar ( RWST r w s m) a -> a -> STM ( RWST r w s m) a Source # isEmptyTMVar :: TMVar ( RWST r w s m) a -> STM ( RWST r w s m) Bool Source # newTQueue :: STM ( RWST r w s m) ( TQueue ( RWST r w s m) a) Source # readTQueue :: TQueue ( RWST r w s m) a -> STM ( RWST r w s m) a Source # tryReadTQueue :: TQueue ( RWST r w s m) a -> STM ( RWST r w s m) ( Maybe a) Source # peekTQueue :: TQueue ( RWST r w s m) a -> STM ( RWST r w s m) a Source # tryPeekTQueue :: TQueue ( RWST r w s m) a -> STM ( RWST r w s m) ( Maybe a) Source # writeTQueue :: TQueue ( RWST r w s m) a -> a -> STM ( RWST r w s m) () Source # isEmptyTQueue :: TQueue ( RWST r w s m) a -> STM ( RWST r w s m) Bool Source # newTBQueue :: Natural -> STM ( RWST r w s m) ( TBQueue ( RWST r w s m) a) Source # readTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) a Source # tryReadTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) ( Maybe a) Source # peekTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) a Source # tryPeekTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) ( Maybe a) Source # flushTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) [a] Source # writeTBQueue :: TBQueue ( RWST r w s m) a -> a -> STM ( RWST r w s m) () Source # lengthTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) Natural Source # isEmptyTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) Bool Source # isFullTBQueue :: TBQueue ( RWST r w s m) a -> STM ( RWST r w s m) Bool Source # newTVarIO :: a -> RWST r w s m ( TVar ( RWST r w s m) a) Source # readTVarIO :: TVar ( RWST r w s m) a -> RWST r w s m a Source # newTMVarIO :: a -> RWST r w s m ( TMVar ( RWST r w s m) a) Source # newEmptyTMVarIO :: RWST r w s m ( TMVar ( RWST r w s m) a) Source # newTQueueIO :: RWST r w s m ( TQueue ( RWST r w s m) a) Source # newTBQueueIO :: Natural -> RWST r w s m ( TBQueue ( RWST r w s m) a) Source #

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

Labelled TVar s, TMVar s, TQueue s and TBQueue s.

Minimal complete definition

labelTVar , labelTMVar , labelTQueue , labelTBQueue

Methods

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

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

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

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

Instances

Instances details

MonadLabelledSTM IO

noop instance

Instance details

Defined in Control.Monad.Class.MonadSTM

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 #

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 #

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

Instances

Instances details

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

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

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

Instances

Instances details

MonadInspectSTM IO
Instance details Defined in Control.Monad.Class.MonadSTM Associated Types type InspectMonad IO :: Type -> Type Source # Methods inspectTVar :: proxy IO -> TVar IO a -> InspectMonad IO a Source # inspectTMVar :: proxy IO -> TMVar IO a -> InspectMonad IO ( Maybe a) Source #

data TraceValue where Source #

A GADT which instructs how to trace the value. The traceDynamic will use dynamic tracing, e.g. traceM ; while traceString will be traced with EventSay .

Constructors

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

Bundled Patterns

pattern TraceDynamic :: () => Typeable tr => tr -> TraceValue	Use only 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

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 #

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

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

Instances

Instances details

MonadTraceSTM IO

noop instance

Instance details

Defined in Control.Monad.Class.MonadSTM

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 #

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

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

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

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

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

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

Constructors

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

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

Constructors

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

newtype WrappedSTM (t :: Trans) r (m :: Type -> Type ) a Source #

A newtype wrapper for an STM monad for monad transformers.

Constructors

WrappedSTM
Fields runWrappedSTM :: STM m a

Instances

Instances details

MonadSTM m => Monad ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods (>>=) :: WrappedSTM t r m a -> (a -> WrappedSTM t r m b) -> WrappedSTM t r m b Source # (>>) :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m b Source # return :: a -> WrappedSTM t r m a Source #
MonadSTM m => Functor ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods fmap :: (a -> b) -> WrappedSTM t r m a -> WrappedSTM t r m b Source # (<$) :: a -> WrappedSTM t r m b -> WrappedSTM t r m a Source #
MonadSTM m => Applicative ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods pure :: a -> WrappedSTM t r m a Source # (<>) :: WrappedSTM t r m (a -> b) -> WrappedSTM t r m a -> WrappedSTM t r m b Source # liftA2 :: (a -> b -> c) -> WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m c Source # (>) :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m b Source # (<*) :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m a Source #
MonadSTM m => MonadPlus ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods mzero :: WrappedSTM t r m a Source # mplus :: WrappedSTM t r m a -> WrappedSTM t r m a -> WrappedSTM t r m a Source #
MonadSTM m => Alternative ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods empty :: WrappedSTM t r m a Source # (<\|>) :: WrappedSTM t r m a -> WrappedSTM t r m a -> WrappedSTM t r m a Source # some :: WrappedSTM t r m a -> WrappedSTM t r m [a] Source # many :: WrappedSTM t r m a -> WrappedSTM t r m [a] Source #
( MonadSTM m, MonadThrow ( STM m), MonadCatch ( STM m)) => MonadThrow ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods throwIO :: Exception e => e -> WrappedSTM t r m a Source # bracket :: WrappedSTM t r m a -> (a -> WrappedSTM t r m b) -> (a -> WrappedSTM t r m c) -> WrappedSTM t r m c Source # bracket_ :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m c -> WrappedSTM t r m c Source # finally :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m a Source #
( MonadSTM m, MonadThrow ( STM m), MonadCatch ( STM m)) => MonadCatch ( WrappedSTM t r m)
Instance details Defined in Control.Monad.Class.MonadSTM Methods catch :: Exception e => WrappedSTM t r m a -> (e -> WrappedSTM t r m a) -> WrappedSTM t r m a Source # catchJust :: Exception e => (e -> Maybe b) -> WrappedSTM t r m a -> (b -> WrappedSTM t r m a) -> WrappedSTM t r m a Source # try :: Exception e => WrappedSTM t r m a -> WrappedSTM t r m ( Either e a) Source # tryJust :: Exception e => (e -> Maybe b) -> WrappedSTM t r m a -> WrappedSTM t r m ( Either b a) Source # handle :: Exception e => (e -> WrappedSTM t r m a) -> WrappedSTM t r m a -> WrappedSTM t r m a Source # handleJust :: Exception e => (e -> Maybe b) -> (b -> WrappedSTM t r m a) -> WrappedSTM t r m a -> WrappedSTM t r m a Source # onException :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m a Source # bracketOnError :: WrappedSTM t r m a -> (a -> WrappedSTM t r m b) -> (a -> WrappedSTM t r m c) -> WrappedSTM t r m c Source # generalBracket :: WrappedSTM t r m a -> (a -> ExitCase b -> WrappedSTM t r m c) -> (a -> WrappedSTM t r m b) -> WrappedSTM t r m (b, c) Source #

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

Instances

Instances details

NoThunks a => NoThunks ( StrictTVar IO a) Source #
Instance details Defined in Ouroboros.Consensus.Util.Orphans Methods noThunks :: Context -> StrictTVar IO a -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> StrictTVar IO a -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( StrictTVar IO a) -> String Source #

checkInvariant :: HasCallStack => Maybe String -> a -> a Source #

Check invariant (if enabled) before continuing

checkInvariant mErr x is equal to x if mErr == Nothing , and throws an error err if mErr == Just err .

This is exported so that other code that wants to conditionally check invariants can reuse the same logic, rather than having to introduce new per-package flags.

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

swapTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> a -> STM m a Source #

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

readTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m a Source #

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

putTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> a -> STM m () Source #

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

takeTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTMVar m a -> STM m a Source #

newEmptyTMVarM :: MonadSTM m => m ( StrictTMVar m a) Source #

newEmptyTMVar :: forall (m :: Type -> Type ) a. MonadSTM m => STM m ( StrictTMVar m a) Source #

newTMVarM :: MonadSTM m => a -> m ( StrictTMVar m a) Source #

castStrictTMVar :: forall (m :: Type -> Type ) (n :: Type -> Type ) a. LazyTMVar m ~ LazyTMVar n => StrictTMVar m a -> StrictTMVar n a Source #

traceTMVarIO :: MonadTraceSTM m => proxy m -> StrictTMVar m a -> ( Maybe ( Maybe a) -> Maybe a -> InspectMonad m TraceValue ) -> m () Source #

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

labelTMVarIO :: MonadLabelledSTM m => StrictTMVar m a -> String -> m () Source #

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

fromLazyTMVar :: forall (m :: Type -> Type ) a. LazyTMVar m a -> StrictTMVar m a Source #

updateTVar :: forall (m :: Type -> Type ) s a. MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a Source #

swapTVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTVar m a -> a -> STM m a Source #

stateTVar :: forall (m :: Type -> Type ) s a. MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a Source #

modifyTVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTVar m a -> (a -> a) -> STM m () Source #

writeTVar :: forall (m :: Type -> Type ) a. ( MonadSTM m, HasCallStack ) => StrictTVar m a -> a -> STM m () Source #

readTVarIO :: MonadSTM m => StrictTVar m a -> m a Source #

readTVar :: forall (m :: Type -> Type ) a. MonadSTM m => StrictTVar m a -> STM m a Source #

newTVarWithInvariantM Source #

Arguments

:: ( MonadSTM m, HasCallStack )
=> (a -> Maybe String )	Invariant (expect `Nothing` )
-> a
-> m ( StrictTVar m a)

newTVarWithInvariant Source #

Arguments

:: forall (m :: Type -> Type ) a. ( MonadSTM m, HasCallStack )
=> (a -> Maybe String )	Invariant (expect `Nothing` )
-> a
-> STM m ( StrictTVar m a)

newTVarM :: MonadSTM m => a -> m ( StrictTVar m a) Source #

fromLazyTVar :: forall (m :: Type -> Type ) a. LazyTVar m a -> StrictTVar m a Source #

toLazyTVar :: forall (m :: Type -> Type ) a. StrictTVar m a -> LazyTVar m a Source #

Get the underlying TVar

Since we obviously cannot guarantee that updates to this LazyTVar will be strict, this should be used with caution.

castStrictTVar :: forall (m :: Type -> Type ) (n :: Type -> Type ) a. LazyTVar m ~ LazyTVar n => StrictTVar m a -> StrictTVar n a Source #

traceTVarIO :: MonadTraceSTM m => proxy m -> StrictTVar m a -> ( Maybe a -> a -> InspectMonad m TraceValue ) -> m () Source #

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

labelTVarIO :: MonadLabelledSTM m => StrictTVar m a -> String -> m () Source #

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

type LazyTVar (m :: Type -> Type ) = TVar m Source #

type LazyTMVar (m :: Type -> Type ) = TMVar m Source #

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

data StrictMVar m a Source #

Strict MVar (modelled using a lazy TMVar under the hood)

The StrictMVar API is slightly stronger than the usual MVar one, as we offer a primitive to read the value of the MVar even if it is empty (in which case we will return the oldest known stale one). See readMVarSTM .

There is a weaker invariant for a StrictMVar than for a StrictTVar : although all functions that modify the StrictMVar check the invariant, we do not guarantee that the value inside the StrictMVar always satisfies the invariant. Instead, we do guarantee that if the StrictMVar is updated with a value that does not satisfy the invariant, an exception is thrown. The reason for this weaker guarantee is that leaving an MVar empty can lead to very hard to debug "blocked indefinitely" problems.

This is also the reason we do not offer support for an invariant in StrictTMVar : if we throw an exception from an STM transaction, the STM transaction is not executed, and so we would not even be able to provide the weaker guarantee that we provide for StrictMVar .

Constructors

StrictMVar

Fields

invariant :: !(a -> Maybe String )

Invariant checked whenever updating the StrictMVar .
tmvar :: !( TMVar m a)

The main TMVar supporting this StrictMVar
tvar :: !( TVar m a)

TVar for supporting readMVarSTM

This TVar is always kept up to date with the TMVar , but holds on the old value of the TMVar when it is empty. This is very useful to support single writer/many reader scenarios.

NOTE: We should always update the tmvar before the tvar so that if the update to the tmvar fails, the 'tvar is left unchanged.

Instances

Instances details

NoThunks a => NoThunks ( StrictMVar IO a) Source #
Instance details Defined in Ouroboros.Consensus.Util.MonadSTM.StrictMVar Methods noThunks :: Context -> StrictMVar IO a -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> StrictMVar IO a -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( StrictMVar IO a) -> String Source #

castStrictMVar :: ( TMVar m ~ TMVar n, TVar m ~ TVar n) => StrictMVar m a -> StrictMVar n a Source #

takeMVar :: MonadSTM m => StrictMVar m a -> m a Source #

tryTakeMVar :: MonadSTM m => StrictMVar m a -> m ( Maybe a) Source #

putMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> a -> m () Source #

tryPutMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> a -> m Bool Source #

readMVar :: MonadSTM m => StrictMVar m a -> m a Source #

tryReadMVar :: MonadSTM m => StrictMVar m a -> m ( Maybe a) Source #

readMVarSTM :: MonadSTM m => StrictMVar m a -> STM m a Source #

Read the possibly-stale value of the MVar

Will return the current value of the MVar if it non-empty, or the last known value otherwise.

swapMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> a -> m a Source #

Swap value of a StrictMVar

NOTE: Since swapping the value can't leave the StrictMVar empty, we could check the invariant first and only then swap. We nonetheless swap first and check the invariant after to keep the semantics the same with putMVar , otherwise it will be difficult to understand when a StrictMVar is updated and when it is not.

isEmptyMVar :: MonadSTM m => StrictMVar m a -> m Bool Source #

updateMVar :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> (a -> (a, b)) -> m b Source #

updateMVar_ :: ( MonadSTM m, HasCallStack ) => StrictMVar m a -> (a -> a) -> m () Source #

modifyMVar :: ( MonadSTM m, MonadCatch m, HasCallStack ) => StrictMVar m a -> (a -> m (a, b)) -> m b Source #

modifyMVar_ :: ( MonadSTM m, MonadCatch m, HasCallStack ) => StrictMVar m a -> (a -> m a) -> m () Source #

newEmptyMVar :: ( MonadSTM m, NoThunks a) => a -> m ( StrictMVar m a) Source #

newMVar :: ( MonadSTM m, HasCallStack , NoThunks a) => a -> m ( StrictMVar m a) Source #

newTVar :: ( MonadSTM m, HasCallStack , NoThunks a) => a -> STM m ( StrictTVar m a) Source #

newTVarIO :: ( MonadSTM m, HasCallStack , NoThunks a) => a -> m ( StrictTVar m a) Source #

Temporary

uncheckedNewEmptyMVar :: MonadSTM m => a -> m ( StrictMVar m a) Source #

uncheckedNewMVar :: MonadSTM m => a -> m ( StrictMVar m a) Source #

uncheckedNewTVarM :: MonadSTM m => a -> m ( StrictTVar m a) Source #