Index of values


(>>=?) [Std]
(>>>) [Deferred.Infix]
(>>|?) [Std]
__bin_read_t__ [Ivar]
_squelch_unused_module_warning_ [Import]

A
abort [Clock.Event]
abort_after_thread_pool_stuck_for [Config]
Documentation on these is in strings in config.ml, so it can be output in the help message.
add [Jobs]
add_consumer [Pipe]
add_consumer reader ~downstream_flushed creates a new consumer of reader, and causes future calls to flushed_downstream reader to take this consumer into account.
add_finalizer [Scheduler]
add_finalizer [Async_gc]
add_finalizer b f ensures that f runs after b becomes unreachable.
add_finalizer_exn [Scheduler]
add_finalizer_exn [Async_gc]
add_job [Scheduler]
add_job [Raw_scheduler]
add_job2 [Scheduler]
after [Std]
after [Clock.Event]
after [Clock]
all [Deferred]
all ts returns a deferred that becomes determined when every t in ts is determined.
all [Deferred_intf.Monad_sequence]
all_unit [Deferred]
Like all, but ignores results of the component deferreds
all_unit [Deferred_intf.Monad_sequence]
any [Deferred]
any ts returns a deferred that is fulfilled when any of the underlying deferreds is fulfilled
any_unit [Deferred]
any_unit ts like any but ignores results of the component deferreds
append [Async_stream]
append t1 t2 returns a stream with all the values of t1, in order, and if t1 ends, these values are followed by all the values of t2.
at [Std]
at [Clock.Event]
at [Clock]
at time returns a deferred d that will become determined as soon as possible after time
at_intervals [Clock]
at_intervals interval ?start ?stop returns a stream whose elements will become determined at nonnegative integer multiples of interval after the start time, until stop becomes determined:
at_kill [Throttle]
at_kill t clean runs clean on each resource when t is killed, either by kill or an unhandled exception.
at_varying_intervals [Clock]
at_varying_intervals f ?stop returns a stream whose next element becomes determined by calling f () and waiting for that amount of time, and then looping to determine subsequent elements.
available_now [Async_stream]
available_now t returns t prefix of t that is available now, along with the rest of the stream.

B
backtrace_history [Execution_context.Fields]
backtrace_history [Execution_context]
bin_read_t [Ivar]
bin_reader_t [Ivar]
bin_size_t [Ivar]
bin_t [Ivar]
bin_write_t [Ivar]
bin_writer_t [Ivar]
bind [Raw_deferred]
bind [Ivar.Deferred]
bind' [Lazy_deferred]
bind' differs from bind in that the supplied function produces an 'a Deferred.t rather than an 'a t.
both [Deferred]
both t1 t2 becomes determined after both t1 and t2 become determined.
broadcast [Async_condition]

