Modulestrict-checked-vars-0.2.1.0Haskell2010

Control.Concurrent.Class.MonadSTM.Strict.TVar.Checked

This module corresponds to Control.Concurrent.STM.TVar in the stm package.

This module can be used as a drop-in replacement for Control.Concurrent.Class.MonadSTM.Strict.TVar, but not the other way around.

2 types
19 values

Packagestrict-checked-vars-0.2.1.0
Exports21
LanguageHaskell2010
LicenceApache-2.0
SourceChecked.hs

StrictTVar

16 declarations

typetype LazyTVar (m :: Type -> Type) = LazyTVar m

newtypenewtype StrictTVar (m :: Type -> Type) a

valuecastStrictTVar

:: LazyTVar m ~ LazyTVar n
=> StrictTVar m a
-> StrictTVar n a

valuefromLazyTVar :: LazyTVar m a -> StrictTVar m a

Create a StrictMVar from a LazyMVar

It is not guaranteed that the LazyTVar contains a value that is in WHNF, so there is no guarantee that the resulting StrictTVar contains a value that is in WHNF. This should be used with caution.

The resulting StrictTVar has a trivial invariant.

valuemodifyTVar :: MonadSTM m => StrictTVar m a -> (a -> a) -> STM m ()

valuenewTVar :: MonadSTM m => a -> STM m (StrictTVar m a)

valuenewTVarIO :: MonadSTM m => a -> m (StrictTVar m a)

valuenewTVarWithInvariant

:: (MonadSTM m, HasCallStack)
=> a -> Maybe String
-> a
-> STM m (StrictTVar m a)

valuenewTVarWithInvariantIO

:: (MonadSTM m, HasCallStack)
=> a -> Maybe String
-> a
-> m (StrictTVar m a)

valuereadTVar :: MonadSTM m => StrictTVar m a -> STM m a

valuereadTVarIO :: MonadSTM m => StrictTVar m a -> m a

valuestateTVar :: MonadSTM m => StrictTVar m s -> (s -> (a, s)) -> STM m a

valueswapTVar :: MonadSTM m => StrictTVar m a -> a -> STM m a

valuetoLazyTVar :: StrictTVar m a -> LazyTVar m a

Get the underlying TVar

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

Similarly, we can not guarantee that updates to this LazyTVar do not break the original invariant that the StrictTVar held.

valueunsafeToUncheckedStrictTVar :: StrictTVar m a -> StrictTVar m a

Create an unchecked reference to the given checked StrictTVar.

Note that the invariant is only guaranteed when modifying the checked TVar. Any modification to the unchecked reference might break the invariants.

valuewriteTVar :: (MonadSTM m, HasCallStack) => StrictTVar m a -> a -> STM m ()

MonadLabelSTM

2 declarations

valuelabelTVar :: MonadLabelledSTM m => StrictTVar m a -> String -> STM m ()

valuelabelTVarIO :: MonadLabelledSTM m => StrictTVar m a -> String -> m ()

MonadTraceSTM

2 declarations

valuetraceTVar

:: MonadTraceSTM m
=> proxy m
-> StrictTVar m a
-> Maybe a -> a -> InspectMonadSTM m TraceValue
-> STM m ()

valuetraceTVarIO

:: MonadTraceSTM m
=> StrictTVar m a
-> Maybe a -> a -> InspectMonadSTM m TraceValue
-> m ()

Invariant

1 declaration

valuecheckInvariant :: HasCallStack => Maybe String -> a -> a

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.