Index of values

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

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

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 ~stop span returns a stream whose elements will become determined span time apart.

at_varying_intervals ~stop f 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.

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

choose_ident l = choose (List.map l ~f:(fun t -> choice t ident)).

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

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 () returns a new tail.

create () creates a new pipe.

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

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 f returns a stream t and calls f tail, where the elements of the stream are determined as the tail is extended, and the end of the stream is reached when the tail is closed.

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.

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

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.

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

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

filter_map s ~f returns a stream with one element, v', for each v in s such with f v = Some v'.

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

flushed t becomes determined when all values written prior to the call to flushed have been removed from the pipe and handed to a reader, or if the reader end of the pipe is closed.

fold t ~init ~f is a variant of fold' in which f does not return a deferred.

fold' reader ~init ~f reads a batch of elements from reader, supplies them to f, waits for f to finish, and then repeats.

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

get t gets all the jobs with the highest priority currently available, subject to max_num_jobs_per_priority.

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

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 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 = whenever (iter' t ~f:(fun a -> f a; Deferred.unit))

iter' reader ~f repeatedly applies f to batches of elements of reader, waiting for each call to f to finish before continuing.

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

iter_durably_report_end t ~f is equivalent to iter_durably' t ~f:(fun x -> return (f x)) but it is more efficient

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.

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.

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 reader return a pipe that has one element for every element on the stream

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

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

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

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.

When RECORD_ASYNC_BACKTRACES is set, the Async scheduler records a backtrace everytime it schedules a job, and will include the backtrace history in any exceptions raised to monitors, and in particular, in an unhandled exception that reaches the main monitor.

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.

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.

start_cycle t ~max_num_jobs_per_priority enables subsequent calls of get to return 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 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 schedules f () to run 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_raise_rest f is the same as try_with f, except that subsequent errors raised by f () are reraised to the monitor that called try_with_raise_rest.

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

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.

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

whenever t ignores t completely.

with_timeout span d does pretty much what one can expect.

with_write 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' writer q transfers the elements from q into the pipe, leaving q empty.