Async_kernel (async_kernel.Async

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

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

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

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

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

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

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

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

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

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

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

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

module Let_syntax = Deferred.Let_syntax.Let_syntax