Safe Haskell	None
Language	Haskell2010

Control.Monad.Class.MonadSTM.Strict

Contents

StrictTVar
StrictTMVar
- Low-level API
Deprecated API

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
}
type LazyTVar m = TVar m
type LazyTMVar m = TMVar m
data StrictTVar m a
labelTVar :: MonadLabelledSTM m => StrictTVar m a -> String -> STM m ()
labelTVarIO :: MonadLabelledSTM m => StrictTVar m a -> String -> m ()
traceTVar :: MonadTraceSTM m => proxy m -> StrictTVar m a -> ( Maybe a -> a -> InspectMonad m TraceValue ) -> STM m ()
traceTVarIO :: MonadTraceSTM m => proxy m -> StrictTVar m a -> ( Maybe a -> a -> InspectMonad m TraceValue ) -> m ()
castStrictTVar :: LazyTVar m ~ LazyTVar n => StrictTVar m a -> StrictTVar n a
toLazyTVar :: StrictTVar m a -> LazyTVar m a
fromLazyTVar :: LazyTVar m a -> StrictTVar m a
newTVar :: MonadSTM m => a -> STM m ( StrictTVar m a)
newTVarIO :: MonadSTM m => a -> m ( StrictTVar m a)
newTVarWithInvariant :: ( MonadSTM m, HasCallStack ) => (a -> Maybe String ) -> a -> STM m ( StrictTVar m a)
newTVarWithInvariantIO :: ( MonadSTM m, HasCallStack ) => (a -> Maybe String ) -> a -> m ( StrictTVar m a)
readTVar :: MonadSTM m => StrictTVar m a -> STM m a
readTVarIO :: MonadSTM m => StrictTVar m a -> m a
writeTVar :: ( MonadSTM m, HasCallStack ) => StrictTVar m a -> a -> STM m ()
modifyTVar :: MonadSTM m => StrictTVar m a -> (a -> a) -> STM m ()
stateTVar :: MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a
swapTVar :: MonadSTM m => StrictTVar m a -> a -> STM m a
data StrictTMVar m a
labelTMVar :: MonadLabelledSTM m => StrictTMVar m a -> String -> STM m ()
labelTMVarIO :: MonadLabelledSTM m => StrictTMVar m a -> String -> m ()
traceTMVar :: MonadTraceSTM m => proxy m -> StrictTMVar m a -> ( Maybe ( Maybe a) -> Maybe a -> InspectMonad m TraceValue ) -> STM m ()
traceTMVarIO :: MonadTraceSTM m => proxy m -> StrictTMVar m a -> ( Maybe ( Maybe a) -> Maybe a -> InspectMonad m TraceValue ) -> m ()
castStrictTMVar :: LazyTMVar m ~ LazyTMVar n => StrictTMVar m a -> StrictTMVar n a
$sel:toLazyTMVar:StrictTMVar :: StrictTMVar m a -> LazyTMVar m a
fromLazyTMVar :: LazyTMVar m a -> StrictTMVar m a
newTMVar :: MonadSTM m => a -> STM m ( StrictTMVar m a)
newTMVarIO :: MonadSTM m => a -> m ( StrictTMVar m a)
newEmptyTMVar :: MonadSTM m => STM m ( StrictTMVar m a)
newEmptyTMVarIO :: MonadSTM m => m ( StrictTMVar m a)
takeTMVar :: MonadSTM m => StrictTMVar m a -> STM m a
tryTakeTMVar :: MonadSTM m => StrictTMVar m a -> STM m ( Maybe a)
putTMVar :: MonadSTM m => StrictTMVar m a -> a -> STM m ()
tryPutTMVar :: MonadSTM m => StrictTMVar m a -> a -> STM m Bool
readTMVar :: MonadSTM m => StrictTMVar m a -> STM m a
tryReadTMVar :: MonadSTM m => StrictTMVar m a -> STM m ( Maybe a)
swapTMVar :: MonadSTM m => StrictTMVar m a -> a -> STM m a
isEmptyTMVar :: MonadSTM m => StrictTMVar m a -> STM m Bool
checkInvariant :: HasCallStack => Maybe String -> a -> a
updateTVar :: MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a
newTVarM :: MonadSTM m => a -> m ( StrictTVar m a)
newTVarWithInvariantM :: ( MonadSTM m, HasCallStack ) => (a -> Maybe String ) -> a -> m ( StrictTVar m a)
newTMVarM :: MonadSTM m => a -> m ( StrictTMVar m a)
newEmptyTMVarM :: MonadSTM m => m ( StrictTMVar 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 ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( ExceptT e 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 ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM type TBQueue ( StateT s 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 ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( ExceptT e 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 ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM type TQueue ( StateT s 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 ( ExceptT e m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( ExceptT e m) = WrappedSTM 'Except e 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 ( StateT s m)
Instance details Defined in Control.Monad.Class.MonadSTM type STM ( StateT s m) = WrappedSTM 'State s 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 ( 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 #
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 ( 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 #
( 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 => 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 => 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, 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 #

type LazyTVar m = TVar m Source #

type LazyTMVar m = TMVar m Source #

`StrictTVar`

data StrictTVar m a Source #

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

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

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

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

castStrictTVar :: LazyTVar m ~ LazyTVar n => StrictTVar m a -> StrictTVar n a Source #

toLazyTVar :: 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.

fromLazyTVar :: LazyTVar m a -> StrictTVar m a Source #

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

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

newTVarWithInvariant Source #

Arguments

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

newTVarWithInvariantIO Source #

Arguments

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

readTVar :: MonadSTM m => StrictTVar m a -> STM m a Source #

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

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

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

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

swapTVar :: MonadSTM m => StrictTVar m a -> a -> STM m a Source #

`StrictTMVar`

data StrictTMVar m a Source #

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

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

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

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

castStrictTMVar :: LazyTMVar m ~ LazyTMVar n => StrictTMVar m a -> StrictTMVar n a Source #

$sel:toLazyTMVar:StrictTMVar :: StrictTMVar m a -> LazyTMVar m a Source #

fromLazyTMVar :: LazyTMVar m a -> StrictTMVar m a Source #

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

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

newEmptyTMVar :: MonadSTM m => STM m ( StrictTMVar m a) Source #

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

takeTMVar :: MonadSTM m => StrictTMVar m a -> STM m a Source #

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

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

tryPutTMVar :: MonadSTM m => StrictTMVar m a -> a -> STM m Bool Source #

readTMVar :: MonadSTM m => StrictTMVar m a -> STM m a Source #

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

swapTMVar :: MonadSTM m => StrictTMVar m a -> a -> STM m a Source #

isEmptyTMVar :: MonadSTM m => StrictTMVar m a -> STM m Bool Source #

Low-level API

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.

Deprecated API

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

Deprecated: Use stateTVar

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

Deprecated: Use newTVarIO

newTVarWithInvariantM Source #

Arguments

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

Deprecated: Use newTVarWithInvariantIO

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

Deprecated: Use newTVarIO

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

Deprecated: Use newEmptyTMVarIO