package async
sectionYPositions = computeSectionYPositions($el), 10)"
x-init="setTimeout(() => sectionYPositions = computeSectionYPositions($el), 10)"
>
On This Page
Legend:
Library
Module
Module type
Parameter
Class
Class type
Library
Module
Module type
Parameter
Class
Class type
Async_kernel
include module type of struct include Async_kernel end
module Async_kernel_config = Async_kernel.Async_kernel_config
module Async_kernel_require_explicit_time_source =
Async_kernel.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.Condition
module Execution_context = Async_kernel.Execution_context
module Gc = Async_kernel.Gc
module Invariant = Async_kernel.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 = 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
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 Async_kernel.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 Async_kernel.Deferred.t) ->
('a, exn) Core.Result.t Async_kernel.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.Monad.Infix with type 'a t := 'a Async_kernel.Deferred.t
val (>>>) : 'a Async_kernel.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.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 : Time_unix.Span.t -> unit Async_kernel.Deferred.t
val at : Time_unix.t -> unit Async_kernel.Deferred.t
val every :
?start:unit Async_kernel.Deferred.t ->
?stop:unit Async_kernel.Deferred.t ->
?continue_on_error:bool ->
Time_unix.Span.t ->
(unit -> unit) ->
unit
val with_timeout :
Time_unix.Span.t ->
'a Async_kernel.Deferred.t ->
'a Clock.Or_timeout.t Async_kernel.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 eprintf : ('a, unit, string, unit) format4 -> 'a
val fprintf : Async_unix.Writer.t -> ('a, unit, string, unit) format4 -> 'a
val ifprintf : 'a -> ('b, 'a, 'c, unit) format4 -> 'b
val printf : ('a, unit, string, unit) format4 -> 'a
val print_s : ?mach:unit -> Sexplib.Sexp.t -> unit
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 = 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 : sig ... end
The default expect test config in code which has open Async
.
module Expect_test_config_or_error : sig ... end
An alternative to Async.Deferred_or_error_expect_test_config
in which %expect
has type unit
rather than unit Deferred.Or_error.t
. This lets one write:
module Ppx_log_syntax : sig ... end
sectionYPositions = computeSectionYPositions($el), 10)"
x-init="setTimeout(() => sectionYPositions = computeSectionYPositions($el), 10)"
>
On This Page