Index of types

C
choice [Deferred]	`choice` is used to produce an argument to `enabled` or `choose`.
D
deferred [Raw_deferred]
E
execution_context [Import.Raw]
F
fold [Pipe]	`fold' reader ~init ~f` reads a batch of elements from `reader`, supplies them to `f`, waits for `f` to finish, and then repeats.
H
how [Deferred_intf]
I
iter [Pipe]	`iter' reader ~f` repeatedly applies `f` to batches of elements of `reader`, waiting for each call to `f` to finish before continuing.
ivar [Raw_ivar]
M
monad [Deferred_intf.Monad_sequence]
N
next [Tail.Stream]
next [Raw_stream]
next [Async_stream]
next_ [Tail.Stream]
next_ [Async_stream]	`next t` returns a deferred that will become determined when the next part of the stream is determined.
O
one [Raw_monitor.Pretty]
outcome [Throttle]
P
phantom [Pipe.Reader]
phantom [Pipe.Writer]
pipe [Pipe]
R
raw [Import.Raw]
T
t [Unregister]
t [Throttle.Sequencer]
t [Throttle.Job]
t [Throttle]
t [Thread_pool.Helper_thread]	A helper thread is a thread with its own dedicated work queue.
t [Thread_pool.Work_group]	Each piece of work in the thread pool is associated with a "work group", which is used to control the number of threads used for work in the group.
t [Thread_pool]
t [Tail.Stream]
t [Tail]
t [Scheduler]
t [Raw_scheduler.T]
t [Raw_stream]
t [Raw_tail]
t [Raw_ivar.Scheduler_dependent]
t [Raw_ivar.Handler]
t [Raw_ivar]
t [Raw_handler.T]
t [Raw_deferred.Scheduler_dependent]
t [Raw_deferred]
t [Priority]
t [Pipe.Consumer]	A `Consumer` is used to augment our notion of flushing (`Pipe.flushed`) to include the time spent processing an element once it has been removed from the pipe.
t [Pipe.Flushed_result]
t [Pipe.Reader]
t [Pipe.Writer]
t [Pipe]
t [Monitor]
t [Lazy_deferred]
t [Jobs.Priority]
t [Jobs]
t [Job]
t [Ivar.Deferred]
t [Ivar]
t [Import.Raw]
t [Import.Basic_scheduler.Execution_context]
t [Import.Basic_scheduler]
t [Handler]
t [Raw_monitor.Pretty]
t [Execution_context]
t [Events.Event]
t [Events]
t [Deferred_intf.Deferred]
t [Deferred_intf.Deferred_map]
t [Deferred]	A deferred is a value that will become determined asynchronously.
t [Config.File_descr_watcher]
t [Config]
t [Clock.Event]
t [Backpatched.Hole]
t [Backpatched]
t [Async_stream]	`sexp_of_t t f` returns a sexp of all of the elements currently available in the stream.
t [Deferred_intf.Monad_sequence]
t [Async_or_error]
t [Async_condition]
t_ [Raw_monitor]
tail [Raw_scheduler]
W
with_optional_monitor_name [Monitor]
with_options [Scheduler]
with_options [Monitor.Exported_for_scheduler]