package async

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Async_kernel
Async_unix
Async_command
Async_rpc

async
- Async
  - Async_kernel_require_explicit_time_source
    
    Async_kernel_scheduler
    
    Clock_ns
    
    Event
    
    Status
    
    Date
    
    Time
    
    Time_ns
  - Command
  - Condition
  - Deferred
    
    Or_error
    
    Expect_test_config
    
    IO_flush
    
    IO_run
  - Expect_test_config
    
    IO_flush
    
    IO_run
  - Expect_test_config_with_unit_expect
    
    IO_flush
    
    IO_run
  - Gc
    
    Alarm
  - Invariant
    
    Async
    
    S
    
    S1
    
    S2
    
    S3
  - Quickcheck
  - Stream
    
    Deferred
    
    Choice
    
    Handler
    
    Infix
    
    Let_syntax
    
    Let_syntax
    
    M
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    Monad_infix
    
    Monad_sequence
    
    Scheduler
    
    Bvar
    
    Fields
    
    Direct
    
    Ivar
    
    Synchronous_time_source
    
    Alarm
    
    Event
    
    Abort_result
    
    Reschedule_result
    
    Id
    
    Hash_queue
    
    Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
    
    Map
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Tree
    
    Provide_of_sexp
    
    K
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Named
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
    
    Tree
    
    Named
    
    Provide_of_sexp
    
    Elt
    
    Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Read_write
    
    T1
    
    Event
    
    Fields
    
    Direct
    
    Status
    
    Fields
    
    Direct
    
    Job_or_event
    
    Match
    
    Time_ns
    
    Very_low_priority_worker
    
    Exec_result
    
    Fields
    
    Direct
    
    Unregister
async.async_command
- Async_command
  - Staged
async.async_quickcheck
- Async_quickcheck
  - Configure
    
    Config
async.async_rpc
- Async_rpc
  - Rpc
    
    Connection
    
    Low_latency_transport
    
    Config
    
    Reader
    
    Writer
    
    Transport
    
    Reader
    
    Writer
async.lock_file_async
- Lock_file_async
  - Flock
  - Nfs
  - Symlink
async.log_extended
- Log_extended
  - Command
  - Console
    
    Blocking
  - Syslog
    
    Blocking
async.persistent_connection
- Persistent_connection
  - Make
    
    Conn
    
    Address
    
    Event
  - Rpc
    
    Event
  - S
    
    Event
  - Versioned_rpc
    
    Event
async.unpack_sequence
- Unpack_sequence

Legend:
Library
Module
Module type
Parameter
Class
Class type

Async_kernel

include module type of Async_kernel
  with module Deferred := Async_kernel.Deferred

module Async_kernel_config = Async_kernel.Async_kernel_config

module Async_kernel_require_explicit_time_source : sig ... end

Deprecates functions that use wall-clock time, so that code must be explicit about what time source is used.

module Async_kernel_scheduler = Async_kernel.Async_kernel_scheduler

module Bvar = Async_kernel.Bvar

module Clock_ns = Async_kernel.Clock_ns

module Condition : sig ... end

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

module Execution_context = Async_kernel.Execution_context

module Gc : sig ... end

Async's analog of Core_kernel.Gc.

module Invariant : sig ... end

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 = Async_kernel.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 = 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 catch : 
  ((unit -> unit) -> exn Monitor.Deferred.t) Monitor.with_optional_monitor_name

val choice : 
  'a Async_kernel.Deferred.t ->
  ('a -> 'b) ->
  'b Async_kernel.Deferred.Choice.t

val choose : 
  'a Async_kernel.Deferred.Choice.t list ->
  'a Async_kernel.Deferred.t

val don't_wait_for : unit Async_kernel.Deferred.t -> unit

val never : unit -> 'a Async_kernel.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 Async_kernel.Deferred.t -> ('a -> unit) -> unit

Infix operators and `Let_syntax` support

include Core_kernel.Monad.Infix with type 'a t := 'a Async_kernel.Deferred.t

val (>>>) : 'a Async_kernel__.Types.Deferred.t -> ('a -> unit) -> unit

equivalent to Deferred.upon.

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

equivalent to Deferred.Result.bind.

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

equivalent to Deferred.Result.map.

include module type of struct include Async_kernel.Deferred.Let_syntax end

val return : 'a -> 'a Async_kernel.Deferred.t

val (>>=) : 
  'a Async_kernel.Deferred.t ->
  ('a -> 'b Async_kernel.Deferred.t) ->
  'b Async_kernel.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 Async_kernel.Deferred.t ->
  ('a -> 'b) ->
  'b Async_kernel.Deferred.t

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

module Let_syntax = Async_kernel.Deferred.Let_syntax.Let_syntax

module Deferred : sig ... end

Async_unix

include module type of struct include Async_unix end

module Async_config = Async_unix.Async_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.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.Socket

module Sys = Async_unix.Sys

module Tcp = Async_unix.Tcp

module Thread_safe = Async_unix.Thread_safe

module Writer = Async_unix.Writer

module Unix = Async_unix.Unix

val after : Core.Time.Span.t -> unit Async_kernel__.Types.Deferred.t

val at : Core.Time.t -> unit Async_kernel__.Types.Deferred.t

val every : 
  ?start:unit Async_kernel__.Types.Deferred.t ->
  ?stop:unit Async_kernel__.Types.Deferred.t ->
  ?continue_on_error:bool ->
  Core.Time.Span.t ->
  (unit -> unit) ->
  unit

val with_timeout : 
  Core.Time.Span.t ->
  'a Async_kernel__.Types.Deferred.t ->
  [ `Result of 'a | `Timeout ] Async_kernel__.Types.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_kernel.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_ = Async_unix.Overwrite_

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 : 
  Async_unix.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 ]

module LargeFile = Async_unix.LargeFile

module Sexp = Async_unix.Sexp

val exit : 
  ?force:unit Async_kernel.Deferred.t ->
  int ->
  'a Async_kernel.Deferred.t

Async_command

module Command : sig ... end

Async_rpc

include module type of struct include Async_rpc end

module Rpc = Async_rpc.Rpc

module Versioned_rpc = Async_rpc.Versioned_rpc

module Quickcheck : sig ... end

module Expect_test_config : 
  Expect_test_config.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: