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