package async_kernel

  1. Overview
  2. Docs
package async_kernel
Legend:
Library
Module
Module type
Parameter
Class
Class type
module Limiter_in_this_directory = Limiter
module Async_kernel_config : sig ... end

Settings that globally affect the behavior of 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
module Clock_ns : sig ... end
module Condition : sig ... end

Async's implementation of the standard notion of a "condition" variable.

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 : sig ... end

Async's analog of Core_kernel.Gc.

module Handler : sig ... end

A continuation that captures the current Async execution context.

module Invariant : sig ... end
module Ivar : sig ... end

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

module Quickcheck : sig ... end
module Lazy_deferred : sig ... end

A delayed computation that can produce a deferred.

module Limiter : sig ... end
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 : sig ... end

An immutable sequence of values, with a possibly incomplete tail that may be extended asynchronously.

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 at : Base__.Int63_backends.Dynamic.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 -> Core_kernel.Core_kernel_private.Time_ns_alternate_sexp.Span.t -> (unit -> unit) -> unit
val never : unit -> 'a Deferred.t
val schedule : ?monitor:Monitor.t -> ?priority:Priority.t -> (unit -> unit) -> unit
val schedule' : ?monitor:Monitor.t -> ?priority:Priority.t -> (unit -> 'a Async_kernel__.Types.Deferred.t) -> 'a Async_kernel__.Types.Deferred.t
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 within : ?monitor:Monitor.t -> ?priority:Priority.t -> (unit -> unit) -> unit
val within' : ?monitor:Monitor.t -> ?priority:Priority.t -> (unit -> 'a Async_kernel__.Types.Deferred.t) -> 'a Async_kernel__.Types.Deferred.t
val (>>>) : 'a Async_kernel__.Types.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
include module type of struct include Deferred.Let_syntax end
val return : 'a -> 'a Deferred.t
val (>>=) : 'a Deferred.t -> ('a -> 'b Deferred.t) -> 'b Deferred.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 Deferred.t -> ('a -> 'b) -> 'b Deferred.t

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

module Let_syntax = Deferred.Let_syntax.Let_syntax
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.

module Async_kernel_private : sig ... end