Module Async

Async_kernel

include Async_kernel
module Async_kernel_config = Async_kernel__.Config
module Bvar = Async_kernel.Bvar
module Clock_intf = Async_kernel.Clock_intf
module Clock_ns = Async_kernel.Clock_ns
module Deferred = Async_kernel.Deferred
module Eager_deferred = Async_kernel.Eager_deferred
module Execution_context = Async_kernel.Execution_context
module Handler = Async_kernel.Handler
module Ivar = Async_kernel.Ivar
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 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 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 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

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 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 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 included 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 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 shutdown : ?⁠force:unit Async_unix__.Import.Deferred.t ‑> int ‑> unit
val within : ((unit ‑> unit) ‑> unit) 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 Cpu_usage = Async_extra.Cpu_usage
module Dynamic_port_writer = Async_extra.Dynamic_port_writer
module File_tail = Async_extra.File_tail
module File_writer = Async_extra.File_writer
module Lock_file = Async_extra.Lock_file
module Persistent_connection = Async_extra.Persistent_connection
module Persistent_connection_intf = Async_extra.Persistent_connection_intf
module Persistent_singleton = Async_extra.Persistent_singleton
module Rpc = Async_extra.Rpc
module Schedule_v5 = Async_extra.Schedule_v5
module Schedule_v4_deprecated = Async_extra.Schedule_v4_deprecated
module Sequencer_table = Async_extra.Sequencer_table
module Tcp = Async_extra.Tcp
module Tcp_file = Async_extra.Tcp_file
module Typed_tcp = Async_extra.Typed_tcp
module Udp = Async_extra.Udp
module Unpack_sequence = Async_extra.Unpack_sequence
module User_and_group = Async_extra.User_and_group
module Versioned_rpc = Async_rpc_kernel.Versioned_rpc
module Versioned_typed_tcp = Async_extra.Versioned_typed_tcp
module Weak_hashtbl = Async_extra.Weak_hashtbl
module Expect_test_config : Expect_test_config.S with type 'a IO.t = 'a Deferred.t