async_kernel v0.11.1 · OCaml Package

module Scheduler : sig ... end

type +'a t

include sig ... end

val sexp_of_t : 
  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
  'a t ->
  Ppx_sexp_conv_lib.Sexp.t

type 'a deferred = 'a t

include Core_kernel.Invariant.S1 with type 'a t := 'a t

val invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv

val of_ivar : 'a Async_kernel__.Types.Ivar.t -> 'a t

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

val peek : 'a t -> 'a option

val value_exn : 'a t -> 'a

val is_determined : _ t -> bool

val upon : 'a t -> ('a -> unit) -> unit

module Handler : sig ... end

val add_handler : 'a t -> ('a -> unit) -> Execution_context.t -> 'a Handler.t

val remove_handler : 'a t -> 'a Handler.t -> unit

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

module M : sig ... end

include module type of struct include M end
  with module Let_syntax := M.Let_syntax

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

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

module Monad_infix = M.Monad_infix

val bind : 
  'a Async_kernel__.Types.Deferred.t ->
  f:('a -> 'b Async_kernel__.Types.Deferred.t) ->
  'b Async_kernel__.Types.Deferred.t

val map : 
  'a Async_kernel__.Types.Deferred.t ->
  f:('a -> 'b) ->
  'b Async_kernel__.Types.Deferred.t

val join : 
  'a Async_kernel__.Types.Deferred.t Async_kernel__.Types.Deferred.t ->
  'a Async_kernel__.Types.Deferred.t

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

val return : 'a -> 'a Async_kernel__.Types.Deferred.t

module Let_syntax : module type of struct include M.Let_syntax end

val unit : unit Async_kernel__.Types.Deferred.t

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

val both : 'a t -> 'b t -> ('a * 'b) t

module Infix : sig ... end

val don't_wait_for : unit t -> unit

module Choice : sig ... end

type 'a choice = 'a Choice.t

module Unregister : sig ... end

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

val enabled : 
  'a Choice.t Core_kernel.List.t ->
  (unit -> 'a Core_kernel.List.t) Async_kernel__.Types.Deferred.t

val choose_result : 'a Choice.t list -> 'a

val choose : 
  'a Choice.t Core_kernel.List.t ->
  'a Async_kernel__.Types.Deferred.t

val any_f : 
  'a Async_kernel__.Types.Deferred.t Core_kernel.List.t ->
  ('a -> 'b) ->
  'b Async_kernel__.Types.Deferred.t

val any : 
  'a Async_kernel__.Types.Deferred.t Core_kernel.List.t ->
  'a Async_kernel__.Types.Deferred.t

val any_unit : 
  'a Async_kernel__.Types.Deferred.t Core_kernel.List.t ->
  unit Async_kernel__.Types.Deferred.t

val for_ : 
  int ->
  to_:int ->
  do_:(int -> unit Async_kernel__.Types.Deferred.t) ->
  unit Async_kernel__.Types.Deferred.t

val repeat_until_finished : 
  'a ->
  ('a -> [< `Finished of 'b | `Repeat of 'a ] t) ->
  'b t

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

type how = Monad_sequence.how

val sexp_of_how : how -> Ppx_sexp_conv_lib.Sexp.t

module type Monad_sequence = Monad_sequence.S with type 'a monad := 'a t

val fold : 'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t

val seqmap : 
  'a list ->
  f:('a -> 'b Async_kernel__.Types.Deferred.t) ->
  'b Core_kernel.List.t Async_kernel__.Types.Deferred.t

val all : 
  'a Async_kernel__.Types.Deferred.t list ->
  'a Core_kernel.List.t Async_kernel__.Types.Deferred.t

val all_unit : unit t list -> unit t

val all_ignore : unit t list -> unit t

val ok : 
  'a Async_kernel__.Types.Deferred.t ->
  ('a, 'b) Core_kernel._result Async_kernel__.Types.Deferred.t

package async_kernel