Test.DejaFu.STM

A MonadSTM implementation, which can be run on top of IO or ST.

The STMLike Monad

data STMLike n r a

Instances

MonadIO ConcIO

Methods

liftIO :: IO a -> ConcIO a

MonadBase IO ConcIO

Methods

liftBase :: IO α -> ConcIO α

Monad (STMLike n r)

Methods

(>>=) :: STMLike n r a -> (a -> STMLike n r b) -> STMLike n r b

(>>) :: STMLike n r a -> STMLike n r b -> STMLike n r b

return :: a -> STMLike n r a

fail :: String -> STMLike n r a

Functor (STMLike n r)

Methods

fmap :: (a -> b) -> STMLike n r a -> STMLike n r b

(<$) :: a -> STMLike n r b -> STMLike n r a

Applicative (STMLike n r)

Methods

pure :: a -> STMLike n r a

(<*>) :: STMLike n r (a -> b) -> STMLike n r a -> STMLike n r b

(*>) :: STMLike n r a -> STMLike n r b -> STMLike n r b

(<*) :: STMLike n r a -> STMLike n r b -> STMLike n r a

MonadThrow (STMLike n r)

Methods

throwM :: Exception e => e -> STMLike n r a

MonadCatch (STMLike n r)

Methods

catch :: Exception e => STMLike n r a -> (e -> STMLike n r a) -> STMLike n r a

Monad n => MonadSTM (STMLike n r)

Associated Types

type TVar (STMLike n r :: * -> *) :: * -> *

Methods

retry :: STMLike n r a

orElse :: STMLike n r a -> STMLike n r a -> STMLike n r a

newTVar :: a -> STMLike n r (TVar (STMLike n r) a)

newTVarN :: String -> a -> STMLike n r (TVar (STMLike n r) a)

readTVar :: TVar (STMLike n r) a -> STMLike n r a

writeTVar :: TVar (STMLike n r) a -> a -> STMLike n r ()

Monad n => MonadConc (Conc n r (STMLike n r))

Associated Types

type STM (Conc n r (STMLike n r) :: * -> *) :: * -> *

type MVar (Conc n r (STMLike n r) :: * -> *) :: * -> *

type CRef (Conc n r (STMLike n r) :: * -> *) :: * -> *

type Ticket (Conc n r (STMLike n r) :: * -> *) :: * -> *

type ThreadId (Conc n r (STMLike n r) :: * -> *) :: *

Methods

fork :: Conc n r (STMLike n r) () -> Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

forkWithUnmask :: ((forall a. Conc n r (STMLike n r) a -> Conc n r (STMLike n r) a) -> Conc n r (STMLike n r) ()) -> Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

forkWithUnmaskN :: String -> ((forall a. Conc n r (STMLike n r) a -> Conc n r (STMLike n r) a) -> Conc n r (STMLike n r) ()) -> Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

forkOn :: Int -> Conc n r (STMLike n r) () -> Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

forkOnWithUnmask :: Int -> ((forall a. Conc n r (STMLike n r) a -> Conc n r (STMLike n r) a) -> Conc n r (STMLike n r) ()) -> Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

forkOnWithUnmaskN :: String -> Int -> ((forall a. Conc n r (STMLike n r) a -> Conc n r (STMLike n r) a) -> Conc n r (STMLike n r) ()) -> Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

getNumCapabilities :: Conc n r (STMLike n r) Int

setNumCapabilities :: Int -> Conc n r (STMLike n r) ()

myThreadId :: Conc n r (STMLike n r) (ThreadId (Conc n r (STMLike n r)))

yield :: Conc n r (STMLike n r) ()

threadDelay :: Int -> Conc n r (STMLike n r) ()

newEmptyMVar :: Conc n r (STMLike n r) (MVar (Conc n r (STMLike n r)) a)

newEmptyMVarN :: String -> Conc n r (STMLike n r) (MVar (Conc n r (STMLike n r)) a)