C
capacity_available [Throttle]
capacity_available t becomes determined the next time that t has fewer than max_concurrent_jobs t running, and hence an enqueued job would start immediately.
catch [Std]
catch [Monitor]
catch ?name f runs f () inside a new monitor m and returns the first error raised to m.
catch_stream [Monitor]
catch_stream ?name f runs f () inside a new monitor m and returns the stream of errors raised to m.
change [Deferred_intf.Deferred_map]
check_access [Scheduler]
check_access [Raw_scheduler.T.Fields]
check_access [Raw_scheduler.T]
check_access [Raw_scheduler]
check_invariant [Pipe]
check_invariant, if true, will cause pipes' invariants to be checked at the start of each operation.
check_invariants [Scheduler]
check_invariants [Raw_scheduler.T.Fields]
check_invariants [Raw_scheduler.T]
check_invariants [Config]
choice [Deferred_std]
choice [Deferred]
choose [Deferred_std]
choose [Deferred]
choose choices is enabled choices >>| (fun f -> List.hd_exn (f ())).
cleaned [Throttle]
cleaned t becomes determined after t is killed and all of its at_kill clean functions have completed.
clear [Pipe]
clear reader consumes all of the values currently in reader, and all blocked flushes become determined with `Ok.
clear [Jobs]
clear t removes all jobs from t.
clock [Config.Print_debug_messages_for]
close [Pipe]
close t closes the write end of the pipe:
close_exn [Tail]
close_exn t closes t.
close_if_open [Tail]
close_if_open t closes t, if it's not already closed.
close_read [Pipe]
closed [Pipe]
closed t returns a deferred that becomes determined when close t or close_read t is called.
closed [Async_stream]
closed t returns a deferred that becomes determined when the end of t is reached.
collect [Tail]
collect t returns the stream starting at the current position of the tail, i.e.
combine_errors [Async_or_error]
combine_errors_unit [Async_or_error]
concat [Pipe]
concat inputs return a reader, output, with the values from each pipe in inputs in sequence.
concat [Import]
concat [Async_stream]
concat t takes a stream of streams and produces a stream that is the concatenation of each stream in order (you see all of stream 1, then all of stream 2...
connect [Raw_ivar]
copy_to_tail [Async_stream]
copy_to_tail t tail reads elements from t and puts them in tail, until the end of t is reached.
create [Unregister]
create [Throttle]
create ~continue_on_error ~max_concurrent_jobs returns a throttle that will run up to max_concurrent_jobs concurrently.
create [Tail]
create () returns a new tail.
create [Throttle.Sequencer]
create [Raw_scheduler.T.Fields]
create [Raw_scheduler]
create [Raw_monitor.Fields]
create [Raw_ivar]
create [Raw_deferred]
create [Pipe]
create () creates a new pipe.
create [Monitor]
create () returns a new monitor whose parent is the current monitor.
create [Lazy_deferred]
create f creates a new lazy deferred that will call f when it is forced.
create [Jobs]
create [Job]
create [Ivar.Deferred]
create [Ivar]
create () returns an empty ivar.
create [Handler]
create k creates a handler by coupling the continuation k together with the evaluation context that is current at the time create is called.
create [Execution_context.Fields]
create [Deferred]
create f calls f i, where i is empty ivar.
create [Async_stream]
create [Async_condition]
create_full [Raw_ivar]
create_job [Raw_handler]
create_like [Execution_context]
create_with [Throttle]
create_with ~continue_on_error job_resources returns a throttle that will run up to List.length job_resources concurrently, and will ensure that all running jobs are supplied distinct elements of job_resources.
create_with_parent [Raw_monitor]
current [Monitor]
current () returns the current monitor
current_execution_context [Scheduler]
current_execution_context [Raw_scheduler.T.Fields]
current_execution_context [Raw_scheduler.T]
current_execution_context [Raw_scheduler]
cycle_count [Scheduler]
cycle_count [Raw_scheduler.T.Fields]
cycle_count [Raw_scheduler.T]
cycle_num_jobs [Scheduler]
cycle_start [Scheduler]
cycle_start [Raw_scheduler.T.Fields]
cycle_start [Raw_scheduler.T]
cycle_times [Scheduler]

D
dead [Kill_index]
debug [Raw_scheduler]
debug [Raw_monitor]
debug_space_leaks [Raw_ivar]
debug_space_leaks [Deferred]
Set debug_space_leaks to Some n to trigger assertion failures when single deferred has more than n handlers waiting for it to be filled.
detect_invalid_access_from_thread [Config]
do_nothing [Job]
don't_wait_for [Deferred_std]
don't_wait_for [Deferred]
don't_wait_for t ignores t completely.
downstream_flushed [Pipe]
drain [Pipe]
drain reader repeatedly reads values from reader and throws them away.
drain_and_count [Pipe]

E
enabled [Deferred]
enabled [choice t1 f1; ... choice tn fn;] returns a deferred d that becomes determined when any of the ti become determined.
enqueue [Throttle]
enqueue' [Throttle]
enqueue t job schedules job to be run as soon as possible.
environment_variable [Config]
epoll_max_ready_events [Config]
eprint [Import]
eprints [Import]
equal [Raw_ivar]
equal [Pipe]
equal on pipes is physical equality.
equal [Ivar]
equal t t' is physical equality of t and t'.
error [Monitor]
error t returns a deferred that becomes defined if the monitor ever sees an error.
error [Async_or_error]
error_handlers [Raw_monitor.Fields]
error_handlers [Raw_monitor]
error_string [Async_or_error]
errors [Monitor]
errors t returns a stream of all subsequent errors that monitor t sees.
events [Scheduler]
events [Raw_scheduler.T.Fields]
events [Raw_scheduler.T]
every [Std]
every [Clock]
every ?start ?stop span f is every' ?start ?stop span (fun () -> f (); Deferred.unit)
every' [Clock]
every' ?start ?stop span f runs f() every span amount of time starting when start becomes determined and stopping when stop becomes determined.
execution_context [Job]
execution_context_is_alive [Raw_scheduler]
exists [Raw_scheduler.T.Fields]
exists [Raw_monitor.Fields]
exists [Execution_context.Fields]
extend [Tail]
extend t v extends the stream, and will raise an exception if t has been closed.
extract_exn [Monitor]
extract_exn exn extracts the exn from an error exn that comes from a monitor.

F
fail [Async_or_error]
fail error = Deferred.return (Error error) *
fd [Config.Print_debug_messages_for]
file_descr_watcher [Config.Print_debug_messages_for]
file_descr_watcher [Config]
fill [Raw_ivar]
fill [Ivar]
fill t v fills t with value v if t was empty.
fill_if_empty [Ivar]
fill_if_empty t v fills t with v if t is currently empty.
filter [Raw_handler]
filter [Pipe]
filter input ~f returns a reader, output, and copies to output each element from input that satisfies the predicate f.
filter [Handler]
filter h ~f makes the eventual execution of the handler h on a value v dependent on whether predicate f holds of v
filter [Deferred_intf.Deferred_map]
filter [Deferred_intf.Monad_sequence]
filter_deprecated [Async_stream]
filter_deprecated s ~f returns a stream with one element, v, for each v in s such with f v = true.
filter_map [Pipe]
filter_map [Deferred_intf.Deferred_map]
filter_map [Deferred_intf.Monad_sequence]
filter_map' [Pipe]
filter_map' input ~f returns a reader, output, and repeatedly applies f to elements from input, with the results that aren't None appearing in output.
filter_map_deprecated [Async_stream]
filter_map_deprecated s ~f returns a stream with one element, v', for each v in s such with f v = Some v'.
filter_mapi [Deferred_intf.Deferred_map]
finalizer_jobs [Raw_scheduler.T.Fields]
finalizer_jobs [Raw_scheduler.T]
finalizers [Config.Print_debug_messages_for]
find [Async_stream]
find ~f t returns a deferred that becomes determined when f x is true for some element of t, or if the end of the stream is reached
find [Deferred_intf.Monad_sequence]
find_local [Scheduler]
find_local [Execution_context]
find_map [Deferred_intf.Monad_sequence]
first_exn [Async_stream]
first_exn t returns a deferred that becomes determined with the first element of t.
first_n [Async_stream]
first_n t n returns a stream with the first n elements of t, if t has n or more elements, or it returns t.
fold [Raw_scheduler.T.Fields.Direct]
fold [Raw_scheduler.T.Fields]
fold [Raw_monitor.Fields.Direct]
fold [Raw_monitor.Fields]
fold [Pipe]
fold [Execution_context.Fields.Direct]
fold [Execution_context.Fields]
fold [Deferred_intf.Deferred_map]
fold [Async_stream]
fold t ~init ~f is a variant of fold' in which f does not return a deferred.
fold [Deferred_intf.Monad_sequence]
fold' [Pipe]
fold' [Async_stream]
fold' t ~init ~f is like list fold, walking over the elements of the stream in order, as they become available.
fold_right [Deferred_intf.Deferred_map]
fold_without_pushback [Pipe]
foldi [Deferred_intf.Monad_sequence]
follow [Lazy_deferred]
follow t f returns a new lazy deferred almost like bind' with the notable difference that its computation will start as soon as the deferred it is following becomes determined.
for_all [Raw_scheduler.T.Fields]
for_all [Raw_monitor.Fields]
for_all [Execution_context.Fields]
force [Lazy_deferred]
force t forces evaluation of t and returns a deferred that becomes determined when the deferred computation becomes determined or raises.
force_current_cycle_to_end [Scheduler]
force_current_cycle_to_end [Jobs]
force_current_cycle_to_end sets the number of normal jobs allowed to run in this cycle to zero.
force_exn [Lazy_deferred]
forever [Deferred]
forever initial_state f repeatedly runs f, supplying the state returned to the next call to f.

G
global_kill_index [Raw_scheduler.T.Fields]
global_kill_index [Raw_scheduler.T]
got_uncaught_exn [Raw_scheduler]

H
handle_errors [Monitor]
handle_errors ?name f handler runs f () inside a new monitor with the optionally supplied name, and calls handler error on every error raised to that monitor.
has_seen_error [Raw_monitor.Fields]
has_seen_error [Raw_monitor]
has_seen_error [Monitor]
has_seen_error t returns true iff the monitor has ever seen an error.
hash [Pipe]
hash a hash function suitable for pipes
here [Raw_monitor.Fields]
here [Raw_monitor]

I
id [Raw_monitor.Fields]
id [Raw_monitor]
indir [Raw_ivar]
init [Pipe]
init f creates a new pipe, applies f to its writer end, and returns its reader end.
init [Deferred_intf.Monad_sequence]
default how is `Sequential
initial [Kill_index]
install [Handler]
install h d behaves like upon except that it also returns a uninstall function that, when called, uninstalls the handler
install_removable_handler [Raw_ivar]
install_removable_handler [Raw_deferred]
install_removable_handler [Ivar.Deferred]
interleave [Pipe]
interleave inputs returns a reader output, and, for each input, transfers batches of values from that input to output, using transfer_id.
interleave [Async_stream]
interleave list takes a stream of streams and returns a stream of their items interleaved as they become determined.
interruptor [Config.Print_debug_messages_for]
invariant [Raw_scheduler]
invariant [Pipe.Reader]
invariant [Pipe.Writer]
is_alive [Monitor]
is_alive t returns true iff none of t or its ancestors have been killed.
is_closed [Tail]
is_closed t returns true iff the stream t is closed.
is_closed [Pipe]
is_closed t returns true iff close t or close_read t has been called.
is_dead [Throttle]
is_dead t returns true if t was killed, either by kill or by an unhandled exception in a job.
is_dead [Raw_scheduler]
is_determined [Raw_deferred]
is_determined [Lazy_deferred]
is_determined [Ivar.Deferred]
is_determined [Deferred]
is_determined t returns true iff t is determined.
is_empty [Raw_ivar]
is_empty [Pipe]
is_empty t is true iff there are no values in the pipe.
is_empty [Jobs]
is_empty t returns true if there are no waiting jobs.
is_empty [Ivar]
is_empty t returns true if t is empty
is_forced [Lazy_deferred]
is_full [Raw_ivar]
is_full [Ivar]
is_full t returns true if t is full
iter [Raw_scheduler.T.Fields.Direct]
iter [Raw_scheduler.T.Fields]
iter [Raw_monitor.Fields.Direct]
iter [Raw_monitor.Fields]
iter [Pipe]
iter [Execution_context.Fields.Direct]
iter [Execution_context.Fields]
iter [Deferred_intf.Deferred_map]
iter [Async_stream]
iter t ~f = don't_wait_for (iter' t ~f:(fun a -> f a; Deferred.unit))
iter [Deferred_intf.Monad_sequence]
iter' [Pipe]
iter' [Async_stream]
iter' t ~f applies f to each element of the stream in turn, as they become available.
iter_durably [Async_stream]
iter_durably' [Async_stream]
iter_durably' t ~f is like iter' t ~f, except if f raises an exception it continues with the next element of the stream *and* reraises the exception (to the monitor in scope when iter_durably was called).
iter_durably_report_end [Async_stream]
iter_without_pushback [Pipe]
iteri [Deferred_intf.Monad_sequence]

