Module Async_kernel

Contains Async's core data structures, like Deferred, Ivar, and Clock.

Async_kernel is designed to depend only on Core_kernel (as opposed to Core), and so is more platform-independent.

module Async_kernel_config : sig ... end

Settings that globally affect the behavior of Async.

module Async_kernel_persistent_connection = Async_kernel__.Persistent_connection
module Async_kernel_require_explicit_time_source = Async_kernel__.Require_explicit_time_source
module Async_kernel_scheduler = Async_kernel__.Scheduler
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_ns : sig ... end

Provides a Clock with Time_ns as the unit.

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

Monad_sequence.S is a generic interface specifying functions that deal with a container and a monad. It is specialized to the Deferred monad and used with various containers in modules Deferred.Array, Deferred.List, Deferred.Queue, and Deferred.Sequence. The type specifies the parallelism of container iterators.

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 Async_kernel__.Clock_intf.Deferred.t
val at : Async_kernel__.Import.Time_ns.t ‑> unit Async_kernel__.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 Async_kernel__.Clock_intf.Deferred.t ‑> ?⁠stop:unit Async_kernel__.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 Async_kernel__.Clock_intf.Deferred.t ‑> [ `Result of 'a | `Timeout ] Async_kernel__.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 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'bDeferred.Result.t ‑> ('a ‑> ('c'bDeferred.Result.t) ‑> ('c'bDeferred.Result.t

equivalent to Deferred.Result.bind.

val (>>|?) : ('a'bDeferred.Result.t ‑> ('a ‑> 'c) ‑> ('c'bDeferred.Result.t

equivalent to

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