A | |
| Array [Deferred] | |
| Async_stream |
For most applications one should use
Pipe instead of Stream.
|
B | |
| Block_group | |
C | |
| Clock [Std] | |
| Clock |
Clock includes functions to create deferreds that become determined at a certain time.
|
| Clock_event [Raw_scheduler] | |
| Clock_event | |
D | |
| Debug |
When
RECORD_ASYNC_BACKTRACES is set, the Async scheduler records a backtrace
everytime it schedules a job, and will include the backtrace history in any exceptions
raised to monitors, and in particular, in an unhandled exception that reaches the main
monitor.
|
| Deferred [Std] | |
| Deferred [Deferred_intf] | |
| Deferred |
A deferred is a value that will become determined asynchronously.
|
| Deferred [Raw_stream] | |
| Deferred [Raw_tail] | |
| Deferred_intf | |
| Deferred_std | |
| Direct [Execution_context.Fields] | |
| Direct [Raw_monitor.Fields] | |
E | |
| Event [Events] | |
| Event [Clock] |
Events provide a way to "abort"
at and after requests.
|
| Events |
Events is for keeping a set of events that need to happen in the future.
|
| Execution_context [Std] | |
| Execution_context [Import.Basic_scheduler] | |
| Execution_context | |
| Execution_context [Raw_scheduler] | |
| Exported_for_scheduler [Monitor] | |
F | |
| Fields [Execution_context] | |
| Fields [Raw_monitor] | |
H | |
| Handler [Std] | |
| Handler |
A handler is a continuation that captures the current async execution context.
|
| Handler [Raw_ivar] | |
I | |
| Import | |
| Infix [Deferred] | |
| Ivar [Std] | |
| Ivar |
An ivar is a write-once cell that can be empty or full (i.e.
|
| Ivar [Raw_scheduler] | |
| Ivar [Raw_clock_event] | |
| Ivar [Raw_tail] | |
J | |
| Job [Throttle] | |
| Job | |
| Jobs | length t returns the number of waiting jobs
|
L | |
| List [Deferred] | |
M | |
| Map [Deferred] | |
| Monitor [Std] | |
| Monitor |
A monitor is a context that determines what to do when there is an unhandled
exception.
|
| Monitor [Execution_context] | |
P | |
| Pipe [Std] | |
| Pipe |
A pipe is a buffered FIFO communication channel.
|
| Pretty [Raw_monitor] | |
| Priority [Std] | |
| Priority | |
| Priority [Jobs] | |
Q | |
| Queue [Deferred] | |
R | |
| Raw_async_stream | |
| Raw_clock_event | |
| Raw_deferred | |
| Raw_handler | |
| Raw_ivar | |
| Raw_monitor | |
| Raw_scheduler | |
| Raw_stream | |
| Raw_tail | |
| Reader [Pipe] | |
S | |
| Scheduler | |
| Scheduler [Clock_event] | |
| Scheduler_dependent [Raw_ivar] | |
| Scheduler_dependent [Raw_deferred] | |
| Sequencer [Std] | |
| Sequencer [Throttle] |
A sequencer is a throttle that is:
|
| Std | |
| Stream [Std] | |
| Stream [Raw_tail] | |
T | |
| T [Raw_handler] | |
| T [Raw_scheduler] | |
| T [Raw_clock_event] | |
| Tail |
A tail is a pointer to the end of a stream that can be used to extend the stream.
|
| Tail [Std] | |
| Tail [Raw_scheduler] | |
| Tail [Raw_monitor] | |
| Test | |
| Throttle |
Throttles for simultaneous computations.
|
| Throttle [Std] | |
U | |
| Unregister | |
W | |
| Work [Block_group] | |
| Writer [Pipe] |