J
jobs [Raw_scheduler.T.Fields]
jobs [Raw_scheduler.T]

K
kill [Throttle]
kill t kills t, which aborts all enqeued jobs that haven't started and all jobs enqueued in the future.
kill [Monitor]
kill t causes t and all of t's descendants to never start another job.
kill_index [Raw_monitor.Fields]
kill_index [Raw_monitor]
kill_index [Execution_context.Fields]
kill_index [Execution_context]
kill_monitor [Raw_scheduler]

L
last_cycle_num_jobs [Raw_scheduler.T.Fields]
last_cycle_num_jobs [Raw_scheduler.T]
last_cycle_time [Raw_scheduler.T.Fields]
last_cycle_time [Raw_scheduler.T]
length [Pipe]
length t returns the number of elements currently queued in t
length [Jobs]
length t returns the number of waiting jobs
length [Async_stream]
length s returns a deferred that is determined when the end of s is reached, taking the value of the number of elements in s
local_storage [Execution_context.Fields]
local_storage [Execution_context]
log [Debug]
log_string [Debug]
low [Priority]

M
main [Raw_monitor]
main [Monitor]
main [Execution_context]
main_execution_context [Scheduler]
main_execution_context [Raw_scheduler.T.Fields]
main_execution_context [Raw_scheduler.T]
make_creator [Raw_scheduler.T.Fields]
make_creator [Raw_monitor.Fields]
make_creator [Execution_context.Fields]
map [Raw_scheduler.T.Fields]
map [Raw_monitor.Fields]
map [Pipe]
map [Execution_context.Fields]
map [Deferred_intf.Deferred_map]
map [Async_stream]
map t ~f creates a new stream that with one element, (f v), for each element v of t.
map [Deferred_intf.Monad_sequence]
map' [Pipe]
map' input ~f returns a reader, output, and repeatedly applies f to batches of elements from input, with the results appearing in output.
map' [Async_stream]
map' t f creates a new stream that with one element, (f v), for each element v of t.
map_poly [Raw_scheduler.T.Fields]
map_poly [Raw_monitor.Fields]
map_poly [Execution_context.Fields]
mapi [Deferred_intf.Deferred_map]
max_concurrent_jobs [Throttle]
max_concurrent_jobs t returns the maximum number of jobs that t will run concurrently.
max_inter_cycle_timeout [Config]
max_num_jobs_per_priority_per_cycle [Raw_scheduler.T.Fields]
max_num_jobs_per_priority_per_cycle [Raw_scheduler.T]
max_num_jobs_per_priority_per_cycle [Config]
max_num_open_file_descrs [Config]
max_num_threads [Config]
merge [Pipe]
merge inputs ~cmp returns a reader, output, that merges all the inputs.
merge [Deferred_intf.Deferred_map]
monitor [Execution_context.Fields]
monitor [Execution_context]
monitor [Config.Print_debug_messages_for]
monitor_is_alive [Raw_scheduler]
monitor_send_exn [Config.Print_debug_messages_for]

