package async

You can search for identifiers within the package.

in-package search v0.2.0

package async

async
- Async
  - Expect_test_config
  - Std
    
    Expect_test_config
    
    IO

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Std : sig ... end

include module type of struct include Async_kernel end

module Limiter_in_this_directory = Async_kernel.Limiter_in_this_directory

module Async_kernel_config = Async_kernel.Async_kernel_config

module Bvar = Async_kernel.Bvar

module Clock_intf = Async_kernel.Clock_intf

module Clock_ns = Async_kernel.Clock_ns

module Condition = Async_kernel.Condition

module Deferred = Async_kernel.Deferred

module Eager_deferred = Async_kernel.Eager_deferred

module Execution_context = Async_kernel.Execution_context

module Gc = Async_kernel.Gc

module Handler = Async_kernel.Handler

module Invariant = Async_kernel.Invariant

module Ivar = Async_kernel.Ivar

module Quickcheck = Async_kernel.Quickcheck

module Lazy_deferred = Async_kernel.Lazy_deferred

module Limiter = Async_kernel.Limiter

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.Sequencer

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

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 never : unit -> 'a 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 (>>>) : '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 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.Let_syntax

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.

module Async_kernel_private = Async_kernel.Async_kernel_private

include module type of struct include Async_unix.Std end

module Async_config = Async_unix.Std.Async_config

module Clock = Async_unix.Std.Clock

module Fd = Async_unix.Std.Fd

module In_thread = Async_unix.Std.In_thread

module Io_stats = Async_unix.Std.Io_stats

module Log = Async_unix.Std.Log

module Print = Async_unix.Std.Print

module Process = Async_unix.Std.Process

module Reader = Async_unix.Std.Reader

module Require_explicit_time_source =
  Async_unix.Std.Require_explicit_time_source

module Scheduler = Async_unix.Std.Scheduler

module Shutdown = Async_unix.Std.Shutdown

module Signal = Async_unix.Std.Signal

module Socket = Async_unix.Std.Socket

module Sys = Async_unix.Std.Sys

module Thread_safe = Async_unix.Std.Thread_safe

module Thread_safe_pipe = Async_unix.Std.Thread_safe_pipe

module Writer = Async_unix.Std.Writer

module Unix = Async_unix.Std.Unix

include module type of struct include Async_unix.Assign_try_with_log_exn end

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.Std.Printf

include sig ... end

module Overwrite_ = Async_unix.Std.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) 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 : 
  Async_unix.Writer.t ->
  ('a, unit, string, unit) Pervasives.format4 ->
  'a

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_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.Std.LargeFile

module Sexp = Async_unix.Std.Sexp

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

include module type of struct include Async_extra.Std end

module Bus = Async_extra.Std.Bus

module Command = Async_extra.Std.Command

module Cpu_usage = Async_extra.Std.Cpu_usage

module Dynamic_port_writer = Async_extra.Std.Dynamic_port_writer

module File_tail = Async_extra.Std.File_tail

module File_writer = Async_extra.Std.File_writer

module Lock_file = Async_extra.Std.Lock_file

module Persistent_connection = Async_extra.Std.Persistent_connection

module Persistent_singleton = Async_extra.Std.Persistent_singleton

module Rpc = Async_extra.Std.Rpc

module Schedule = Async_extra.Std.Schedule

module Sequencer_table = Async_extra.Std.Sequencer_table

module Tcp = Async_extra.Std.Tcp

module Tcp_file = Async_extra.Std.Tcp_file

module Typed_tcp = Async_extra.Std.Typed_tcp

module Udp = Async_extra.Std.Udp

module Unpack_sequence = Async_extra.Std.Unpack_sequence

module User_and_group = Async_extra.Std.User_and_group

module Versioned_rpc = Async_extra.Std.Versioned_rpc

module Versioned_typed_tcp = Async_extra.Std.Versioned_typed_tcp

module Weak_hashtbl = Async_extra.Std.Weak_hashtbl

module Expect_test_config : sig ... end