Module `Async`

Async_kernel

include Async_kernel

module Async_kernel_config = Async_kernel.Async_kernel_config

module Async_kernel_require_explicit_time_source = Async_kernel__.Require_explicit_time_source

module Async_kernel_scheduler = Async_kernel.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 Execution_context = Async_kernel.Execution_context

module Gc = Async_kernel__.Async_gc

module Invariant = Async_kernel__.Async_invariant

module Ivar = Async_kernel.Ivar

module Lazy_deferred = Async_kernel.Lazy_deferred

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

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

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

module Deferred : sig ... end

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 Tcp = Async_unix.Tcp

module Thread_safe = Async_unix.Thread_safe

module Writer = Async_unix.Writer

module Unix = Async_unix.Unix

include Async_unix__.Assign_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_kernel.Deferred.t) -> 'a Async_kernel.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_kernel.Deferred.t) -> 'a Async_kernel.Deferred.t) Scheduler.with_options

module Printf = Async_unix.Printf: Shadow blocking functions in Core.Printf to prevent their unintentional use.

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) Stdlib.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) Stdlib.format4 -> 'a
val ifprintf : 'a -> ('b, 'a, 'c, unit) Stdlib.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) Stdlib.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 ]
val eprint_s : [< `This_is_async__Think_about_blocking ] -> [> `This_is_async__Think_about_blocking ]
val eprint_s_nonblocking : ?⁠mach:unit -> Sexplib.Sexp.t -> unit

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_command

module Command : sig ... end

Async_rpc

include Async_rpc

module Rpc = Async_rpc.Rpc

module Versioned_rpc = Async_rpc_kernel.Versioned_rpc

module Quickcheck : sig ... end

module Expect_test_config : Expect_test_config_types.S with type 'a IO_flush.t = 'a Deferred.t with type 'a IO_run.t = 'a Deferred.t

module Expect_test_config_with_unit_expect : sig ... end: An alternative to Async.Expect_test_config in which %expect has type unit rather than unit Deferred.t. This lets one write: