Module Async_kernel

module Async_kernel_config = Async_kernel__.Config
module Bvar : sig ... end

A Bvar is a synchronization point that allows one to broadcast a value to clients waiting on the broadcast. With a Bvar, one can efficiently notify multiple clients of edge-triggered conditions, repeating as each edge trigger occurs.

module Clock_intf : sig ... end

Schedule jobs to run at a time in the future.

module Clock_ns : sig ... end
module Condition = Async_kernel__.Async_condition
module Deferred : sig ... end

A value that will become determined asynchronously.

module Eager_deferred : sig ... end

Eager_deferred partially implements the Deferred interface, with a type 'a t equal to 'a Deferred.t, but where the operations are "eager", that is built upon a world where bind, map, and upon eagerly apply their closure without preemption in the case the deferred they are working with is already determined.

module Execution_context : sig ... end

The context in which an Async job runs.

module Gc = Async_kernel__.Async_gc
module Handler : sig ... end

A continuation that captures the current Async execution context.

module Invariant = Async_kernel__.Async_invariant
module Ivar : sig ... end

A write-once cell that can be empty or full (i.e. hold a single value).

module Quickcheck = Async_kernel__.Async_quickcheck
module Lazy_deferred : sig ... end

A delayed computation that can produce a deferred.

module Limiter = Limiter_in_this_directory
module Monad_sequence : sig ... end
module Monitor : sig ... end

The part of the Execution_context that determines what to do when there is an unhandled exception.

module Mvar : sig ... end

An Mvar is a mutable location that is either empty or contains a value. One can put or set the value, and wait on value_available for the location to be filled in either way.

module Pipe : sig ... end

A buffered FIFO communication channel.

module Priority : sig ... end

The priority of a job.

module Sequencer = Throttle.Sequencer
module Stream = Async_kernel__.Async_stream
module Synchronous_time_source : sig ... end

A synchronous version of Async_kernel.Time_source. advance_by_alarms runs alarms immediately, rather than enqueueing Async jobs.

module Tail : sig ... end

A pointer to the end of an Async_stream that can be used to extend the stream.

module Throttle : sig ... end

A way to limit the number of concurrent computations.

module Time_source : sig ... end
module Use_eager_deferred : sig ... end

Intended usage is to open Use_eager_deferred to shadow operations from the non-eager world and rebind them to their eager counterparts.

Toplevel functions

The functions below are broadly useful when writing Async programs, and so are made available at the toplevel.

val after : Async_kernel__.Import.Time_ns.Span.t ‑> unit Clock_intf.Deferred.t
val at : Async_kernel__.Import.Time_ns.t ‑> unit Clock_intf.Deferred.t
val catch : ((unit ‑> unit) ‑> exn Monitor.Deferred.t) Monitor.with_optional_monitor_name
val choice : 'a Deferred.t ‑> ('a ‑> 'b) ‑> 'b Deferred.Choice.t
val choose : 'a Deferred.Choice.t list ‑> 'a Deferred.t
val don't_wait_for : unit Deferred.t ‑> unit
val every : ?⁠start:unit Clock_intf.Deferred.t ‑> ?⁠stop:unit Clock_intf.Deferred.t ‑> ?⁠continue_on_error:bool ‑> Async_kernel__.Import.Time_ns.Span.t ‑> (unit ‑> unit) ‑> unit
val never : unit ‑> 'a Deferred.t
val schedule : ((unit ‑> unit) ‑> unit) Async_kernel__.Scheduler.with_options
val schedule' : ((unit ‑> 'a Async_kernel__.Scheduler.Deferred.t) ‑> 'a Async_kernel__.Scheduler.Deferred.t) Async_kernel__.Scheduler.with_options
val try_with : (?⁠extract_exn:bool ‑> ?⁠run:[ `Now | `Schedule ] ‑> ?⁠rest:[ `Call of exn ‑> unit | `Log | `Raise ] ‑> (unit ‑> 'a Monitor.Deferred.t) ‑> ('a, exn) Core_kernel.Result.t Monitor.Deferred.t) Monitor.with_optional_monitor_name
val upon : 'a Deferred.t ‑> ('a ‑> unit) ‑> unit
val with_timeout : Async_kernel__.Import.Time_ns.Span.t ‑> 'a Clock_intf.Deferred.t ‑> [ `Result of 'a | `Timeout ] Clock_intf.Deferred.t
val within : ((unit ‑> unit) ‑> unit) Async_kernel__.Scheduler.with_options
val within' : ((unit ‑> 'a Async_kernel__.Scheduler.Deferred.t) ‑> 'a Async_kernel__.Scheduler.Deferred.t) Async_kernel__.Scheduler.with_options

Infix operators and Let_syntax support

include Core_kernel.Monad.Infix with type a t := a Deferred.t
type 'a t
val (>>=) : 'a t ‑> ('a ‑> 'b t) ‑> 'b t

t >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t to yield a value v, and then runs the computation returned by f v.

val (>>|) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

t >>| f is t >>= (fun a -> return (f a)).

val (>>>) : 'a Async_kernel__Deferred.t ‑> ('a ‑> unit) ‑> unit

equivalent to Deferred.upon.

val (>>=?) : ('a, 'b) Deferred.Result.t ‑> ('a ‑> ('c, 'b) Deferred.Result.t) ‑> ('c, 'b) Deferred.Result.t

equivalent to Deferred.Result.bind.

val (>>|?) : ('a, 'b) Deferred.Result.t ‑> ('a ‑> 'c) ‑> ('c, 'b) Deferred.Result.t

equivalent to Deferred.Result.map.

include Deferred.Let_syntax

These are convenient to have in scope when programming with a monad

val return : 'a ‑> 'a Deferred.t
include Base__.Monad_intf.Infix with type a t := a Deferred.t
type 'a t
val (>>=) : 'a t ‑> ('a ‑> 'b t) ‑> 'b t

t >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t to yield a value v, and then runs the computation returned by f v.

val (>>|) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

t >>| f is t >>= (fun a -> return (f a)).

module Let_syntax = Deferred.Let_syntax.Let_syntax