sig
  module type Fold =
    sig
      type t
      type data
      val init : Fold_map.Fold.t
      val f : Fold_map.Fold.t -> Fold_map.Fold.data -> Fold_map.Fold.t
    end
  module type Fold_sexpable =
    sig
      type t
      type data
      val init : t
      val f : t -> data -> t
      type sexpable = t
      val sexp_of_t : sexpable -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> sexpable
    end
  module Cons :
    functor (T : sig type t end->
      sig
        type t = T.t list
        type data = T.t
        val init : t
        val f : t -> data -> t
      end
  module Cons_sexpable :
    functor (T : Core.Std.Sexpable->
      sig
        type t = T.sexpable list
        type data = T.sexpable
        val init : t
        val f : t -> data -> t
        type sexpable = t
        val sexp_of_t : sexpable -> Sexplib.Sexp.t
        val t_of_sexp : Sexplib.Sexp.t -> sexpable
      end
  module Multiply :
    sig
      type t = int
      type data = int
      val init : t
      val f : t -> data -> t
      type sexpable = t
      val sexp_of_t : sexpable -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> sexpable
    end
  module Add :
    sig
      type t = int
      type data = int
      val init : t
      val f : t -> data -> t
      type sexpable = t
      val sexp_of_t : sexpable -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> sexpable
    end
  module type Fold_map =
    sig
      type in_value
      type out_value
      type 'a t
      val empty : 'Fold_map.Fold_map.t
      val singleton :
        '-> Fold_map.Fold_map.in_value -> 'Fold_map.Fold_map.t
      val is_empty : 'Fold_map.Fold_map.t -> bool
      val cardinal : 'Fold_map.Fold_map.t -> int
      val add :
        key:'->
        data:Fold_map.Fold_map.in_value ->
        'Fold_map.Fold_map.t -> 'Fold_map.Fold_map.t
      val find : 'Fold_map.Fold_map.t -> '-> Fold_map.Fold_map.out_value
      val remove : 'Fold_map.Fold_map.t -> '-> 'Fold_map.Fold_map.t
      val set :
        key:'->
        data:Fold_map.Fold_map.out_value ->
        'Fold_map.Fold_map.t -> 'Fold_map.Fold_map.t
      val mem : 'Fold_map.Fold_map.t -> '-> bool
      val iter :
        f:(key:'-> data:Fold_map.Fold_map.out_value -> unit) ->
        'Fold_map.Fold_map.t -> unit
      val fold :
        f:(key:'-> data:Fold_map.Fold_map.out_value -> '-> 'b) ->
        'Fold_map.Fold_map.t -> init:'-> 'b
      val filter :
        f:(key:'-> data:Fold_map.Fold_map.out_value -> bool) ->
        'Fold_map.Fold_map.t -> 'Fold_map.Fold_map.t
      val keys : 'Fold_map.Fold_map.t -> 'a list
      val data : 'Fold_map.Fold_map.t -> Fold_map.Fold_map.out_value list
      val to_alist :
        'Fold_map.Fold_map.t -> ('a * Fold_map.Fold_map.out_value) list
      val of_list :
        ('a * Fold_map.Fold_map.in_value) list -> 'Fold_map.Fold_map.t
      val for_all :
        f:(Fold_map.Fold_map.out_value -> bool) ->
        'Fold_map.Fold_map.t -> bool
      val exists :
        f:(Fold_map.Fold_map.out_value -> bool) ->
        'Fold_map.Fold_map.t -> bool
      val to_map :
        'Fold_map.Fold_map.t ->
        ('a, Fold_map.Fold_map.out_value) Core.Std.Map.t
      val of_map :
        ('a, Fold_map.Fold_map.out_value) Core.Std.Map.t ->
        'Fold_map.Fold_map.t
    end
  module type Fold_map_sexpable =
    sig
      type in_value
      type out_value
      type 'a t
      val empty : 'a t
      val singleton : '-> in_value -> 'a t
      val is_empty : 'a t -> bool
      val cardinal : 'a t -> int
      val add : key:'-> data:in_value -> 'a t -> 'a t
      val find : 'a t -> '-> out_value
      val remove : 'a t -> '-> 'a t
      val set : key:'-> data:out_value -> 'a t -> 'a t
      val mem : 'a t -> '-> bool
      val iter : f:(key:'-> data:out_value -> unit) -> 'a t -> unit
      val fold :
        f:(key:'-> data:out_value -> '-> 'b) -> 'a t -> init:'-> 'b
      val filter : f:(key:'-> data:out_value -> bool) -> 'a t -> '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 : f:(out_value -> bool) -> 'a t -> bool
      val exists : f:(out_value -> bool) -> 'a t -> bool
      val to_map : 'a t -> ('a, out_value) Core.Std.Map.t
      val of_map : ('a, out_value) Core.Std.Map.t -> 'a t
      type 'a sexpable = 'a t
      val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a sexpable -> Sexplib.Sexp.t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a sexpable
    end
  module Make :
    functor (Fold : Fold->
      sig
        type in_value = Fold.data
        type out_value = Fold.t
        type 'a t
        val empty : 'a t
        val singleton : '-> in_value -> 'a t
        val is_empty : 'a t -> bool
        val cardinal : 'a t -> int
        val add : key:'-> data:in_value -> 'a t -> 'a t
        val find : 'a t -> '-> out_value
        val remove : 'a t -> '-> 'a t
        val set : key:'-> data:out_value -> 'a t -> 'a t
        val mem : 'a t -> '-> bool
        val iter : f:(key:'-> data:out_value -> unit) -> 'a t -> unit
        val fold :
          f:(key:'-> data:out_value -> '-> 'b) -> 'a t -> init:'-> 'b
        val filter : f:(key:'-> data:out_value -> bool) -> 'a t -> '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 : f:(out_value -> bool) -> 'a t -> bool
        val exists : f:(out_value -> bool) -> 'a t -> bool
        val to_map : 'a t -> ('a, out_value) Core.Std.Map.t
        val of_map : ('a, out_value) Core.Std.Map.t -> 'a t
      end
  module Make_sexpable :
    functor (Fold_sexpable : Fold_sexpable->
      sig
        type in_value = Fold_sexpable.data
        type out_value = Fold_sexpable.t
        type 'a t
        val empty : 'a t
        val singleton : '-> in_value -> 'a t
        val is_empty : 'a t -> bool
        val cardinal : 'a t -> int
        val add : key:'-> data:in_value -> 'a t -> 'a t
        val find : 'a t -> '-> out_value
        val remove : 'a t -> '-> 'a t
        val set : key:'-> data:out_value -> 'a t -> 'a t
        val mem : 'a t -> '-> bool
        val iter : f:(key:'-> data:out_value -> unit) -> 'a t -> unit
        val fold :
          f:(key:'-> data:out_value -> '-> 'b) -> 'a t -> init:'-> 'b
        val filter : f:(key:'-> data:out_value -> bool) -> 'a t -> '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 : f:(out_value -> bool) -> 'a t -> bool
        val exists : f:(out_value -> bool) -> 'a t -> bool
        val to_map : 'a t -> ('a, out_value) Core.Std.Map.t
        val of_map : ('a, out_value) Core.Std.Map.t -> 'a t
        type 'a sexpable = 'a t
        val sexp_of_t :
          ('-> Sexplib.Sexp.t) -> 'a sexpable -> Sexplib.Sexp.t
        val t_of_sexp :
          (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a sexpable
      end
end