Start a new thread.

Start a new bound thread.

Check if the current thread is bound.

Get the ThreadId of the current thread.

Get the number of Haskell threads that can run simultaneously.

Set the number of Haskell threads that can run simultaneously.

Yield the current thread.

Yield/delay the current thread.

Create a new MVar.

Put into a MVar, possibly waking up some threads.

Get blocked on a put.

Try to put into a MVar, possibly waking up some threads.

Read from a MVar.

Try to read from a MVar.

Get blocked on a read.

Take from a MVar, possibly waking up some threads.

Get blocked on a take.

Try to take from a MVar, possibly waking up some threads.

Create a new CRef.

Read from a CRef.

Read from a CRef for a future compare-and-swap.

Modify a CRef.

Modify a CRef using a compare-and-swap.

Write to a CRef without synchronising.

Attempt to to a CRef using a compare-and-swap, synchronising it.

Commit the last write to the given CRef by the given thread, so that all threads can see the updated value.

An STM transaction was executed, possibly waking up some threads.

Got blocked in an STM transaction.

Register a new exception handler

Pop the innermost exception handler from the stack.

Throw an exception.

Throw an exception to a thread.

Get blocked on a throwTo.

Killed by an uncaught exception.

Set the masking state. If True, this is being used to set the masking state to the original state in the argument passed to a masked function.

Return to an earlier masking state. If True, this is being used to return to the state of the masked block in the argument passed to a masked function.

Lift an IO action. Note that this can only happen with ConcIO.

A return or pure action was executed.

Cease execution and terminate.

Start executing an action with subconcurrency.

Stop executing an action with subconcurrency.

Execute an action with dontCheck.

Will start a new thread.

Will start a new bound thread.

Will check if the current thread is bound.

Will get the ThreadId.

Will get the number of Haskell threads that can run simultaneously.

Will set the number of Haskell threads that can run simultaneously.

Will yield the current thread.

Will yield/delay the current thread.

Will create a new MVar.

Will put into a MVar, possibly waking up some threads.

Will try to put into a MVar, possibly waking up some threads.

Will read from a MVar.

Will try to read from a MVar.

Will take from a MVar, possibly waking up some threads.

Will try to take from a MVar, possibly waking up some threads.

Will create a new CRef.

Will read from a CRef.

Will read from a CRef for a future compare-and-swap.

Will modify a CRef.

Will modify a CRef using a compare-and-swap.

Will write to a CRef without synchronising.

Will attempt to to a CRef using a compare-and-swap, synchronising it.

Will commit the last write by the given thread to the CRef.

Will execute an STM transaction, possibly waking up some threads.

Will register a new exception handler

Will pop the innermost exception handler from the stack.

Will throw an exception.

Will throw an exception to a thread.

Will set the masking state. If True, this is being used to set the masking state to the original state in the argument passed to a masked function.

Will return to an earlier masking state. If True, this is being used to return to the state of the masked block in the argument passed to a masked function.

Will lift an IO action. Note that this can only happen with ConcIO.

Will execute a return or pure action.

Will cease execution and terminate.

Will execute an action with subconcurrency.

Will stop executing an extion with subconcurrency.

Will execute an action with dontCheck.

Create a new TVar

Read from a TVar.

Write to a TVar.

Abort and discard effects.

Execute a transaction. If the transaction aborts by calling retry, execute the other transaction.

Throw an exception, abort, and discard effects.

Execute a transaction. If the transaction aborts by throwing an exception of the appropriate type, it is handled and execution continues; otherwise aborts, propagating the exception upwards.

Terminate successfully and commit effects.

Start a new thread, because the last was blocked (or it's the start of computation).

Continue running the last thread for another step.

Pre-empt the running thread, and switch to another.

Will be raised if the scheduler does something bad. This should never arise unless you write your own, faulty, scheduler! If it does, please file a bug report.

The scheduler chose to abort execution. This will be produced if, for example, all possible decisions exceed the specified bounds (there have been too many pre-emptions, the computation has executed for too long, or there have been too many yields).

Every thread is blocked, and the main thread is not blocked in an STM transaction.

Every thread is blocked, and the main thread is blocked in an STM transaction.

An uncaught exception bubbled to the top of the computation.

Calls to subconcurrency were nested, or attempted when multiple threads existed.

A call to dontCheck was attempted after the first action of the initial thread.

Discard the trace but keep the result. The result will appear to have an empty trace.

Discard the result and the trace. It will simply not be reported as a possible behaviour of the program.

The most intuitive model: a program behaves as a simple interleaving of the actions in different threads. When a CRef is written to, that write is immediately visible to all threads.

Each thread has a write buffer. A thread sees its writes immediately, but other threads will only see writes when they are committed, which may happen later. Writes are committed in the same order that they are created.

Each CRef has a write buffer. A thread sees its writes immediately, but other threads will only see writes when they are committed, which may happen later. Writes to different CRefs are not necessarily committed in the same order that they are created.