putMVar :: MVar (Conc n r (STMLike n r)) a -> a -> Conc n r (STMLike n r) ()

tryPutMVar :: MVar (Conc n r (STMLike n r)) a -> a -> Conc n r (STMLike n r) Bool

readMVar :: MVar (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) a

takeMVar :: MVar (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) a

tryTakeMVar :: MVar (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) (Maybe a)

newCRef :: a -> Conc n r (STMLike n r) (CRef (Conc n r (STMLike n r)) a)

newCRefN :: String -> a -> Conc n r (STMLike n r) (CRef (Conc n r (STMLike n r)) a)

readCRef :: CRef (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) a

atomicModifyCRef :: CRef (Conc n r (STMLike n r)) a -> (a -> (a, b)) -> Conc n r (STMLike n r) b

writeCRef :: CRef (Conc n r (STMLike n r)) a -> a -> Conc n r (STMLike n r) ()

atomicWriteCRef :: CRef (Conc n r (STMLike n r)) a -> a -> Conc n r (STMLike n r) ()

readForCAS :: CRef (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) (Ticket (Conc n r (STMLike n r)) a)

peekTicket :: Ticket (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) a

casCRef :: CRef (Conc n r (STMLike n r)) a -> Ticket (Conc n r (STMLike n r)) a -> a -> Conc n r (STMLike n r) (Bool, Ticket (Conc n r (STMLike n r)) a)

modifyCRefCAS :: CRef (Conc n r (STMLike n r)) a -> (a -> (a, b)) -> Conc n r (STMLike n r) b

modifyCRefCAS_ :: CRef (Conc n r (STMLike n r)) a -> (a -> a) -> Conc n r (STMLike n r) ()

atomically :: STM (Conc n r (STMLike n r)) a -> Conc n r (STMLike n r) a

readTVarConc :: TVar (STM (Conc n r (STMLike n r))) a -> Conc n r (STMLike n r) a

throwTo :: Exception e => ThreadId (Conc n r (STMLike n r)) -> e -> Conc n r (STMLike n r) ()

_concKnowsAbout :: Either (MVar (Conc n r (STMLike n r)) a) (TVar (STM (Conc n r (STMLike n r))) a) -> Conc n r (STMLike n r) ()

_concForgets :: Either (MVar (Conc n r (STMLike n r)) a) (TVar (STM (Conc n r (STMLike n r))) a) -> Conc n r (STMLike n r) ()

_concAllKnown :: Conc n r (STMLike n r) ()

_concMessage :: Typeable * a => a -> Conc n r (STMLike n r) ()

type TVar (STMLike n r)

type TVar (STMLike n r) = TVar r

type STM (Conc n r (STMLike n r))

type STM (Conc n r (STMLike n r)) = STMLike n r

type MVar (Conc n r (STMLike n r))

type MVar (Conc n r (STMLike n r)) = MVar r

type CRef (Conc n r (STMLike n r))

type CRef (Conc n r (STMLike n r)) = CRef r

type Ticket (Conc n r (STMLike n r))

type Ticket (Conc n r (STMLike n r)) = Ticket

type ThreadId (Conc n r (STMLike n r))

type ThreadId (Conc n r (STMLike n r)) = ThreadId

type STMST t = STMLike (ST t) (STRef t)

A MonadSTM implementation using ST, it encapsulates a single atomic transaction. The environment, that is, the collection of defined TVars is implicit, there is no list of them, they exist purely as references. This makes the types simpler, but means you can't really get an aggregate of them (if you ever wanted to for some reason).

type STMIO = STMLike IO IORef

A MonadSTM implementation using ST, it encapsulates a single atomic transaction. The environment, that is, the collection of defined TVars is implicit, there is no list of them, they exist purely as references. This makes the types simpler, but means you can't really get an aggregate of them (if you ever wanted to for some reason).

Executing Transactions

data Result a

The result of an STM transaction, along with which TVars it touched whilst executing.

Constructors

Success [TVarId] [TVarId] a