N
name [Raw_monitor.Fields]
name [Raw_monitor]
name [Monitor]
name t returns the name of the monitor, or a unique id if no name was supplied to create.
names [Raw_scheduler.T.Fields]
names [Raw_monitor.Fields]
names [Execution_context.Fields]
never [Deferred_std]
never [Deferred]
never () returns a deferred that never becomes determined
next [Tail.Stream]
next [Kill_index]
next [Async_stream]
next_id [Raw_monitor]
next_upcoming_event [Scheduler]
noop [Unregister]
normal [Priority]
num_jobs_run [Scheduler]
num_jobs_run [Raw_scheduler.T.Fields]
num_jobs_run [Raw_scheduler.T]
num_jobs_running [Throttle]
num_jobs_running t returns the number of jobs that t is currently running.
num_jobs_waiting_to_start [Throttle]
num_jobs_waiting_to_start t returns the number of jobs that have been enqueued but have not yet started.
num_pending_jobs [Scheduler]

O
of_exn [Async_or_error]
of_exn_result [Async_or_error]
of_fun [Async_stream]
of_fun f returns a stream whose elements are determined by calling f forever.
of_ivar [Raw_deferred]
of_list [Pipe]
of_list l returns a closed pipe reader filled with the contents of l.
of_list [Async_stream]
of_list l returns a stream with the elements of list l.
of_stream_deprecated [Pipe]
of_stream_deprecated reader return a pipe that has one element for every element on the stream.
ok_exn [Async_or_error]
These functions are direct analogs of the corresponding Core.Or_error functions.
ok_unit [Async_or_error]
ok_unit = return ()

