Index of values

add t ~at value adds a new event e to t with the specified value, and returns `Ok e.

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_work_for_group ?priority ?name t work_group f enqueues f to be done by some thread in the pool, subject to the thread-usage limits of work_group.

add_work_for_helper_thread ?priority ?name t helper_thread f enqueues f on helper_thread's work queue.

advance_clock t ~to_ advances the clock to to_, and returns `Ok values, with values for all events in t with at <= to_.

after span returns a deferred d that will become determined after the span of time passes.

all ts returns a deferred that becomes determined when every t in ts is determined.

Like all, but ignores results of the component deferreds

any ts returns a deferred that is fulfilled when any of the underlying deferreds is fulfilled

any_unit ts like any but ignores results of the component deferreds

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 time returns a deferred d that will become determined as soon as possible after the specified time.

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 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 t returns t prefix of t that is available now, along with the rest of the stream.

bind' differs from bind in that the supplied function produces an 'a Deferred.t rather than an 'a t.

both t1 t2 becomes determined after both t1 and t2 become determined.

catch ?name f runs f () inside a new monitor m and returns the first error raised to m.

catch_stream ?name f runs f () inside a new monitor m and returns the stream of errors raised to m.

check_invariant, if true, will cause pipes' invariants to be checked at the start of each operation.

choose choices is enabled choices >>| (fun f -> List.hd_exn (f ())).