The transaction completed successfully, reading the first list TVars and writing to the second.

Retry [TVarId]

The transaction aborted by calling retry, and read the returned TVars. It should be retried when at least one of the TVars has been mutated.

Exception SomeException

The transaction aborted by throwing an exception.

Instances

Functor Result

Methods

fmap :: (a -> b) -> Result a -> Result b

(<$) :: a -> Result b -> Result a

Foldable Result

Methods

fold :: Monoid m => Result m -> m

foldMap :: Monoid m => (a -> m) -> Result a -> m

foldr :: (a -> b -> b) -> b -> Result a -> b

foldr' :: (a -> b -> b) -> b -> Result a -> b

foldl :: (b -> a -> b) -> b -> Result a -> b

foldl' :: (b -> a -> b) -> b -> Result a -> b

foldr1 :: (a -> a -> a) -> Result a -> a

foldl1 :: (a -> a -> a) -> Result a -> a

toList :: Result a -> [a]

null :: Result a -> Bool

length :: Result a -> Int

elem :: Eq a => a -> Result a -> Bool

maximum :: Ord a => Result a -> a

minimum :: Ord a => Result a -> a

sum :: Num a => Result a -> a

product :: Num a => Result a -> a

Show a => Show (Result a)

Methods

showsPrec :: Int -> Result a -> ShowS

show :: Result a -> String

showList :: [Result a] -> ShowS

type TTrace = [TAction]

A trace of an STM transaction is just a list of actions that occurred, as there are no scheduling decisions to make.

data TAction

All the actions that an STM transaction can perform.

Constructors

TNew

Create a new TVar

TRead TVarId

Read from a TVar.

TWrite TVarId

Write to a TVar.

TRetry

Abort and discard effects.

TOrElse TTrace (Maybe TTrace)

Execute a transaction until it succeeds (STMStop) or aborts (STMRetry) and, if it aborts, execute the other transaction.

TThrow

Throw an exception, abort, and discard effects.

TCatch TTrace (Maybe TTrace)

Execute a transaction until it succeeds (STMStop) or aborts (STMThrow). If the exception is of the appropriate type, it is handled and execution continues; otherwise aborts, propagating the exception upwards.

TStop

Terminate successfully and commit effects.

TLift

Lifts an action from the underlying monad. Note that the penultimate action in a trace will always be a Lift, this is an artefact of how the runner works.

Instances

Eq TAction

Methods

(==) :: TAction -> TAction -> Bool

(/=) :: TAction -> TAction -> Bool

Show TAction

Methods

showsPrec :: Int -> TAction -> ShowS

show :: TAction -> String

showList :: [TAction] -> ShowS

NFData TAction

Methods

rnf :: TAction -> ()

data TVarId

Every TVar has a unique identifier.

Instances

Eq TVarId

Methods

(==) :: TVarId -> TVarId -> Bool

(/=) :: TVarId -> TVarId -> Bool

Ord TVarId

Methods

compare :: TVarId -> TVarId -> Ordering

(<) :: TVarId -> TVarId -> Bool

(<=) :: TVarId -> TVarId -> Bool

(>) :: TVarId -> TVarId -> Bool

(>=) :: TVarId -> TVarId -> Bool

max :: TVarId -> TVarId -> TVarId

min :: TVarId -> TVarId -> TVarId

Show TVarId

Methods

showsPrec :: Int -> TVarId -> ShowS

show :: TVarId -> String

showList :: [TVarId] -> ShowS

NFData TVarId

Methods

rnf :: TVarId -> ()

runTransactionST :: STMST t a -> IdSource -> ST t (Result a, IdSource, TTrace)

Run a transaction in the ST monad, returning the result and new initial TVarId. If the transaction ended by calling retry, any TVar modifications are undone.

runTransactionIO :: STMIO a -> IdSource -> IO (Result a, IdSource, TTrace)

Run a transaction in the IO monad, returning the result and new initial TVarId. If the transaction ended by calling retry, any TVar modifications are undone.