P
parallel [Config.Print_debug_messages_for]
parent [Raw_monitor.Fields]
parent [Raw_monitor]
peek [Raw_ivar]
peek [Raw_deferred]
peek [Pipe]
peek [Lazy_deferred]
peek t = Deferred.peek (wait t)
peek [Ivar.Deferred]
peek [Deferred]
peek t returns Some v iff t is determined with value t.
peek_exn [Lazy_deferred]
prepend [Raw_handler]
prepend [Handler]
prepend h ~f pre-composes the handler with the function f
preserve_execution_context [Scheduler]
preserve_execution_context [Monitor.Exported_for_scheduler]
preserve_execution_context' [Scheduler]
preserve_execution_context' [Monitor.Exported_for_scheduler]
prior_jobs_done [Throttle]
prior_jobs_done t becomes determined when all of the jobs that were previously enqueued in t have completed.
priority [Execution_context.Fields]
priority [Execution_context]
protect [Monitor]
protect f ~finally runs f () and then finally regardless of the success or failure of f.
pushback [Pipe]
pushback writer becomes determined when either writer has been closed or the pipe is empty.

R
read [Pipe]
read pipe reads a single value from the pipe.
read [Ivar]
read t returns a deferred that becomes enabled with value v after the ivar is filled with v.
read' [Pipe]
read' pipe reads all of the values available in the pipe, as soon as any value becomes available.
read_all [Pipe]
read_all reader reads all the values from the pipe until it is closed.
read_at_most [Pipe]
read_at_most r ~num_values reads up to num_values values from the pipe's currently available data, blocking if the pipe is empty.
read_exactly [Pipe]
read_exactly r ~num_values reads exactly num_values items, unless EOF is encountered.
read_now [Pipe]
read_now' [Pipe]
read_now' reader reads all of the values from reader that are immediately available.
reader [Config.Print_debug_messages_for]
record_backtrace [Execution_context]
record_backtraces [Raw_scheduler.T.Fields]
record_backtraces [Raw_scheduler.T]
record_backtraces [Config]
repeat_until_finished [Deferred]
repeat_until_finished initial_state f repeatedly runs f until f returns `Finished.
report_thread_pool_stuck_for [Config]
reset_in_forked_process [Scheduler]
return [Raw_deferred]
return [Ivar.Deferred]
return [Deferred_std]
run [Job]
run_after [Clock]
run_all [Jobs]
run_all t f removes jobs from t one at a time and applies f to them, stopping as soon as an unhandled exception is raised, or when no more jobs can be run at any priority, as per ~max_num_jobs_per_priority.
run_at [Clock]
run_at time f a runs f a as soon as possible after time.
run_cycle [Scheduler]
run_cycles_until_no_jobs_remain [Scheduler]
run_every_cycle_start [Raw_scheduler.T.Fields]
run_every_cycle_start [Raw_scheduler.T]
run_job [Config.Print_debug_messages_for]

S
schedule [Std]
schedule [Scheduler]
schedule [Monitor.Exported_for_scheduler]
schedule [Handler]
schedule h v schedules the handler h to run at some point in the future by being called on value v
schedule' [Std]
schedule' [Scheduler]
schedule' [Monitor.Exported_for_scheduler]
scheduler [Config.Print_debug_messages_for]
send_exn [Monitor]
send_exn t exn ?backtrace sends the exception exn as an error to be handled monitor t.
set_check_access [Scheduler]
set_check_access [Raw_scheduler.T]
set_check_access [Raw_scheduler]
set_check_invariants [Scheduler]
set_check_invariants [Raw_scheduler.T]
set_current_execution_context [Raw_scheduler.T]
set_cycle_count [Raw_scheduler.T]
set_cycle_start [Raw_scheduler.T]
set_error_handlers [Raw_monitor]
set_execution_context [Scheduler]
set_execution_context [Raw_scheduler]
set_global_kill_index [Raw_scheduler.T]
set_has_seen_error [Raw_monitor]
set_kill_index [Raw_monitor]
set_kill_index [Execution_context]
set_last_cycle_num_jobs [Raw_scheduler.T]
set_last_cycle_time [Raw_scheduler.T]
set_main_execution_context [Raw_scheduler.T]
set_max_num_jobs_per_priority_per_cycle [Scheduler]
set_max_num_jobs_per_priority_per_cycle [Raw_scheduler.T]
set_num_jobs_run [Raw_scheduler.T]
set_record_backtraces [Scheduler]
set_record_backtraces [Raw_scheduler.T]
set_run_every_cycle_start [Raw_scheduler.T]
set_size_budget [Pipe]
set_size_budget t i changes the size budget of t to i.
set_someone_is_listening [Raw_monitor]
set_thread_safe_finalizer_hook [Scheduler]
set_thread_safe_finalizer_hook [Raw_scheduler.T]
set_uncaught_exn [Raw_scheduler.T]
sexp_of_how [Deferred_intf]
sexp_of_one [Raw_monitor.Pretty]
sexp_of_outcome [Throttle]
sexp_of_pipe [Pipe]
sexp_of_t [Throttle.T2]
sexp_of_t [Throttle]
sexp_of_t [Tail.Stream]
sexp_of_t [Tail]
sexp_of_t [Throttle.Sequencer]
sexp_of_t [Scheduler]
sexp_of_t [Raw_scheduler.T]
sexp_of_t [Raw_monitor.Pretty]
sexp_of_t [Raw_monitor]
sexp_of_t [Raw_ivar]
sexp_of_t [Raw_deferred]
sexp_of_t [Priority]
sexp_of_t [Pipe.Flushed_result]
sexp_of_t [Pipe.Reader]
sexp_of_t [Pipe.Writer]
sexp_of_t [Pipe]
sexp_of_t [Monitor]
sexp_of_t [Kill_index]
sexp_of_t [Jobs]
sexp_of_t [Job]
sexp_of_t [Ivar.Deferred]
sexp_of_t [Ivar]
sexp_of_t [Execution_context]
sexp_of_t [Deferred]
sexp_of_t [Config.File_descr_watcher]
sexp_of_t [Config]
sexp_of_t [Clock.Event]
sexp_of_t [Async_stream]
sexp_of_t t f returns a sexp of all of the elements currently available in the stream.
sexp_of_t [Async_condition]
show_debug_messages [Pipe]
show_debug_messages, if true will cause a message to be printed at the start of each operation, showing the pipe and other arguments.
shutdown [Config.Print_debug_messages_for]
signal [Async_condition]
size_budget [Pipe]
Every pipe has a "size budget", which governs the pushback that is used to discourage writers from enqueueing arbitrarily large amounts of data.
someone_is_listening [Raw_monitor.Fields]
someone_is_listening [Raw_monitor]
split [Async_stream]
split ~stop ~f t returns a pair (p, d), where p is a prefix of t that ends for one of three reasons:
      1. [t] ends
      2. stop becomes determined
      3. f returns `Found
   
