### Async_kernel

`include 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 = Async_kernel.Async_kernel_config`
`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 = Async_kernel.Bvar`
`module Clock_ns = Async_kernel.Clock_ns`
`module Condition = Async_kernel__.Async_condition`
`module Deferred = Async_kernel.Deferred`
`module Eager_deferred = Async_kernel.Eager_deferred`
`module Execution_context = Async_kernel.Execution_context`
`module Gc = Async_kernel__.Async_gc`
`module Invariant = Async_kernel__.Async_invariant`
`module Ivar = Async_kernel.Ivar`
`module Quickcheck = Async_kernel__.Async_quickcheck`
`module Lazy_deferred = Async_kernel.Lazy_deferred`
`module Limiter = Limiter_in_this_directory`
`module Monad_sequence = Async_kernel.Monad_sequence`
`module Monitor = Async_kernel.Monitor`
`module Mvar = Async_kernel.Mvar`
`module Pipe = Async_kernel.Pipe`
`module Priority = Async_kernel.Priority`
`module Sequencer = Throttle.Sequencer`
`module Stream = Async_kernel__.Async_stream`
`module Synchronous_time_source = Async_kernel.Synchronous_time_source`
`module Tail = Async_kernel.Tail`
`module Throttle = Async_kernel.Throttle`
`module Time_source = Async_kernel.Time_source`
`module Use_eager_deferred = Async_kernel.Use_eager_deferred`

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`

### Async_unix

`include Async_unix`
`module Async_config = Async_unix__.Config`
`module Clock = Async_unix.Clock`
`module Dump_core_on_job_delay = Async_unix.Dump_core_on_job_delay`
`module Fd = Async_unix.Fd`
`module In_thread = Async_unix.In_thread`
`module Io_stats = Async_unix.Io_stats`
`module Log = Async_unix.Log`
`module Print = Async_unix__.Async_print`
`module Process = Async_unix.Process`
`module Reader = Async_unix.Reader`
`module Require_explicit_time_source = Async_unix.Require_explicit_time_source`
`module Scheduler = Async_unix.Scheduler`
`module Shutdown = Async_unix.Shutdown`
`module Signal = Async_unix.Signal`
`module Socket = Async_unix__.Unix_syscalls.Socket`
`module Sys = Async_unix__.Async_sys`
`module Thread_safe = Async_unix.Thread_safe`
`module Thread_safe_pipe = Async_unix.Thread_safe_pipe`
`module Writer = Async_unix.Writer`
`module Unix = Async_unix.Unix`
`include Async_unix__.Assign_try_with_log_exn`

This module is internal to Async. It is `include`d in `std.ml` so that any code that uses `Async_unix` does the top-level side effect in this module to assign `Async_kernel.Monitor0.try_with_log_exn`.

`val after : Core.Time.Span.t ‑> unit Async_kernel__.Clock_intf.Deferred.t`
`val at : Core.Time.t ‑> unit Async_kernel__.Clock_intf.Deferred.t`
`val every : ?⁠start:unit Async_kernel__.Clock_intf.Deferred.t ‑> ?⁠stop:unit Async_kernel__.Clock_intf.Deferred.t ‑> ?⁠continue_on_error:bool ‑> Core.Time.Span.t ‑> (unit ‑> unit) ‑> unit`
`val with_timeout : Core.Time.Span.t ‑> 'a Async_kernel__.Clock_intf.Deferred.t ‑> [ `Result of 'a | `Timeout ] Async_kernel__.Clock_intf.Deferred.t`
`val schedule : ((unit ‑> unit) ‑> unit) Scheduler.with_options`
`val schedule' : ((unit ‑> 'a Async_unix__.Import.Deferred.t) ‑> 'a Async_unix__.Import.Deferred.t) Scheduler.with_options`
`val shutdown : ?⁠force:unit Async_unix__.Import.Deferred.t ‑> int ‑> unit`
`val within : ((unit ‑> unit) ‑> unit) Scheduler.with_options`
`val within' : ((unit ‑> 'a Async_unix__.Import.Deferred.t) ‑> 'a Async_unix__.Import.Deferred.t) Scheduler.with_options`
`module Printf = Async_unix.Printf`
`include sig ... end`
`module Overwrite_ : sig ... end`
`val close_in_noerr : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val close_in : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val close_out_noerr : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val close_out : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val eprintf : ('a, unit, string, unit) Pervasives.format4 ‑> 'a`
`val flush_all : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val flush : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val fprintf : Writer.t ‑> ('a, unit, string, unit) Pervasives.format4 ‑> 'a`
`val ifprintf : 'a ‑> ('b, 'a, 'c, unit) Pervasives.format4 ‑> 'b`
`val in_channel_length : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input_binary_int : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input_byte : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input_char : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input_line : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input_lines : ?⁠fix_win_eol:'a ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val input_value : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val open_in_bin : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val open_in_gen : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val open_in : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val open_out_bin : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val open_out_gen : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val open_out : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val out_channel_length : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val output_binary_int : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val output_byte : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val output_char : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val output : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val output_string : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val output_value : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val pos_in : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val pos_out : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val prerr_char : char ‑> unit`
`val prerr_endline : string ‑> unit`
`val prerr_float : float ‑> unit`
`val prerr_int : int ‑> unit`
`val prerr_newline : unit ‑> unit`
`val prerr_string : string ‑> unit`
`val print_char : char ‑> unit`
`val print_endline : string ‑> unit`
`val print_float : float ‑> unit`
`val printf : ('a, unit, string, unit) Pervasives.format4 ‑> 'a`
`val print_int : int ‑> unit`
`val print_newline : unit ‑> unit`
`val print_s : ?⁠mach:unit ‑> Sexplib.Sexp.t ‑> unit`
`val print_string : string ‑> unit`
`val read_float : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val read_int : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val read_line : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val read_lines : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val read_wrap : ?⁠binary:'a ‑> f:'b ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val really_input : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val seek_in : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val seek_out : [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val set_binary_mode_in : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val set_binary_mode_out : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val write_lines : [< `This_is_async__Think_about_blocking ] ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`val write_wrap : ?⁠binary:'a ‑> f:'b ‑> [< `This_is_async__Think_about_blocking ] ‑> [> `This_is_async__Think_about_blocking ]`
`module LargeFile : sig ... end`
`module Sexp : sig ... end`
`val exit : ?⁠force:unit Async_unix__.Import.Deferred.t ‑> int ‑> 'a Async_unix__.Import.Deferred.t`

### Async_extra

`include Async_extra`
`module Bus = Async_extra.Bus`
`module Command = Async_extra.Command`
`module Lock_file = Async_extra.Lock_file`
`module Persistent_connection = Async_extra.Persistent_connection`
`module Rpc = Async_extra.Rpc`
`module Schedule_v5 = Async_extra.Schedule_v5`
`module Schedule_v4_deprecated = Async_extra.Schedule_v4_deprecated`
`module Tcp = Async_extra.Tcp`
`module Udp = Async_extra.Udp`
`module User_and_group = Async_extra.User_and_group`
`module Versioned_rpc = Async_rpc_kernel.Versioned_rpc`
`module Weak_hashtbl = Async_extra.Weak_hashtbl`
`module Expect_test_config : Expect_test_config.S with type 'a IO.t = 'a Deferred.t`