Index of values

t1 >> t2 is equal to t1 >>= fun _ -> t2 which first execute t1 and wait for its result but ignore it, and then behaviors like t2

t >>= f is an alternative notation of bind t f

abort is a single transaction, when executed, abort the whole execution from current point.

always v returns an event that is always ready for synchronization.

This is an analog of atomically in Haskell, which repeatedly execute a transaction until the committing succeed.

atom_once execute a transaction and result in Some v if the transaction success and None if the transaction fail (due to conflicting in committing or abort).

bind t f is a transaction, when executed, first behavior as transaction t, then feed the reture value to f to get the consecutive transaction to execute next.

broadcast c restarts all processes waiting on the condition variable c.

catch t f is a transaction, when executed, behaviors as t if no exception arise, otherwise f is used to catch this exception and produce the replacing transaction to execute.

choose evl returns the event that is the alternative of all the events in the list evl.

Thread.create funct arg creates a new thread of control, in which the function application funct arg is executed concurrently with the other threads of the program.

Return a new mutex.

Return a new condition variable.

delay d suspends the execution of the calling thread for d seconds.

Terminate prematurely the currently executing thread.

guard fn returns the event that, when synchronized, computes fn() and behaves as the resulting event.

Return the identifier of the given thread.

join th suspends the execution of the calling thread until the thread th has terminated.

Terminate prematurely the thread whose handle is given.

Lock the given mutex.

Return a new channel.

We provide two functions to create a transactional variable from common value: tvar is traditional toplevel declaration as those new* and create* functions seen in most other library, it is ensured to succeed; while new_tvar is a transactional declaration (as in Haskell) which may fail if the execution of the whole transaction it's bound in fails.

or_else t1 t2 is a transaction, when executed, first try to execute t1.

Non-blocking version of Event.sync: offer all the communication possibilities specified in the event to the outside world, and if one can take place immediately, perform it and return Some r where r is the result value of that communication.

Read value from a transactional variable, results in a transaction which can be further composed with other transactions through bind etc., or executed right away with atom etc.

receive ch returns the event consisting in receiving a value from the channel ch.

retry is a transaction, when executed, first wait for the changing of any transactional variables being read in the history of current execution, then relaunch the whole execution.

retry_now is a transaction in the same spirit with retry, the only difference is that it does not wait for any changes and relaunch the execution immediately.

Primitive to wrap a plain of type 'a value to a 'a stm, which when being executed, will produces the orignal value.

Suspend the execution of the calling thead until input/output becomes possible on the given Unix file descriptors.

``Synchronize'' on an alternative of events.

Return the thread currently executing.

send ch v returns the event consisting in sending the value v over the channel ch.

sigmask cmd sigs changes the set of blocked signals for the calling thread.

signal c restarts one of the processes waiting on the condition variable c.

spawn f x launch up the computation of (f x) in a separate thread right away, the result is return as a event which you can sync with.

spawnl f x returns a event represents the computation of (f x) as a separate thread, just like spwan.

``Synchronize'' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed.

Same as Mutex.lock, but does not suspend the calling thread if the mutex is already locked: just return false immediately in that case.

Toplevel tvar declaration, produce a transaction variable from a value.

Unlock the given mutex.

wait is a transaction, when executed, simply wait for the changing of any transactional variables being read in the history of current execution, but without relaunch it.

wait c m atomically unlocks the mutex m and suspends the calling process on the condition variable c.

wait_pid p suspends the execution of the calling thread until the process specified by the process identifier p terminates.

See Thread.wait_write.

wait_signal sigs suspends the execution of the calling thread until the process receives one of the signals specified in the list sigs.

See Thread.wait_timed_read.

Suspend the execution of the calling thread until at least one character is available for reading (wait_read) or one character can be written without blocking (wait_write) on the given Unix file descriptor.

This function does nothing in this implementation.

wrap ev fn returns the event that performs the same communications as ev, then applies the post-processing function fn on the return value.

wrap_abort ev fn returns the event that performs the same communications as ev, but if it is not selected the function fn is called after the synchronization.

write_tvar tv v write value v to transactional variable tv, results in a transaction whose type is unit.

Re-schedule the calling thread without suspending it.