The deferred d describes why the prefix ended, and returns the suffix of the stream in case (2) or (3).
stabilize [Raw_scheduler]
start_cycle [Jobs]
start_cycle t ~max_num_jobs_per_priority enables subsequent calls of run_all to run up to max_num_jobs_per_priority jobs of each priority level.
status [Clock.Event]

T
t [Scheduler]
t [Raw_scheduler]
t [Config]
t_ref [Raw_scheduler]
take_until [Async_stream]
take_until t d returns a stream t' that has the same elements as t up until d becomes determined.
thread_pool [Config.Print_debug_messages_for]
thread_safe [Config.Print_debug_messages_for]
thread_safe_finalizer_hook [Raw_scheduler.T.Fields]
thread_safe_finalizer_hook [Raw_scheduler.T]
timing_wheel_config [Config]
to_list [Raw_scheduler.T.Fields]
to_list [Raw_monitor.Fields]
to_list [Pipe]
to_list input reads everything from input; on EOF, it produces the accumulated list of these values.
to_list [Execution_context.Fields]
to_list [Async_stream]
to_list t returns a deferred that will become determined with the list of elements in t, if the end of t is reached.
to_pretty [Raw_monitor]
to_stream_deprecated [Pipe]
to_stream_deprecated reader returns a stream that reads everything from the pipe.
transfer [Pipe]
transfer' [Pipe]
transfer' input output ~f ?stop repeatedly reads a batch of elements from input, applies f to the batch, writes the result as a batch to output, and then waits on pushback in output before continuing.
transfer_id [Pipe]
try_with [Std]
try_with [Monitor]
try_with f runs f () in a monitor and returns the result as Ok x if f finishes normally, or returns Error e if there is some error.
try_with [Async_or_error]
try_with f catches exceptions thrown by f and returns them in the Result.t as an Error.t.
try_with_ignored_exn_handling [Monitor]
try_with_ignored_exn_handling describes what should happen when try_with's rest value is `Ignore, as determined by !try_with_rest_handling and the ~rest supplied to try_with.
try_with_join [Async_or_error]
try_with_rest_handling [Monitor]
try_with_rest_handling determines how try_with f ~rest determines the rest value it actually uses.

