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 `wait`ing 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 `Monad_sequence.how` 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 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`