Index of values

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.

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

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 ?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 ~continue_on_error ~max_concurrent_jobs returns a throttle that will run up to max_concurrent_jobs concurrently.

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

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.

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

fail error = Deferred.return (Error error) *

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

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_alive t returns true iff none of t or its ancestors have been killed.

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

kill t causes t and all of t's descendants to never start another job.

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_concurrent_jobs t returns the maximum number of jobs that t will run concurrently.

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

num_jobs_running t returns the number of jobs that t is currently running.

num_jobs_waiting_to_start t returns the number of jobs that have been enqueued but have not yet started.

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.

These functions are direct analogs of the corresponding Core.Or_error functions.

ok_unit = return ()

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.

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.

run_at time f a runs f a as soon as possible after time.

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.

sexp_of_t t f returns a sexp of all of the elements currently available in the stream.

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.

try_with f catches exceptions thrown by f and returns them in the Result.t as an Error.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 would 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.