sig
  type 'a t = 'a Ivar.Deferred.t
  val create : ('a Ivar.t -> unit) -> 'a t
  val upon : 'a t -> ('a -> unit) -> unit
  val peek : 'a t -> 'a option
  val is_determined : 'a t -> bool
  val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
  val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
  module Monad_infix :
    sig
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
    end
  val bind : 'a t -> ('a -> 'b t) -> 'b t
  val return : 'a -> 'a t
  val map : 'a t -> f:('a -> 'b) -> 'b t
  val join : 'a t t -> 'a t
  val ignore : 'a t -> unit t
  val all_ignore : unit t list -> unit t
  module Infix :
    sig
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      val ( >>> ) : 'a t -> ('a -> unit) -> unit
    end
  val unit : unit t
  val never : unit -> 'a t
  val both : 'a t -> 'b t -> ('a * 'b) t
  val all : 'a t list -> 'a list t
  val all_unit : unit t list -> unit t
  val any : 'a t list -> 'a t
  val any_unit : 'a t list -> unit t
  module type Monad_sequence =
    sig
      type 'a t
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
      val init : ?how:Deferred_intf.how -> int -> f:(int -> 'a t) -> 'a t t
      val iter : ?how:Deferred_intf.how -> 'a t -> f:('a -> unit t) -> unit t
      val iteri :
        ?how:Deferred_intf.how -> 'a t -> f:(int -> 'a -> unit t) -> unit t
      val map : ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b t) -> 'b t t
      val filter :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> bool t) -> 'a t t
      val filter_map :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b option t) -> 'b t t
      val find : 'a t -> f:('a -> bool t) -> 'a option t
      val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
      val all : 'a t t -> 'a t t
      val all_unit : unit t t -> unit t
    end
  module Array :
    sig
      type 'a t = 'a array
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
      val init : ?how:Deferred_intf.how -> int -> f:(int -> 'a t) -> 'a t t
      val iter : ?how:Deferred_intf.how -> 'a t -> f:('a -> unit t) -> unit t
      val iteri :
        ?how:Deferred_intf.how -> 'a t -> f:(int -> 'a -> unit t) -> unit t
      val map : ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b t) -> 'b t t
      val filter :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> bool t) -> 'a t t
      val filter_map :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b option t) -> 'b t t
      val find : 'a t -> f:('a -> bool t) -> 'a option t
      val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
      val all : 'a t t -> 'a t t
      val all_unit : unit t t -> unit t
    end
  module List :
    sig
      type 'a t = 'a list
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
      val init : ?how:Deferred_intf.how -> int -> f:(int -> 'a t) -> 'a t t
      val iter : ?how:Deferred_intf.how -> 'a t -> f:('a -> unit t) -> unit t
      val iteri :
        ?how:Deferred_intf.how -> 'a t -> f:(int -> 'a -> unit t) -> unit t
      val map : ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b t) -> 'b t t
      val filter :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> bool t) -> 'a t t
      val filter_map :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b option t) -> 'b t t
      val find : 'a t -> f:('a -> bool t) -> 'a option t
      val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
      val all : 'a t t -> 'a t t
      val all_unit : unit t t -> unit t
    end
  module Queue :
    sig
      type 'a t = 'a Core.Std.Queue.t
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
      val init : ?how:Deferred_intf.how -> int -> f:(int -> 'a t) -> 'a t t
      val iter : ?how:Deferred_intf.how -> 'a t -> f:('a -> unit t) -> unit t
      val iteri :
        ?how:Deferred_intf.how -> 'a t -> f:(int -> 'a -> unit t) -> unit t
      val map : ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b t) -> 'b t t
      val filter :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> bool t) -> 'a t t
      val filter_map :
        ?how:Deferred_intf.how -> 'a t -> f:('a -> 'b option t) -> 'b t t
      val find : 'a t -> f:('a -> bool t) -> 'a option t
      val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
      val all : 'a t t -> 'a t t
      val all_unit : unit t t -> unit t
    end
  module Map :
    sig
      type ('a, 'b, 'c) t = ('a, 'b, 'c) Core.Std.Map.t
      val change :
        ('k, 'v, 'comparator) t ->
        'k ->
        ('v option -> 'v option Deferred_intf.Deferred.t) ->
        ('k, 'v, 'comparator) t Deferred_intf.Deferred.t
      val iter :
        ?how:Deferred_intf.how ->
        ('k, 'v, 'a) t ->
        f:(key:'k -> data:'v -> unit Deferred_intf.Deferred.t) ->
        unit Deferred_intf.Deferred.t
      val map :
        ?how:Deferred_intf.how ->
        ('k, 'v1, 'comparator) t ->
        f:('v1 -> 'v2 Deferred_intf.Deferred.t) ->
        ('k, 'v2, 'comparator) t Deferred_intf.Deferred.t
      val mapi :
        ?how:Deferred_intf.how ->
        ('k, 'v1, 'comparator) t ->
        f:(key:'k -> data:'v1 -> 'v2 Deferred_intf.Deferred.t) ->
        ('k, 'v2, 'comparator) t Deferred_intf.Deferred.t
      val fold :
        ('k, 'v, 'b) t ->
        init:'a ->
        f:(key:'k -> data:'v -> 'a -> 'a Deferred_intf.Deferred.t) ->
        'a Deferred_intf.Deferred.t
      val fold_right :
        ('k, 'v, 'b) t ->
        init:'a ->
        f:(key:'k -> data:'v -> 'a -> 'a Deferred_intf.Deferred.t) ->
        'a Deferred_intf.Deferred.t
      val filter :
        ?how:Deferred_intf.how ->
        ('k, 'v, 'comparable) t ->
        f:(key:'k -> data:'v -> bool Deferred_intf.Deferred.t) ->
        ('k, 'v, 'comparable) t Deferred_intf.Deferred.t
      val filter_map :
        ?how:Deferred_intf.how ->
        ('k, 'v1, 'comparable) t ->
        f:('v1 -> 'v2 option Deferred_intf.Deferred.t) ->
        ('k, 'v2, 'comparable) t Deferred_intf.Deferred.t
      val filter_mapi :
        ?how:Deferred_intf.how ->
        ('k, 'v1, 'comparable) t ->
        f:(key:'k -> data:'v1 -> 'v2 option Deferred_intf.Deferred.t) ->
        ('k, 'v2, 'comparable) t Deferred_intf.Deferred.t
      val merge :
        ?how:Deferred_intf.how ->
        ('k, 'v1, 'comparator) t ->
        ('k, 'v2, 'comparator) t ->
        f:(key:'k ->
           [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
           'v3 option Deferred_intf.Deferred.t) ->
        ('k, 'v3, 'comparator) t Deferred_intf.Deferred.t
    end
  module Result :
    sig
      type ('a, 'b) t = ('a, 'b) Core.Std.Result.t t
      val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
      val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
        end
      val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
      val return : 'a -> ('a, 'b) t
      val map : ('a, 'd) t -> f:('a -> 'b) -> ('b, 'd) t
      val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
      val ignore : ('a, 'd) t -> (unit, 'd) t
      val all : ('a, 'd) t list -> ('a list, 'd) t
      val all_ignore : (unit, 'd) t list -> (unit, 'd) t
    end
  module Option :
    sig
      type 'a t = 'a option t
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
    end
  val don't_wait_for : unit t -> unit
  type 'a choice = 'a Deferred.choice
  val choice : 'a t -> ('a -> 'b) -> 'b choice
  val enabled : 'b choice list -> (unit -> 'b list) t
  val choose : 'b choice list -> 'b t
  val repeat_until_finished :
    'state ->
    ('state -> [ `Finished of 'result | `Repeat of 'state ] t) -> 'result t
  val forever : 'state -> ('state -> 'state t) -> unit
  val debug_space_leaks : int option ref
  val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
  module Or_error :
    sig
      type 'a t = 'a Core.Std.Or_error.t Deferred.t
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      val fail : Core.Std.Error.t -> 'a t
      val ok_exn : 'a t -> 'a Deferred.t
      val of_exn : exn -> 'a t
      val of_exn_result : ('a, exn) Core.Std.Result.t Deferred.t -> 'a t
      val error : string -> 'a -> ('a -> Core.Std.Sexp.t) -> 'b t
      val error_string : string -> 'a t
      val unimplemented : string -> 'a t
      val combine_errors : 'a t list -> 'a list t
      val combine_errors_unit : unit t list -> unit t
      val ok_unit : unit t
      val try_with :
        ?extract_exn:bool -> ?name:string -> (unit -> 'a Deferred.t) -> 'a t
      val try_with_join :
        ?extract_exn:bool -> ?name:string -> (unit -> 'a t) -> 'a t
      module List :
        sig
          val foldi :
            'a list -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
          val fold : 'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
          val init :
            ?how:Deferred_intf.how -> int -> f:(int -> 'a t) -> 'a list t
          val iter :
            ?how:Deferred_intf.how -> 'a list -> f:('a -> unit t) -> unit t
          val iteri :
            ?how:Deferred_intf.how ->
            'a list -> f:(int -> 'a -> unit t) -> unit t
          val map :
            ?how:Deferred_intf.how -> 'a list -> f:('a -> 'b t) -> 'b list t
          val filter :
            ?how:Deferred_intf.how ->
            'a list -> f:('a -> bool t) -> 'a list t
          val filter_map :
            ?how:Deferred_intf.how ->
            'a list -> f:('a -> 'b option t) -> 'b list t
          val find : 'a list -> f:('a -> bool t) -> 'a option t
          val find_map : 'a list -> f:('a -> 'b option t) -> 'b option t
          val all : 'a t list -> 'a list t
          val all_unit : unit t list -> unit t
        end
    end
end