clear reader consumes all of the values currently in reader, and all blocked flushes become determined with `Ok.

clear t removes all jobs from t.

close t closes the write end of the pipe:

close_exn t closes t.

close_if_open t closes t, if it's not already closed.

closed t returns a deferred that becomes determined when close t or close_read t is called.

closed t returns a deferred that becomes determined when the end of t is reached.

collect t returns the stream starting at the current position of the tail, i.e.

concat inputs return a reader, output, with the values from each pipe in inputs in sequence.

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...

copy_to_tail t tail reads elements from t and puts them in tail, until the end of t is reached.

create a new monitor with the specified initial state

create ~continue_on_error ~max_concurrent_jobs returns a throttle that will runs up to max_concurrent_jobs concurrently.

create ~max_num_threads returns a new thread pool.

create () returns a new tail.

create () creates a new pipe.

create () returns a new monitor whose parent is the current monitor.

create f creates a new lazy deferred that will call f when it is forced.

create () returns an empty ivar.

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 f calls f i, where i is empty ivar.

create_helper_thread ?priority ?name t work_group creates a new helper thread that is part of work_group, i.e.

create_work_group t ~min_assignable_threads ~max_assigned_threads creates a new work group.

current () returns the current monitor

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.

default_name t returns the name that will be used for work performed by t, unless that work is added with an overriding name

default_priority t returns the priority that will be used for work performed by t, unless that work is added with an overriding priority.

default_priority t returns the priority that will be used for work performed by t, unless that work is added with an overriding priority.

don't_wait_for t ignores t completely.

drain reader repeatedly reads values from reader and throws them away.

It is not an error to empty an already-empty hole.

enabled [choice t1 f1; ... choice tn fn;] returns a deferred d that becomes determined when any of the ti become determined.

schedule a state-accessing operation

enqueue t ~monitor job schedules job to be run as soon as possible.

equal on pipes is physical equality.

equal t t' is physical equality of t and t'.

error t returns a deferred that becomes defined if the monitor ever sees an error.

errors t returns a stream of all subsequent errors that monitor t sees.

every ?start ?stop span f is every' ?start ?stop span (fun () -> f (); Deferred.unit)

every' ?start ?stop span f runs f() every span amount of time starting when start becomes determined and stopping when stop becomes determined.

extend t v extends the stream, and will raise an exception if t has been closed.

extract_exn exn extracts the exn from an error exn that comes from a monitor.

fill t v fills t with value v if t was empty.

It is an error to fill an already-filled hole.

fill_if_empty t v fills t with v if t is currently empty.

filter input ~f returns a reader, output, and copies to output each element from input that satisfies the predicate f.

filter h ~f makes the eventual execution of the handler h on a value v dependent on whether predicate f holds of v

filter_deprecated s ~f returns a stream with one element, v, for each v in s such with f v = true.

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 s ~f returns a stream with one element, v', for each v in s such with f v = Some v'.

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

finished_with t destroys all the threads in t, and makes t no longer usable.

finished_with_helper_thread t helper_thread returns the helper thread to the general thread pool.

finished_with_work_group t work_group informs thread pool t that the work_group will no longer be used.

first_exn t returns a deferred that becomes determined with the first element of t.

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 t ~init ~f is a variant of fold' in which f does not return a deferred.

fold' t ~init ~f is like list fold, walking over the elements of the stream in order, as they become available.

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.

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 sets the number of normal jobs allowed to run in this cycle to zero.

forever initial_state f repeatedly runs f, supplying the state returned to the next call to f.

It is an error to get from a hole that has not been filled.

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 t returns true iff the monitor has ever seen an error.

hash a hash function suitable for pipes

init f creates a new pipe, applies f to its writer end, and returns its reader end.

install h d behaves like upon except that it also returns a uninstall function that, when called, uninstalls the handler

interleave inputs returns a reader output, and, for each input, transfers batches of values from that input to output, using transfer_id.

interleave list takes a stream of streams and returns a stream of their items interleaved as they become determined.

is_closed t returns true iff the stream t is closed.

is_closed t returns true iff close t or close_read t has been called.

is_determined t returns true iff t is determined.

is_empty t is true iff there are no values in the pipe.

is_empty t returns true if there are no waiting jobs.

is_empty t returns true if t is empty

is_full t returns true if t is full

iter t ~f = don't_wait_for (iter' t ~f:(fun a -> f a; Deferred.unit))

iter' t ~f applies f to each element of the stream in turn, as they become available.

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).

length t returns the number of elements currently queued in t

length t returns the number of waiting jobs

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

map t ~f creates a new stream that with one element, (f v), for each element v of t.

map' input ~f returns a reader, output, and repeatedly applies f to batches of elements from input, with the results appearing in output.

map' t f creates a new stream that with one element, (f v), for each element v of t.

max_num_threads t returns the maximum number of threads that t is allowed to create.

name t returns the name of the monitor, or a unique id if no name was supplied to create.

never () returns a deferred that never becomes determined

next_upcoming t returns the next upcoming event in t, if any.

num_threads t returns the number of threads that the pool t has created.

of_fun f returns a stream whose elements are determined by calling f forever.

of_list l returns a closed pipe reader filled with the contents of l.

of_list l returns a stream with the elements of list l.

of_stream_deprecated reader return a pipe that has one element for every element on the stream.

peek t = Deferred.peek (wait t)

peek t returns Some v iff t is determined with value t.

prepend h ~f pre-composes the handler with the function f

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 t becomes determined when all of the jobs that were previously enqueued in t have completed.

protect f ~finally runs f () and then finally regardless of the success or failure of f.

pushback writer becomes determined when either writer has been closed or the pipe is empty.

read pipe reads a single value from the pipe.

read t returns a deferred that becomes enabled with value v after the ivar is filled with v.

read' pipe reads all of the values available in the pipe, as soon as any value becomes available.

read_all reader reads all the values from the pipe until it is closed.

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 r ~num_values reads exactly num_values items, unless EOF is encountered.

read_now reader reads all of the values from reader that are immediately available.

remove t event removes event from t and returns `Removed, if event is present in t, else it returns `Not_present.

repeat_until_finished initial_state f repeatedly runs f until f returns `Finished.

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.

schedule h v schedules the handler h to run at some point in the future by being called on value v

send_exn t exn ?backtrace sends the exception exn as an error to be handled monitor t.

set_size_budget t i changes the size budget of t to i.

show_debug_messages, if true will cause a message to be printed at the start of each operation, showing the pipe and other arguments.

Every pipe has a "size budget", which governs the pushback that is used to discourage writers from enqueueing arbitrarily large amounts of data.

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).

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.

take_until t d returns a stream t' that has the same elements as t up until d becomes determined.

to_list input reads everything from input; on EOF, it produces the accumulated list of these values.

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_stream_deprecated reader returns a stream that reads everything from the 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.

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.

This interface is more generic than unit -> 'a Deferred.t.

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 t takes a stream of lists and unpacks the items from each list into a single stream

unit is a deferred that is always determined with value ()

upon t f will run f v at some point after t becomes determined with value v.

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.

values_available reader returns a deferred that becomes determined when there are values in the pipe.

wait t waits for t to be forced.

with_timeout span d does pretty much what one can expect.

write' writer q transfers the elements from q into the pipe, leaving q empty.

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' and write_without_pushback are alternatives to write' and write that can be used when you don't care about the resultant deferred.