`module Scheduler = Async_kernel__.Scheduler1`
`include Async_kernel__.Deferred0`

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

`type +'a t``= 'a Async_kernel__.Types.Deferred.t```
`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 invariant : 'a Base__.Invariant_intf.inv ‑> 'a t Base__.Invariant_intf.inv`
`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`
`module Handler = Async_kernel__.Deferred0.Handler`
`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 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 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 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 all : 'a Async_kernel__.Types.Deferred.t list ‑> 'a list Async_kernel__.Types.Deferred.t`
`val all_unit : unit Async_kernel__.Types.Deferred.t list ‑> unit 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`