U
uncaught_exn [Scheduler]
uncaught_exn [Raw_scheduler.T.Fields]
uncaught_exn [Raw_scheduler.T]
unfold [Async_stream]
unfold b f returns a stream a1; a2; ...; an whose elements are determined by the equations:
      b0 = b
      Some (a1, b1) = f b0
      Some (a2, b2) = f b1
      ...
      None = f bn
   
ungroup [Async_stream]
ungroup t takes a stream of lists and unpacks the items from each list into a single stream
unimplemented [Async_or_error]
unit [Deferred]
unit is a deferred that is always determined with value ()
unregister [Unregister]
update_kill_index [Raw_monitor]
upon [Raw_ivar]
upon [Raw_deferred]
upon [Ivar.Deferred]
upon [Deferred_std]
upon [Deferred]
upon t f will run f v at some point after t becomes determined with value v.
upon' [Raw_ivar]
upon' [Raw_deferred]
upon' [Ivar.Deferred]
upstream_flushed [Pipe]
Deferreds returned by upstream_flushed and downstream_flushed become determined when all values written prior to the call have been consumed, or if the reader end of the pipe is closed.

V
values_available [Pipe]
values_available reader returns a deferred that becomes determined when there are values in the pipe.
values_sent_downstream [Pipe.Consumer]

W
wait [Lazy_deferred]
wait t waits for t to be forced.
wait [Async_condition]
wait_exn [Lazy_deferred]
with_execution_context [Scheduler]
with_execution_context [Raw_scheduler]
with_local [Scheduler]
with_local [Execution_context]
with_timeout [Std]
with_timeout [Clock]
with_timeout span d does pretty much what one would expect.
within [Std]
within [Scheduler]
within [Monitor.Exported_for_scheduler]
within' [Std]
within' [Scheduler]
within' [Monitor.Exported_for_scheduler]
within_context [Scheduler]
within_context [Monitor.Exported_for_scheduler]
within_v [Scheduler]
within_v [Monitor.Exported_for_scheduler]
write [Pipe]
write' [Pipe]
write' writer q transfers the elements from q into the pipe, leaving q empty.
write_when_ready [Pipe]
write_when_ready writer ~f waits until there is space available in the pipe, and then calls f write, where write can be used by f to write a single value into the pipe at a time.
write_without_pushback [Pipe]
write_without_pushback' [Pipe]
write_without_pushback' and write_without_pushback are alternatives to write' and write that can be used when you don't care about the resultant deferred.
writer [Config.Print_debug_messages_for]