(>>=?) [Std] | |
(>>>) [Deferred.Infix] | |
(>>|?) [Std] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Std] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Raw_stream] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Raw_tail] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Raw_scheduler] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Raw_handler] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Import] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Raw_monitor] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Execution_context] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Deferred_std] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Deferred_intf] | |
A | |
abort [Clock.Event] | |
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_exn [Scheduler] | |
add_job [Scheduler] | |
add_job [Raw_scheduler] | |
add_job [Import.Basic_scheduler] | |
after [Std] | |
after [Clock.Event] | |
after [Clock] | |
alarm_precision [Config] | |
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_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_read_t_ [Ivar] | |
bin_read_t__ [Ivar] | |
bin_reader_t [Ivar] | |
bin_size_t [Ivar] | |
bin_t [Ivar] | |
bin_write_t [Ivar] | |
bin_write_t_ [Ivar] | |
bin_writer_t [Ivar] | |
bind [Raw_deferred.Scheduler_dependent] | |
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 | |
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 [Config] | |
choice [Deferred_std] | |
choice [Deferred] | |
choose [Deferred_std] | |
choose [Deferred] | choose choices is enabled choices >>| (fun f -> List.hd_exn (f ())) .
|
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 [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.Scheduler_dependent] | |
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.Sequencer] |
create a new monitor with the specified initial state
|
create [Throttle.Job] | |
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 [Raw_scheduler.T.Fields] | |
create [Raw_tail] | |
create [Raw_scheduler] | |
create [Raw_ivar.Scheduler_dependent] | |
create [Raw_ivar] | |
create [Raw_deferred.Scheduler_dependent] | |
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] | 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 [Raw_monitor.Fields_of_t_] | |
create [Deferred] | create f calls f i , where i is empty ivar.
|
create [Backpatched.Hole] | |
create [Backpatched] | |
create [Async_stream] | |
create [Async_condition] | |
create_full [Raw_ivar.Scheduler_dependent] | |
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 .
|
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] | |
current_execution_context [Import.Basic_scheduler] | |
cycle_count [Scheduler] | |
cycle_count [Raw_scheduler.T.Fields] | |
cycle_count [Raw_scheduler.T] | |
cycle_num_jobs [Scheduler] | |
cycle_num_jobs [Raw_scheduler.T.Fields] | |
cycle_num_jobs [Raw_scheduler.T] | |
cycle_start [Scheduler] | |
cycle_start [Raw_scheduler.T.Fields] | |
cycle_start [Raw_scheduler.T] | |
cycle_times [Scheduler] | |
cycle_times [Raw_scheduler.T.Fields] | |
cycle_times [Raw_scheduler.T] | |
D | |
dead [Kill_index] | |
debug [Raw_scheduler] | |
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 | |
empty [Backpatched.Hole] |
It is not an error to
empty an already-empty hole.
|
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.Sequencer] |
schedule a state-accessing operation
|
enqueue [Throttle] | |
enqueue' [Throttle] | enqueue t job schedules job to be run as soon as possible.
|
enqueue_job [Throttle] | |
environment_variable [Config] | |
epoll_max_ready_events [Config] | |
equal [Raw_ivar.Scheduler_dependent] | |
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_string [Async_or_error] | |
errors [Monitor] | errors t returns a stream of all subsequent errors that monitor t sees.
|
errors [Raw_monitor.Fields_of_t_] | |
errors [Raw_monitor] | |
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 [Execution_context.Fields] | |
exists [Raw_monitor.Fields_of_t_] | |
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.Scheduler_dependent] | |
fill [Ivar] | fill t v fills t with value v if t was empty.
|
fill [Backpatched.Hole] |
It is an error to
fill an already-filled hole.
|
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
|
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 [Pipe] | |
fold [Execution_context.Fields.Direct] | |
fold [Execution_context.Fields] | |
fold [Raw_monitor.Fields_of_t_.Direct] | |
fold [Raw_monitor.Fields_of_t_] | |
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] | |
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 [Execution_context.Fields] | |
for_all [Raw_monitor.Fields_of_t_] | |
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 | |
get_exn [Backpatched] |
It is an error to
get from a hole that has not been filled.
|
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 [Monitor] | has_seen_error t returns true iff the monitor has ever seen an error.
|
has_seen_error [Raw_monitor.Fields_of_t_] | |
has_seen_error [Raw_monitor] | |
hash [Pipe] | hash a hash function suitable for pipes
|
here [Raw_monitor.Fields_of_t_] | |
here [Raw_monitor] | |
I | |
id [Raw_monitor.Fields_of_t_] | |
id [Raw_monitor] | |
init [Pipe] | init f creates a new pipe, applies f to its writer end, and returns its reader
end.
|
init [Deferred_intf.Monad_sequence] | |
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.Scheduler_dependent] | |
install_removable_handler [Raw_deferred.Scheduler_dependent] | |
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] | |
invariant [Execution_context] | |
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_determined [Raw_deferred.Scheduler_dependent] | |
is_determined [Lazy_deferred] | |
is_determined [Deferred] | is_determined t returns true iff t is determined.
|
is_empty [Raw_ivar.Scheduler_dependent] | |
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.Scheduler_dependent] | |
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 [Pipe] | |
iter [Execution_context.Fields.Direct] | |
iter [Execution_context.Fields] | |
iter [Raw_monitor.Fields_of_t_.Direct] | |
iter [Raw_monitor.Fields_of_t_] | |
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 [Monitor] | kill t causes t and all of t 's descendants to never start another job.
|
kill_index [Execution_context.Fields] | |
kill_index [Raw_monitor.Fields_of_t_] | |
kill_index [Raw_monitor] | |
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
|
log [Debug] | |
log_string [Debug] | |
low [Priority] | |
low [Jobs.Priority] | |
M | |
main [Monitor] | |
main [Execution_context] | |
main_execution_context [Scheduler] | |
main_execution_context [Raw_scheduler.T.Fields] | |
main_execution_context [Raw_scheduler.T] | |
main_monitor_hole [Execution_context] | |
make_creator [Raw_scheduler.T.Fields] | |
make_creator [Execution_context.Fields] | |
make_creator [Raw_monitor.Fields_of_t_] | |
map [Raw_scheduler.T.Fields] | |
map [Pipe] | |
map [Execution_context.Fields] | |
map [Raw_monitor.Fields_of_t_] | |
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 [Execution_context.Fields] | |
map_poly [Raw_monitor.Fields_of_t_] | |
mapi [Deferred_intf.Deferred_map] | |
max_num_jobs_per_priority_per_cycle [Raw_scheduler.T.Fields] | |
max_num_jobs_per_priority_per_cycle [Raw_scheduler.T] | |
max_num_open_file_descrs [Config] | |
max_num_threads [Config] | |
merge [Deferred_intf.Deferred_map] | |
monitor [Execution_context.Fields] | |
monitor [Execution_context] | |
monitor [Config.Print_debug_messages_for] | |
monitor_is_alive [Raw_scheduler] | |
N | |
name [Monitor] | name t returns the name of the monitor, or a unique id if no name was supplied to
create .
|
name [Raw_monitor.Fields_of_t_] | |
name [Raw_monitor] | |
names [Raw_scheduler.T.Fields] | |
names [Execution_context.Fields] | |
names [Raw_monitor.Fields_of_t_] | |
never [Deferred_std] | |
never [Deferred] | never () returns a deferred that never becomes determined
|
next [Tail.Stream] | |
next [Kill_index] | |
next [Async_stream] | |
next_upcoming_event [Scheduler] | |
noop [Unregister] | |
normal [Priority] | |
normal [Jobs.Priority] | |
num_jobs_run [Scheduler] | |
num_jobs_run [Raw_scheduler.T.Fields] | |
num_jobs_run [Raw_scheduler.T] | |
num_jobs_waiting_to_start [Throttle.Sequencer] | |
num_jobs_waiting_to_start [Throttle] | |
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_hole [Backpatched] | |
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_raw [Import.Raw] | |
of_stream_deprecated [Pipe] | of_stream_deprecated reader return a pipe that has one element for every element on
the stream.
|
ok_exn [Import] | |
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_of_t_] | |
parent [Raw_monitor] | |
peek [Raw_ivar.Scheduler_dependent] | |
peek [Raw_ivar] | |
peek [Raw_deferred.Scheduler_dependent] | |
peek [Raw_deferred] | |
peek [Pipe] | |
peek [Lazy_deferred] | peek t = Deferred.peek (wait t)
|
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 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.
|
prior_jobs_done [Throttle.Sequencer] | |
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 [Config] | |
repeat_until_finished [Deferred] | repeat_until_finished initial_state f repeatedly runs f until f returns
`Finished .
|
reset_in_forked_process [Scheduler] | |
result [Throttle.Job] | |
return [Raw_deferred.Scheduler_dependent] | |
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_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_current_execution_context [Raw_scheduler.T] | |
set_cycle_count [Raw_scheduler.T] | |
set_cycle_start [Raw_scheduler.T] | |
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_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_pipe [Pipe] | |
sexp_of_t [Throttle] | |
sexp_of_t [Tail.Stream] | |
sexp_of_t [Tail] | |
sexp_of_t [Scheduler] | |
sexp_of_t [Raw_scheduler.T] | |
sexp_of_t [Raw_stream] | |
sexp_of_t [Raw_tail] | |
sexp_of_t [Raw_ivar.Scheduler_dependent] | |
sexp_of_t [Raw_ivar] | |
sexp_of_t [Raw_deferred.Scheduler_dependent] | |
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.Priority] | |
sexp_of_t [Jobs] | |
sexp_of_t [Job] | |
sexp_of_t [Ivar.Deferred] | |
sexp_of_t [Ivar] | |
sexp_of_t [Import.Basic_scheduler.Execution_context] | |
sexp_of_t [Raw_monitor.Pretty] | |
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 [Backpatched] | |
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] | |
sexp_of_t_ [Raw_monitor] | |
sexp_of_tail [Raw_scheduler] | |
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.
|
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_of_t_] | |
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 `FoundThe deferred d describes why the prefix ended, and returns the suffix of the
stream in case (2) or (3).
|
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 [Import.Basic_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_level_bits [Config] | |
to_list [Raw_scheduler.T.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 [Raw_monitor.Fields_of_t_] | |
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_raw [Import.Raw] | |
to_stream_deprecated [Pipe] | to_stream_deprecated reader returns a stream that reads everything from the pipe.
|
to_string [Jobs.Priority] | |
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_join [Async_or_error] | |
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.Scheduler_dependent] | |
upon [Raw_deferred.Scheduler_dependent] | |
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.Scheduler_dependent] | |
upon' [Raw_deferred.Scheduler_dependent] | |
upstream_flushed [Pipe] |
Deferreds returned by
upstream_flushed and downstream_flushed becomes 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_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] |