A  | |
| Array [Deferred] | |
| Async_condition | Async.Condition is async's implementation of the standard notion of a "condition"
    variable, and is analogous to OCaml's Condition module.
 | 
| Async_config [Std] | |
| Async_gc | |
| Async_or_error | 
This module is the deferred analog of  
Core.Or_error.
 | 
| Async_stream | 
For most applications one should use  
Pipe instead of Stream.
 | 
B  | |
| Backpatched [Std] | |
| Backpatched | 
A  
Backpatched value is either a simple value or a "hole", which may or may not have
    been filled.
 | 
C  | |
| Clock [Std] | |
| Clock | 
Schedule jobs to run at a time in the future.
 
 | 
| Condition [Std] | |
| Config | 
Settings that globally affect the behavior of async.
 
 | 
| Consumer [Pipe] | |
D  | |
| Debug | |
| Deferred [Std] | |
| Deferred [Raw_stream] | |
| Deferred [Raw_tail] | |
| Deferred [Ivar] | |
| Deferred [Deferred_intf] | |
| Deferred | 
A deferred is a value that will become determined asynchronously.
 
 | 
| Deferred_intf | |
| Deferred_std | |
| Direct [Raw_scheduler.T.Fields] | |
| Direct [Execution_context.Fields] | |
| Direct [Raw_monitor.Fields_of_t_] | |
E  | |
| Event [Clock] | 
Events provide abortable versions of  
at and after.
 | 
| Execution_context [Std] | |
| Execution_context [Raw_scheduler] | |
| Execution_context [Import.Basic_scheduler] | |
| Execution_context | |
| Exported_for_scheduler [Monitor] | |
F  | |
| Fields [Raw_scheduler.T] | |
| Fields [Execution_context] | |
| Fields_of_t_ [Raw_monitor] | |
| File_descr_watcher [Config] | |
| Flushed_result [Pipe] | |
G  | |
| Gc [Std] | |
H  | |
| Handler [Std] | |
| Handler [Raw_ivar] | |
| Handler | 
A handler is a continuation that captures the current async execution context.
 
 | 
| Hole [Backpatched] | |
I  | |
| Import | |
| Infix [Deferred] | |
| Ivar [Std] | |
| Ivar [Raw_tail] | |
| Ivar [Raw_scheduler] | |
| Ivar | 
An ivar is a write-once cell that can be empty or full (i.e.
 
 | 
J  | |
| Job [Throttle] | |
| Job | |
| Jobs | 
A  
Jobs.t has a queue of jobs at each priority level.
 | 
K  | |
| Kill_index | 
A timestamp used to implement  
Monitor.kill.
 | 
L  | |
| Lazy_deferred [Std] | |
| Lazy_deferred | 
A  
Lazy_deferred.t is a delayed computation that can produce a deferred.
 | 
| List [Deferred] | |
| List [Async_or_error] | |
M  | |
| Map [Deferred] | |
| Monitor [Std] | |
| Monitor [Raw_scheduler] | |
| Monitor | 
A monitor is a context that determines what to do when there is an unhandled
    exception.
 
 | 
| Monitor [Execution_context] | |
O  | |
| Option [Deferred] | |
| Or_error [Deferred] | |
P  | |
| Pipe [Std] | |
| Pipe | 
A pipe is a buffered FIFO communication channel.
 
 | 
| Pretty [Raw_monitor] | |
| Print_debug_messages_for [Config] | |
| Priority [Std] | |
| Priority | |
| Priority [Jobs] | 
A  
Jobs.t has a queue of jobs at each priority level.
 | 
Q  | |
| Queue [Deferred] | |
R  | |
| Raw_deferred | |
| Raw_handler | |
| Raw_ivar | |
| Raw_monitor | |
| Raw_scheduler | |
| Raw_stream | |
| Raw_tail | |
| Reader [Pipe] | |
| Result [Deferred] | |
S  | |
| Scheduler | preserve_execution_context f saves the current execution context and returns a
    function g such that g a adds a job that runs f a in the saved execution
    context.
 | 
| Scheduler_dependent [Raw_ivar] | |
| Scheduler_dependent [Raw_deferred] | |
| Sequencer [Std] | |
| Sequencer [Throttle] | 
A sequencer is a throttle that is:
 
 | 
| Std | |
| Stream [Tail] | |
| Stream [Std] | |
| Stream [Raw_tail] | |
T  | |
| T [Raw_scheduler] | |
| T [Raw_handler] | |
| 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] | |
| Test | |
| Throttle | 
Throttles for simultaneous computations.
 
 | 
| Throttle [Std] | |
| Timing_wheel [Import] | |
U  | |
| Unregister | |
W  | |
| Writer [Pipe] |