sig
  module type Foldable =
    sig type t type data val init : t val f : t -> data -> t end
  module type S =
    sig
      type in_value
      type out_value
      type 'key t = private ('key, out_value) Core.Std.Map.Poly.t
      type 'a _in_value = in_value
      type 'a _out_value = out_value
      type ('a, 'b) _t = 'a t
      val empty : 'a t
      val singleton : 'a -> in_value -> 'a t
      val is_empty : 'a t -> bool
      val length : 'a t -> int
      val add : key:'a -> data:in_value -> 'a t -> 'a t
      val find : 'a t -> 'a -> out_value
      val remove : 'a t -> 'a -> 'a t
      val set : key:'a -> data:out_value -> 'a t -> 'a t
      val mem : 'a t -> 'a -> bool
      val iter : 'a t -> f:(key:'a -> data:out_value -> unit) -> unit
      val fold :
        'a t -> init:'b -> f:(key:'a -> data:out_value -> 'b -> 'b) -> 'b
      val filter : 'a t -> f:(key:'a -> data:out_value -> bool) -> 'a t
      val keys : 'a t -> 'a list
      val data : 'a t -> out_value list
      val to_alist : 'a t -> ('a * out_value) list
      val of_list : ('a * in_value) list -> 'a t
      val for_all : 'a t -> f:(out_value -> bool) -> bool
      val exists : 'a t -> f:(out_value -> bool) -> bool
      val to_map : 'a t -> ('a, out_value) Core.Std.Map.Poly.t
      val of_map : ('a, out_value) Core.Std.Map.Poly.t -> 'a t
    end
  module Make :
    functor (Fold : Foldable) ->
      sig
        type in_value = Fold.data
        type out_value = Fold.t
        type 'key t = 'key Fold_map.Make(Fold).t
        type 'a _in_value = in_value
        type 'a _out_value = out_value
        type ('a, 'b) _t = 'a t
        val empty : 'a t
        val singleton : 'a -> in_value -> 'a t
        val is_empty : 'a t -> bool
        val length : 'a t -> int
        val add : key:'a -> data:in_value -> 'a t -> 'a t
        val find : 'a t -> 'a -> out_value
        val remove : 'a t -> 'a -> 'a t
        val set : key:'a -> data:out_value -> 'a t -> 'a t
        val mem : 'a t -> 'a -> bool
        val iter : 'a t -> f:(key:'a -> data:out_value -> unit) -> unit
        val fold :
          'a t -> init:'b -> f:(key:'a -> data:out_value -> 'b -> 'b) -> 'b
        val filter : 'a t -> f:(key:'a -> data:out_value -> bool) -> 'a t
        val keys : 'a t -> 'a list
        val data : 'a t -> out_value list
        val to_alist : 'a t -> ('a * out_value) list
        val of_list : ('a * in_value) list -> 'a t
        val for_all : 'a t -> f:(out_value -> bool) -> bool
        val exists : 'a t -> f:(out_value -> bool) -> bool
        val to_map : 'a t -> ('a, out_value) Core.Std.Map.Poly.t
        val of_map : ('a, out_value) Core.Std.Map.Poly.t -> 'a t
      end
  module type S_sexpable =
    sig
      type in_value
      type out_value
      type 'key t = private ('key, out_value) Core.Std.Map.Poly.t
      type 'a _in_value = in_value
      type 'a _out_value = out_value
      type ('a, 'b) _t = 'a t
      val empty : 'a t
      val singleton : 'a -> in_value -> 'a t
      val is_empty : 'a t -> bool
      val length : 'a t -> int
      val add : key:'a -> data:in_value -> 'a t -> 'a t
      val find : 'a t -> 'a -> out_value
      val remove : 'a t -> 'a -> 'a t
      val set : key:'a -> data:out_value -> 'a t -> 'a t
      val mem : 'a t -> 'a -> bool
      val iter : 'a t -> f:(key:'a -> data:out_value -> unit) -> unit
      val fold :
        'a t -> init:'b -> f:(key:'a -> data:out_value -> 'b -> 'b) -> 'b
      val filter : 'a t -> f:(key:'a -> data:out_value -> bool) -> 'a t
      val keys : 'a t -> 'a list
      val data : 'a t -> out_value list
      val to_alist : 'a t -> ('a * out_value) list
      val of_list : ('a * in_value) list -> 'a t
      val for_all : 'a t -> f:(out_value -> bool) -> bool
      val exists : 'a t -> f:(out_value -> bool) -> bool
      val to_map : 'a t -> ('a, out_value) Core.Std.Map.Poly.t
      val of_map : ('a, out_value) Core.Std.Map.Poly.t -> 'a t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
    end
  module type Foldable_sexpable =
    sig
      type t
      type data
      val init : t
      val f : t -> data -> t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Make_sexpable :
    functor (Fold : Foldable_sexpable) ->
      sig
        type in_value = Fold.data
        type out_value = Fold.t
        type 'key t = 'key Fold_map.Make_sexpable(Fold).t
        type 'a _in_value = in_value
        type 'a _out_value = out_value
        type ('a, 'b) _t = 'a t
        val empty : 'a t
        val singleton : 'a -> in_value -> 'a t
        val is_empty : 'a t -> bool
        val length : 'a t -> int
        val add : key:'a -> data:in_value -> 'a t -> 'a t
        val find : 'a t -> 'a -> out_value
        val remove : 'a t -> 'a -> 'a t
        val set : key:'a -> data:out_value -> 'a t -> 'a t
        val mem : 'a t -> 'a -> bool
        val iter : 'a t -> f:(key:'a -> data:out_value -> unit) -> unit
        val fold :
          'a t -> init:'b -> f:(key:'a -> data:out_value -> 'b -> 'b) -> 'b
        val filter : 'a t -> f:(key:'a -> data:out_value -> bool) -> 'a t
        val keys : 'a t -> 'a list
        val data : 'a t -> out_value list
        val to_alist : 'a t -> ('a * out_value) list
        val of_list : ('a * in_value) list -> 'a t
        val for_all : 'a t -> f:(out_value -> bool) -> bool
        val exists : 'a t -> f:(out_value -> bool) -> bool
        val to_map : 'a t -> ('a, out_value) Core.Std.Map.Poly.t
        val of_map : ('a, out_value) Core.Std.Map.Poly.t -> 'a t
        val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
        val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      end
  module type Foldable2 =
    sig type 'a t val init : 'a t val f : 'a t -> 'a -> 'a t end
  module type S2 =
    sig
      type 'a out_value
      type ('key, 'data) t = private
          ('key, 'data out_value) Core.Std.Map.Poly.t
      type 'a _in_value = 'a
      type 'a _out_value = 'a out_value
      type ('a, 'b) _t = ('a, 'b) t
      val empty : ('a, 'b) t
      val singleton : 'a -> 'b -> ('a, 'b) t
      val is_empty : ('a, 'b) t -> bool
      val length : ('a, 'b) t -> int
      val add : key:'a -> data:'b -> ('a, 'b) t -> ('a, 'b) t
      val find : ('a, 'b) t -> 'a -> 'b out_value
      val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
      val set : key:'a -> data:'b out_value -> ('a, 'b) t -> ('a, 'b) t
      val mem : ('a, 'b) t -> 'a -> bool
      val iter :
        ('a, 'b) t -> f:(key:'a -> data:'b out_value -> unit) -> unit
      val fold :
        ('a, 'b) t ->
        init:'c -> f:(key:'a -> data:'b out_value -> 'c -> 'c) -> 'c
      val filter :
        ('a, 'b) t -> f:(key:'a -> data:'b out_value -> bool) -> ('a, 'b) t
      val keys : ('a, 'b) t -> 'a list
      val data : ('a, 'b) t -> 'b out_value list
      val to_alist : ('a, 'b) t -> ('a * 'b out_value) list
      val of_list : ('a * 'b) list -> ('a, 'b) t
      val for_all : ('a, 'b) t -> f:('b out_value -> bool) -> bool
      val exists : ('a, 'b) t -> f:('b out_value -> bool) -> bool
      val to_map : ('a, 'b) t -> ('a, 'b out_value) Core.Std.Map.Poly.t
      val of_map : ('a, 'b out_value) Core.Std.Map.Poly.t -> ('a, 'b) t
    end
  module Make2 :
    functor (Fold : Foldable2) ->
      sig
        type 'a out_value = 'a Fold.t
        type ('key, 'data) t = ('key, 'data) Fold_map.Make2(Fold).t
        type 'a _in_value = 'a
        type 'a _out_value = 'a out_value
        type ('a, 'b) _t = ('a, 'b) t
        val empty : ('a, 'b) t
        val singleton : 'a -> 'b -> ('a, 'b) t
        val is_empty : ('a, 'b) t -> bool
        val length : ('a, 'b) t -> int
        val add : key:'a -> data:'b -> ('a, 'b) t -> ('a, 'b) t
        val find : ('a, 'b) t -> 'a -> 'b out_value
        val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
        val set : key:'a -> data:'b out_value -> ('a, 'b) t -> ('a, 'b) t
        val mem : ('a, 'b) t -> 'a -> bool
        val iter :
          ('a, 'b) t -> f:(key:'a -> data:'b out_value -> unit) -> unit
        val fold :
          ('a, 'b) t ->
          init:'c -> f:(key:'a -> data:'b out_value -> 'c -> 'c) -> 'c
        val filter :
          ('a, 'b) t -> f:(key:'a -> data:'b out_value -> bool) -> ('a, 'b) t
        val keys : ('a, 'b) t -> 'a list
        val data : ('a, 'b) t -> 'b out_value list
        val to_alist : ('a, 'b) t -> ('a * 'b out_value) list
        val of_list : ('a * 'b) list -> ('a, 'b) t
        val for_all : ('a, 'b) t -> f:('b out_value -> bool) -> bool
        val exists : ('a, 'b) t -> f:('b out_value -> bool) -> bool
        val to_map : ('a, 'b) t -> ('a, 'b out_value) Core.Std.Map.Poly.t
        val of_map : ('a, 'b out_value) Core.Std.Map.Poly.t -> ('a, 'b) t
      end
  module type Foldable2_sexpable =
    sig
      type 'a t
      val init : 'a t
      val f : 'a t -> 'a -> 'a t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
    end
  module type S2_sexpable =
    sig
      type 'a out_value
      type ('key, 'data) t = private
          ('key, 'data out_value) Core.Std.Map.Poly.t
      type 'a _in_value = 'a
      type 'a _out_value = 'a out_value
      type ('a, 'b) _t = ('a, 'b) t
      val empty : ('a, 'b) t
      val singleton : 'a -> 'b -> ('a, 'b) t
      val is_empty : ('a, 'b) t -> bool
      val length : ('a, 'b) t -> int
      val add : key:'a -> data:'b -> ('a, 'b) t -> ('a, 'b) t
      val find : ('a, 'b) t -> 'a -> 'b out_value
      val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
      val set : key:'a -> data:'b out_value -> ('a, 'b) t -> ('a, 'b) t
      val mem : ('a, 'b) t -> 'a -> bool
      val iter :
        ('a, 'b) t -> f:(key:'a -> data:'b out_value -> unit) -> unit
      val fold :
        ('a, 'b) t ->
        init:'c -> f:(key:'a -> data:'b out_value -> 'c -> 'c) -> 'c
      val filter :
        ('a, 'b) t -> f:(key:'a -> data:'b out_value -> bool) -> ('a, 'b) t
      val keys : ('a, 'b) t -> 'a list
      val data : ('a, 'b) t -> 'b out_value list
      val to_alist : ('a, 'b) t -> ('a * 'b out_value) list
      val of_list : ('a * 'b) list -> ('a, 'b) t
      val for_all : ('a, 'b) t -> f:('b out_value -> bool) -> bool
      val exists : ('a, 'b) t -> f:('b out_value -> bool) -> bool
      val to_map : ('a, 'b) t -> ('a, 'b out_value) Core.Std.Map.Poly.t
      val of_map : ('a, 'b out_value) Core.Std.Map.Poly.t -> ('a, 'b) t
      val t_of_sexp :
        (Sexplib.Sexp.t -> 'a) ->
        (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) ->
        ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
    end
  module Make2_sexpable :
    functor (Fold : Foldable2_sexpable) ->
      sig
        type 'a out_value = 'a Fold.t
        type ('key, 'data) t = ('key, 'data) Fold_map.Make2_sexpable(Fold).t
        type 'a _in_value = 'a
        type 'a _out_value = 'a out_value
        type ('a, 'b) _t = ('a, 'b) t
        val empty : ('a, 'b) t
        val singleton : 'a -> 'b -> ('a, 'b) t
        val is_empty : ('a, 'b) t -> bool
        val length : ('a, 'b) t -> int
        val add : key:'a -> data:'b -> ('a, 'b) t -> ('a, 'b) t
        val find : ('a, 'b) t -> 'a -> 'b out_value
        val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
        val set : key:'a -> data:'b out_value -> ('a, 'b) t -> ('a, 'b) t
        val mem : ('a, 'b) t -> 'a -> bool
        val iter :
          ('a, 'b) t -> f:(key:'a -> data:'b out_value -> unit) -> unit
        val fold :
          ('a, 'b) t ->
          init:'c -> f:(key:'a -> data:'b out_value -> 'c -> 'c) -> 'c
        val filter :
          ('a, 'b) t -> f:(key:'a -> data:'b out_value -> bool) -> ('a, 'b) t
        val keys : ('a, 'b) t -> 'a list
        val data : ('a, 'b) t -> 'b out_value list
        val to_alist : ('a, 'b) t -> ('a * 'b out_value) list
        val of_list : ('a * 'b) list -> ('a, 'b) t
        val for_all : ('a, 'b) t -> f:('b out_value -> bool) -> bool
        val exists : ('a, 'b) t -> f:('b out_value -> bool) -> bool
        val to_map : ('a, 'b) t -> ('a, 'b out_value) Core.Std.Map.Poly.t
        val of_map : ('a, 'b out_value) Core.Std.Map.Poly.t -> ('a, 'b) t
        val t_of_sexp :
          (Sexplib.Sexp.t -> 'a) ->
          (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
        val sexp_of_t :
          ('a -> Sexplib.Sexp.t) ->
          ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
      end
  module Cons :
    sig
      type 'a out_value = 'a list
      type ('key, 'data) t = ('key, 'data) Fold_map.Cons.t
      type 'a _in_value = 'a
      type 'a _out_value = 'a out_value
      type ('a, 'b) _t = ('a, 'b) t
      val empty : ('a, 'b) t
      val singleton : 'a -> 'b -> ('a, 'b) t
      val is_empty : ('a, 'b) t -> bool
      val length : ('a, 'b) t -> int
      val add : key:'a -> data:'b -> ('a, 'b) t -> ('a, 'b) t
      val find : ('a, 'b) t -> 'a -> 'b out_value
      val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
      val set : key:'a -> data:'b out_value -> ('a, 'b) t -> ('a, 'b) t
      val mem : ('a, 'b) t -> 'a -> bool
      val iter :
        ('a, 'b) t -> f:(key:'a -> data:'b out_value -> unit) -> unit
      val fold :
        ('a, 'b) t ->
        init:'c -> f:(key:'a -> data:'b out_value -> 'c -> 'c) -> 'c
      val filter :
        ('a, 'b) t -> f:(key:'a -> data:'b out_value -> bool) -> ('a, 'b) t
      val keys : ('a, 'b) t -> 'a list
      val data : ('a, 'b) t -> 'b out_value list
      val to_alist : ('a, 'b) t -> ('a * 'b out_value) list
      val of_list : ('a * 'b) list -> ('a, 'b) t
      val for_all : ('a, 'b) t -> f:('b out_value -> bool) -> bool
      val exists : ('a, 'b) t -> f:('b out_value -> bool) -> bool
      val to_map : ('a, 'b) t -> ('a, 'b out_value) Core.Std.Map.Poly.t
      val of_map : ('a, 'b out_value) Core.Std.Map.Poly.t -> ('a, 'b) t
      val t_of_sexp :
        (Sexplib.Sexp.t -> 'a) ->
        (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) ->
        ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
    end
  module Add :
    sig
      type in_value = int
      type out_value = int
      type 'key t = 'key Fold_map.Add.t
      type 'a _in_value = in_value
      type 'a _out_value = out_value
      type ('a, 'b) _t = 'a t
      val empty : 'a t
      val singleton : 'a -> in_value -> 'a t
      val is_empty : 'a t -> bool
      val length : 'a t -> int
      val add : key:'a -> data:in_value -> 'a t -> 'a t
      val find : 'a t -> 'a -> out_value
      val remove : 'a t -> 'a -> 'a t
      val set : key:'a -> data:out_value -> 'a t -> 'a t
      val mem : 'a t -> 'a -> bool
      val iter : 'a t -> f:(key:'a -> data:out_value -> unit) -> unit
      val fold :
        'a t -> init:'b -> f:(key:'a -> data:out_value -> 'b -> 'b) -> 'b
      val filter : 'a t -> f:(key:'a -> data:out_value -> bool) -> 'a t
      val keys : 'a t -> 'a list
      val data : 'a t -> out_value list
      val to_alist : 'a t -> ('a * out_value) list
      val of_list : ('a * in_value) list -> 'a t
      val for_all : 'a t -> f:(out_value -> bool) -> bool
      val exists : 'a t -> f:(out_value -> bool) -> bool
      val to_map : 'a t -> ('a, out_value) Core.Std.Map.Poly.t
      val of_map : ('a, out_value) Core.Std.Map.Poly.t -> 'a t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
    end
  module Multiply :
    sig
      type in_value = int
      type out_value = int
      type 'key t = 'key Fold_map.Multiply.t
      type 'a _in_value = in_value
      type 'a _out_value = out_value
      type ('a, 'b) _t = 'a t
      val empty : 'a t
      val singleton : 'a -> in_value -> 'a t
      val is_empty : 'a t -> bool
      val length : 'a t -> int
      val add : key:'a -> data:in_value -> 'a t -> 'a t
      val find : 'a t -> 'a -> out_value
      val remove : 'a t -> 'a -> 'a t
      val set : key:'a -> data:out_value -> 'a t -> 'a t
      val mem : 'a t -> 'a -> bool
      val iter : 'a t -> f:(key:'a -> data:out_value -> unit) -> unit
      val fold :
        'a t -> init:'b -> f:(key:'a -> data:out_value -> 'b -> 'b) -> 'b
      val filter : 'a t -> f:(key:'a -> data:out_value -> bool) -> 'a t
      val keys : 'a t -> 'a list
      val data : 'a t -> out_value list
      val to_alist : 'a t -> ('a * out_value) list
      val of_list : ('a * in_value) list -> 'a t
      val for_all : 'a t -> f:(out_value -> bool) -> bool
      val exists : 'a t -> f:(out_value -> bool) -> bool
      val to_map : 'a t -> ('a, out_value) Core.Std.Map.Poly.t
      val of_map : ('a, out_value) Core.Std.Map.Poly.t -> 'a t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
    end
end