Module Async_kernel__.Deferred1

module Scheduler = Async_kernel__.Scheduler1
include Async_kernel__.Deferred0

Internal to Async -- see Deferred for the public API.

include sig ... end
val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> 'a t ‑> Base.Sexp.t
type 'a deferred = 'a t
include Core_kernel.Invariant.S1 with type a t := a t
type 'a t
val of_ivar : 'a Async_kernel__.Ivar0.t ‑> 'a t
val create : ('a Async_kernel__.Ivar0.t ‑> unit) ‑> 'a t
val peek : 'a t ‑> 'a option
val value_exn : 'a t ‑> 'a
val is_determined : _ t ‑> bool
val return : 'a ‑> 'a t
val upon : 'a t ‑> ('a ‑> unit) ‑> unit
val bind : 'a t ‑> f:('a ‑> 'b t) ‑> 'b t
val add_handler : 'a t ‑> ('a ‑> unit) ‑> Async_kernel.Execution_context.t ‑> 'a Handler.t
val remove_handler : 'a t ‑> 'a Handler.t ‑> unit
val never : unit ‑> 'a Async_kernel__.Deferred0.t
module M : sig ... end
include module type of sig ... end with module Let_syntax := M.Let_syntax
val (>>|) : 'a Async_kernel__.Types.Deferred.t ‑> ('a ‑> 'b) ‑> 'b Async_kernel__.Types.Deferred.t
module Monad_infix = M.Monad_infix
val return : 'a ‑> 'a Async_kernel__.Types.Deferred.t
val map : 'a Async_kernel__.Types.Deferred.t ‑> f:('a ‑> 'b) ‑> 'b Async_kernel__.Types.Deferred.t
val all_ignore : unit Async_kernel__.Types.Deferred.t list ‑> unit Async_kernel__.Types.Deferred.t
  • Deprecated [since 2018-02] Use [all_unit]
module Let_syntax = M.Let_syntax
val return : 'a ‑> 'a Async_kernel__.Deferred0.t
module Let_syntax : module type of sig ... end
val all : [> `Make_sure_to_define_all_elsewhere ]
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__.Deferred0.t ‑> ('a ‑> 'b) ‑> 'b Choice.t
val enabled : 'a Choice.t Core_kernel.List.t ‑> (unit ‑> 'a Core_kernel.List.t) Async_kernel__.Deferred0.t
val choose_result : 'a Choice.t list ‑> 'a
val choose : 'a Choice.t Core_kernel.List.t ‑> 'a Async_kernel__.Deferred0.t
val any_f : 'a Async_kernel__.Deferred0.t Core_kernel.List.t ‑> ('a ‑> 'b) ‑> 'b Async_kernel__.Deferred0.t
val any : 'a Async_kernel__.Deferred0.t Core_kernel.List.t ‑> 'a Async_kernel__.Deferred0.t
val any_unit : 'a Async_kernel__.Deferred0.t Core_kernel.List.t ‑> unit Async_kernel__.Deferred0.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 = Async_kernel.Monad_sequence.how
val sexp_of_how : how ‑> Base.Sexp.t
module type Monad_sequence : Async_kernel.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