Proto/Env: rename Set.S and Map.S into S.SET and S.MAP.
This commit is contained in:
Grégoire Henry
Benjamin Canou
parent
fc1ea36a62
commit
48cc2e9928
@ -32,6 +32,86 @@ module type HASHABLE = sig
|
||||
|
||||
end
|
||||
|
||||
module type SET = sig
|
||||
type elt
|
||||
type t
|
||||
val empty: t
|
||||
val is_empty: t -> bool
|
||||
val mem: elt -> t -> bool
|
||||
val add: elt -> t -> t
|
||||
val singleton: elt -> t
|
||||
val remove: elt -> t -> t
|
||||
val union: t -> t -> t
|
||||
val inter: t -> t -> t
|
||||
val diff: t -> t -> t
|
||||
val compare: t -> t -> int
|
||||
val equal: t -> t -> bool
|
||||
val subset: t -> t -> bool
|
||||
val iter: (elt -> unit) -> t -> unit
|
||||
val map: (elt -> elt) -> t -> t
|
||||
val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a
|
||||
val for_all: (elt -> bool) -> t -> bool
|
||||
val exists: (elt -> bool) -> t -> bool
|
||||
val filter: (elt -> bool) -> t -> t
|
||||
val partition: (elt -> bool) -> t -> t * t
|
||||
val cardinal: t -> int
|
||||
val elements: t -> elt list
|
||||
val min_elt: t -> elt
|
||||
val min_elt_opt: t -> elt option
|
||||
val max_elt: t -> elt
|
||||
val max_elt_opt: t -> elt option
|
||||
val choose: t -> elt
|
||||
val choose_opt: t -> elt option
|
||||
val split: elt -> t -> t * bool * t
|
||||
val find: elt -> t -> elt
|
||||
val find_opt: elt -> t -> elt option
|
||||
val find_first: (elt -> bool) -> t -> elt
|
||||
val find_first_opt: (elt -> bool) -> t -> elt option
|
||||
val find_last: (elt -> bool) -> t -> elt
|
||||
val find_last_opt: (elt -> bool) -> t -> elt option
|
||||
val of_list: elt list -> t
|
||||
end
|
||||
|
||||
module type MAP = sig
|
||||
type key
|
||||
type (+'a) t
|
||||
val empty: 'a t
|
||||
val is_empty: 'a t -> bool
|
||||
val mem: key -> 'a t -> bool
|
||||
val add: key -> 'a -> 'a t -> 'a t
|
||||
val update: key -> ('a option -> 'a option) -> 'a t -> 'a t
|
||||
val singleton: key -> 'a -> 'a t
|
||||
val remove: key -> 'a t -> 'a t
|
||||
val merge:
|
||||
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
|
||||
val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
|
||||
val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
|
||||
val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
|
||||
val iter: (key -> 'a -> unit) -> 'a t -> unit
|
||||
val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
|
||||
val for_all: (key -> 'a -> bool) -> 'a t -> bool
|
||||
val exists: (key -> 'a -> bool) -> 'a t -> bool
|
||||
val filter: (key -> 'a -> bool) -> 'a t -> 'a t
|
||||
val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
|
||||
val cardinal: 'a t -> int
|
||||
val bindings: 'a t -> (key * 'a) list
|
||||
val min_binding: 'a t -> (key * 'a)
|
||||
val min_binding_opt: 'a t -> (key * 'a) option
|
||||
val max_binding: 'a t -> (key * 'a)
|
||||
val max_binding_opt: 'a t -> (key * 'a) option
|
||||
val choose: 'a t -> (key * 'a)
|
||||
val choose_opt: 'a t -> (key * 'a) option
|
||||
val split: key -> 'a t -> 'a t * 'a option * 'a t
|
||||
val find: key -> 'a t -> 'a
|
||||
val find_opt: key -> 'a t -> 'a option
|
||||
val find_first: (key -> bool) -> 'a t -> key * 'a
|
||||
val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option
|
||||
val find_last: (key -> bool) -> 'a t -> key * 'a
|
||||
val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option
|
||||
val map: ('a -> 'b) -> 'a t -> 'b t
|
||||
val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
|
||||
end
|
||||
|
||||
module type MINIMAL_HASH = Tezos_crypto.S.MINIMAL_HASH
|
||||
|
||||
module type HASH = sig
|
||||
@ -54,12 +134,12 @@ module type HASH = sig
|
||||
val rpc_arg: t RPC_arg.t
|
||||
|
||||
module Set : sig
|
||||
include Set.S with type elt = t
|
||||
include SET with type elt = t
|
||||
val encoding: t Data_encoding.t
|
||||
end
|
||||
|
||||
module Map : sig
|
||||
include Map.S with type key = t
|
||||
include MAP with type key = t
|
||||
val encoding: 'a Data_encoding.t -> 'a t Data_encoding.t
|
||||
end
|
||||
|
||||
|
||||
@ -9,8 +9,6 @@
|
||||
v1/array.mli
|
||||
v1/list.mli
|
||||
v1/string.mli
|
||||
v1/set.mli
|
||||
v1/map.mli
|
||||
v1/int32.mli
|
||||
v1/int64.mli
|
||||
v1/format.mli
|
||||
@ -38,6 +36,8 @@
|
||||
|
||||
v1/base58.mli
|
||||
v1/s.mli
|
||||
v1/set.mli
|
||||
v1/map.mli
|
||||
v1/blake2B.mli
|
||||
v1/ed25519.mli
|
||||
v1/block_hash.mli
|
||||
|
||||
@ -59,248 +59,6 @@ sig
|
||||
end
|
||||
(** Input signature of the functor {!Map.Make}. *)
|
||||
|
||||
module type S =
|
||||
sig
|
||||
type key
|
||||
(** The type of the map keys. *)
|
||||
|
||||
type (+'a) t
|
||||
(** The type of maps from type [key] to type ['a]. *)
|
||||
|
||||
val empty: 'a t
|
||||
(** The empty map. *)
|
||||
|
||||
val is_empty: 'a t -> bool
|
||||
(** Test whether a map is empty or not. *)
|
||||
|
||||
val mem: key -> 'a t -> bool
|
||||
(** [mem x m] returns [true] if [m] contains a binding for [x],
|
||||
and [false] otherwise. *)
|
||||
|
||||
val add: key -> 'a -> 'a t -> 'a t
|
||||
(** [add x y m] returns a map containing the same bindings as
|
||||
[m], plus a binding of [x] to [y]. If [x] was already bound
|
||||
in [m] to a value that is physically equal to [y],
|
||||
[m] is returned unchanged (the result of the function is
|
||||
then physically equal to [m]). Otherwise, the previous binding
|
||||
of [x] in [m] disappears.
|
||||
@before 4.03 Physical equality was not ensured. *)
|
||||
|
||||
val update: key -> ('a option -> 'a option) -> 'a t -> 'a t
|
||||
(** [update x f m] returns a map containing the same bindings as
|
||||
[m], except for the binding of [x]. Depending on the value of
|
||||
[y] where [y] is [f (find_opt x m)], the binding of [x] is
|
||||
added, removed or updated. If [y] is [None], the binding is
|
||||
removed if it exists; otherwise, if [y] is [Some z] then [x]
|
||||
is associated to [z] in the resulting map. If [x] was already
|
||||
bound in [m] to a value that is physically equal to [z], [m]
|
||||
is returned unchanged (the result of the function is then
|
||||
physically equal to [m]).
|
||||
@since 4.06.0
|
||||
*)
|
||||
|
||||
val singleton: key -> 'a -> 'a t
|
||||
(** [singleton x y] returns the one-element map that contains a binding [y]
|
||||
for [x].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val remove: key -> 'a t -> 'a t
|
||||
(** [remove x m] returns a map containing the same bindings as
|
||||
[m], except for [x] which is unbound in the returned map.
|
||||
If [x] was not in [m], [m] is returned unchanged
|
||||
(the result of the function is then physically equal to [m]).
|
||||
@before 4.03 Physical equality was not ensured. *)
|
||||
|
||||
val merge:
|
||||
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
|
||||
(** [merge f m1 m2] computes a map whose keys is a subset of keys of [m1]
|
||||
and of [m2]. The presence of each such binding, and the corresponding
|
||||
value, is determined with the function [f].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
|
||||
(** [union f m1 m2] computes a map whose keys is the union of keys
|
||||
of [m1] and of [m2]. When the same binding is defined in both
|
||||
arguments, the function [f] is used to combine them.
|
||||
@since 4.03.0
|
||||
*)
|
||||
|
||||
val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
|
||||
(** Total ordering between maps. The first argument is a total ordering
|
||||
used to compare data associated with equal keys in the two maps. *)
|
||||
|
||||
val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
|
||||
(** [equal cmp m1 m2] tests whether the maps [m1] and [m2] are
|
||||
equal, that is, contain equal keys and associate them with
|
||||
equal data. [cmp] is the equality predicate used to compare
|
||||
the data associated with the keys. *)
|
||||
|
||||
val iter: (key -> 'a -> unit) -> 'a t -> unit
|
||||
(** [iter f m] applies [f] to all bindings in map [m].
|
||||
[f] receives the key as first argument, and the associated value
|
||||
as second argument. The bindings are passed to [f] in increasing
|
||||
order with respect to the ordering over the type of the keys. *)
|
||||
|
||||
val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
|
||||
(** [fold f m a] computes [(f kN dN ... (f k1 d1 a)...)],
|
||||
where [k1 ... kN] are the keys of all bindings in [m]
|
||||
(in increasing order), and [d1 ... dN] are the associated data. *)
|
||||
|
||||
val for_all: (key -> 'a -> bool) -> 'a t -> bool
|
||||
(** [for_all p m] checks if all the bindings of the map
|
||||
satisfy the predicate [p].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val exists: (key -> 'a -> bool) -> 'a t -> bool
|
||||
(** [exists p m] checks if at least one binding of the map
|
||||
satisfy the predicate [p].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val filter: (key -> 'a -> bool) -> 'a t -> 'a t
|
||||
(** [filter p m] returns the map with all the bindings in [m]
|
||||
that satisfy predicate [p]. If [p] satisfies every binding in [m],
|
||||
[m] is returned unchanged (the result of the function is then
|
||||
physically equal to [m])
|
||||
@since 3.12.0
|
||||
@before 4.03 Physical equality was not ensured.
|
||||
*)
|
||||
|
||||
val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
|
||||
(** [partition p m] returns a pair of maps [(m1, m2)], where
|
||||
[m1] contains all the bindings of [s] that satisfy the
|
||||
predicate [p], and [m2] is the map with all the bindings of
|
||||
[s] that do not satisfy [p].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val cardinal: 'a t -> int
|
||||
(** Return the number of bindings of a map.
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val bindings: 'a t -> (key * 'a) list
|
||||
(** Return the list of all bindings of the given map.
|
||||
The returned list is sorted in increasing order with respect
|
||||
to the ordering [Ord.compare], where [Ord] is the argument
|
||||
given to {!Map.Make}.
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val min_binding: 'a t -> (key * 'a)
|
||||
(** Return the smallest binding of the given map
|
||||
(with respect to the [Ord.compare] ordering), or raise
|
||||
[Not_found] if the map is empty.
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val min_binding_opt: 'a t -> (key * 'a) option
|
||||
(** Return the smallest binding of the given map
|
||||
(with respect to the [Ord.compare] ordering), or [None]
|
||||
if the map is empty.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val max_binding: 'a t -> (key * 'a)
|
||||
(** Same as {!Map.S.min_binding}, but returns the largest binding
|
||||
of the given map.
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val max_binding_opt: 'a t -> (key * 'a) option
|
||||
(** Same as {!Map.S.min_binding_opt}, but returns the largest binding
|
||||
of the given map.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val choose: 'a t -> (key * 'a)
|
||||
(** Return one binding of the given map, or raise [Not_found] if
|
||||
the map is empty. Which binding is chosen is unspecified,
|
||||
but equal bindings will be chosen for equal maps.
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val choose_opt: 'a t -> (key * 'a) option
|
||||
(** Return one binding of the given map, or [None] if
|
||||
the map is empty. Which binding is chosen is unspecified,
|
||||
but equal bindings will be chosen for equal maps.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val split: key -> 'a t -> 'a t * 'a option * 'a t
|
||||
(** [split x m] returns a triple [(l, data, r)], where
|
||||
[l] is the map with all the bindings of [m] whose key
|
||||
is strictly less than [x];
|
||||
[r] is the map with all the bindings of [m] whose key
|
||||
is strictly greater than [x];
|
||||
[data] is [None] if [m] contains no binding for [x],
|
||||
or [Some v] if [m] binds [v] to [x].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
val find: key -> 'a t -> 'a
|
||||
(** [find x m] returns the current binding of [x] in [m],
|
||||
or raises [Not_found] if no such binding exists. *)
|
||||
|
||||
|
||||
val find_opt: key -> 'a t -> 'a option
|
||||
(** [find_opt x m] returns [Some v] if the current binding of [x]
|
||||
in [m] is [v], or [None] if no such binding exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_first: (key -> bool) -> 'a t -> key * 'a
|
||||
(** [find_first f m], where [f] is a monotonically increasing function,
|
||||
returns the binding of [m] with the lowest key [k] such that [f k],
|
||||
or raises [Not_found] if no such key exists.
|
||||
|
||||
For example, [find_first (fun k -> Ord.compare k x >= 0) m] will return
|
||||
the first binding [k, v] of [m] where [Ord.compare k x >= 0]
|
||||
(intuitively: [k >= x]), or raise [Not_found] if [x] is greater than any
|
||||
element of [m].
|
||||
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option
|
||||
(** [find_first_opt f m], where [f] is a monotonically increasing function,
|
||||
returns an option containing the binding of [m] with the lowest key [k]
|
||||
such that [f k], or [None] if no such key exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_last: (key -> bool) -> 'a t -> key * 'a
|
||||
(** [find_last f m], where [f] is a monotonically decreasing function,
|
||||
returns the binding of [m] with the highest key [k] such that [f k],
|
||||
or raises [Not_found] if no such key exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option
|
||||
(** [find_last_opt f m], where [f] is a monotonically decreasing function,
|
||||
returns an option containing the binding of [m] with the highest key [k]
|
||||
such that [f k], or [None] if no such key exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val map: ('a -> 'b) -> 'a t -> 'b t
|
||||
(** [map f m] returns a map with same domain as [m], where the
|
||||
associated value [a] of all bindings of [m] has been
|
||||
replaced by the result of the application of [f] to [a].
|
||||
The bindings are passed to [f] in increasing order
|
||||
with respect to the ordering over the type of the keys. *)
|
||||
|
||||
val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
|
||||
(** Same as {!Map.S.map}, but the function receives as arguments both the
|
||||
key and the associated value for each binding of the map. *)
|
||||
|
||||
|
||||
end
|
||||
(** Output signature of the functor {!Map.Make}. *)
|
||||
|
||||
module Make (Ord : OrderedType) : S with type key = Ord.t
|
||||
module Make (Ord : OrderedType) : S.MAP with type key = Ord.t
|
||||
(** Functor building an implementation of the map structure
|
||||
given a totally ordered type. *)
|
||||
|
||||
@ -81,6 +81,86 @@ module type MINIMAL_HASH = sig
|
||||
|
||||
end
|
||||
|
||||
module type SET = sig
|
||||
type elt
|
||||
type t
|
||||
val empty: t
|
||||
val is_empty: t -> bool
|
||||
val mem: elt -> t -> bool
|
||||
val add: elt -> t -> t
|
||||
val singleton: elt -> t
|
||||
val remove: elt -> t -> t
|
||||
val union: t -> t -> t
|
||||
val inter: t -> t -> t
|
||||
val diff: t -> t -> t
|
||||
val compare: t -> t -> int
|
||||
val equal: t -> t -> bool
|
||||
val subset: t -> t -> bool
|
||||
val iter: (elt -> unit) -> t -> unit
|
||||
val map: (elt -> elt) -> t -> t
|
||||
val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a
|
||||
val for_all: (elt -> bool) -> t -> bool
|
||||
val exists: (elt -> bool) -> t -> bool
|
||||
val filter: (elt -> bool) -> t -> t
|
||||
val partition: (elt -> bool) -> t -> t * t
|
||||
val cardinal: t -> int
|
||||
val elements: t -> elt list
|
||||
val min_elt: t -> elt
|
||||
val min_elt_opt: t -> elt option
|
||||
val max_elt: t -> elt
|
||||
val max_elt_opt: t -> elt option
|
||||
val choose: t -> elt
|
||||
val choose_opt: t -> elt option
|
||||
val split: elt -> t -> t * bool * t
|
||||
val find: elt -> t -> elt
|
||||
val find_opt: elt -> t -> elt option
|
||||
val find_first: (elt -> bool) -> t -> elt
|
||||
val find_first_opt: (elt -> bool) -> t -> elt option
|
||||
val find_last: (elt -> bool) -> t -> elt
|
||||
val find_last_opt: (elt -> bool) -> t -> elt option
|
||||
val of_list: elt list -> t
|
||||
end
|
||||
|
||||
module type MAP = sig
|
||||
type key
|
||||
type (+'a) t
|
||||
val empty: 'a t
|
||||
val is_empty: 'a t -> bool
|
||||
val mem: key -> 'a t -> bool
|
||||
val add: key -> 'a -> 'a t -> 'a t
|
||||
val update: key -> ('a option -> 'a option) -> 'a t -> 'a t
|
||||
val singleton: key -> 'a -> 'a t
|
||||
val remove: key -> 'a t -> 'a t
|
||||
val merge:
|
||||
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
|
||||
val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
|
||||
val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
|
||||
val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
|
||||
val iter: (key -> 'a -> unit) -> 'a t -> unit
|
||||
val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
|
||||
val for_all: (key -> 'a -> bool) -> 'a t -> bool
|
||||
val exists: (key -> 'a -> bool) -> 'a t -> bool
|
||||
val filter: (key -> 'a -> bool) -> 'a t -> 'a t
|
||||
val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
|
||||
val cardinal: 'a t -> int
|
||||
val bindings: 'a t -> (key * 'a) list
|
||||
val min_binding: 'a t -> (key * 'a)
|
||||
val min_binding_opt: 'a t -> (key * 'a) option
|
||||
val max_binding: 'a t -> (key * 'a)
|
||||
val max_binding_opt: 'a t -> (key * 'a) option
|
||||
val choose: 'a t -> (key * 'a)
|
||||
val choose_opt: 'a t -> (key * 'a) option
|
||||
val split: key -> 'a t -> 'a t * 'a option * 'a t
|
||||
val find: key -> 'a t -> 'a
|
||||
val find_opt: key -> 'a t -> 'a option
|
||||
val find_first: (key -> bool) -> 'a t -> key * 'a
|
||||
val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option
|
||||
val find_last: (key -> bool) -> 'a t -> key * 'a
|
||||
val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option
|
||||
val map: ('a -> 'b) -> 'a t -> 'b t
|
||||
val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
|
||||
end
|
||||
|
||||
module type HASH = sig
|
||||
|
||||
include MINIMAL_HASH
|
||||
@ -101,12 +181,12 @@ module type HASH = sig
|
||||
val rpc_arg: t RPC_arg.t
|
||||
|
||||
module Set : sig
|
||||
include Set.S with type elt = t
|
||||
include SET with type elt = t
|
||||
val encoding: t Data_encoding.t
|
||||
end
|
||||
|
||||
module Map : sig
|
||||
include Map.S with type key = t
|
||||
include MAP with type key = t
|
||||
val encoding: 'a Data_encoding.t -> 'a t Data_encoding.t
|
||||
end
|
||||
|
||||
|
||||
@ -60,206 +60,6 @@ sig
|
||||
end
|
||||
(** Input signature of the functor {!Set.Make}. *)
|
||||
|
||||
module type S =
|
||||
sig
|
||||
type elt
|
||||
(** The type of the set elements. *)
|
||||
|
||||
type t
|
||||
(** The type of sets. *)
|
||||
|
||||
val empty: t
|
||||
(** The empty set. *)
|
||||
|
||||
val is_empty: t -> bool
|
||||
(** Test whether a set is empty or not. *)
|
||||
|
||||
val mem: elt -> t -> bool
|
||||
(** [mem x s] tests whether [x] belongs to the set [s]. *)
|
||||
|
||||
val add: elt -> t -> t
|
||||
(** [add x s] returns a set containing all elements of [s],
|
||||
plus [x]. If [x] was already in [s], [s] is returned unchanged
|
||||
(the result of the function is then physically equal to [s]).
|
||||
@before 4.03 Physical equality was not ensured. *)
|
||||
|
||||
val singleton: elt -> t
|
||||
(** [singleton x] returns the one-element set containing only [x]. *)
|
||||
|
||||
val remove: elt -> t -> t
|
||||
(** [remove x s] returns a set containing all elements of [s],
|
||||
except [x]. If [x] was not in [s], [s] is returned unchanged
|
||||
(the result of the function is then physically equal to [s]).
|
||||
@before 4.03 Physical equality was not ensured. *)
|
||||
|
||||
val union: t -> t -> t
|
||||
(** Set union. *)
|
||||
|
||||
val inter: t -> t -> t
|
||||
(** Set intersection. *)
|
||||
|
||||
val diff: t -> t -> t
|
||||
(** Set difference. *)
|
||||
|
||||
val compare: t -> t -> int
|
||||
(** Total ordering between sets. Can be used as the ordering function
|
||||
for doing sets of sets. *)
|
||||
|
||||
val equal: t -> t -> bool
|
||||
(** [equal s1 s2] tests whether the sets [s1] and [s2] are
|
||||
equal, that is, contain equal elements. *)
|
||||
|
||||
val subset: t -> t -> bool
|
||||
(** [subset s1 s2] tests whether the set [s1] is a subset of
|
||||
the set [s2]. *)
|
||||
|
||||
val iter: (elt -> unit) -> t -> unit
|
||||
(** [iter f s] applies [f] in turn to all elements of [s].
|
||||
The elements of [s] are presented to [f] in increasing order
|
||||
with respect to the ordering over the type of the elements. *)
|
||||
|
||||
val map: (elt -> elt) -> t -> t
|
||||
(** [map f s] is the set whose elements are [f a0],[f a1]... [f
|
||||
aN], where [a0],[a1]...[aN] are the elements of [s].
|
||||
|
||||
The elements are passed to [f] in increasing order
|
||||
with respect to the ordering over the type of the elements.
|
||||
|
||||
If no element of [s] is changed by [f], [s] is returned
|
||||
unchanged. (If each output of [f] is physically equal to its
|
||||
input, the returned set is physically equal to [s].) *)
|
||||
|
||||
val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a
|
||||
(** [fold f s a] computes [(f xN ... (f x2 (f x1 a))...)],
|
||||
where [x1 ... xN] are the elements of [s], in increasing order. *)
|
||||
|
||||
val for_all: (elt -> bool) -> t -> bool
|
||||
(** [for_all p s] checks if all elements of the set
|
||||
satisfy the predicate [p]. *)
|
||||
|
||||
val exists: (elt -> bool) -> t -> bool
|
||||
(** [exists p s] checks if at least one element of
|
||||
the set satisfies the predicate [p]. *)
|
||||
|
||||
val filter: (elt -> bool) -> t -> t
|
||||
(** [filter p s] returns the set of all elements in [s]
|
||||
that satisfy predicate [p]. If [p] satisfies every element in [s],
|
||||
[s] is returned unchanged (the result of the function is then
|
||||
physically equal to [s]).
|
||||
@before 4.03 Physical equality was not ensured.*)
|
||||
|
||||
val partition: (elt -> bool) -> t -> t * t
|
||||
(** [partition p s] returns a pair of sets [(s1, s2)], where
|
||||
[s1] is the set of all the elements of [s] that satisfy the
|
||||
predicate [p], and [s2] is the set of all the elements of
|
||||
[s] that do not satisfy [p]. *)
|
||||
|
||||
val cardinal: t -> int
|
||||
(** Return the number of elements of a set. *)
|
||||
|
||||
val elements: t -> elt list
|
||||
(** Return the list of all elements of the given set.
|
||||
The returned list is sorted in increasing order with respect
|
||||
to the ordering [Ord.compare], where [Ord] is the argument
|
||||
given to {!Set.Make}. *)
|
||||
|
||||
val min_elt: t -> elt
|
||||
(** Return the smallest element of the given set
|
||||
(with respect to the [Ord.compare] ordering), or raise
|
||||
[Not_found] if the set is empty. *)
|
||||
|
||||
val min_elt_opt: t -> elt option
|
||||
(** Return the smallest element of the given set
|
||||
(with respect to the [Ord.compare] ordering), or [None]
|
||||
if the set is empty.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val max_elt: t -> elt
|
||||
(** Same as {!Set.S.min_elt}, but returns the largest element of the
|
||||
given set. *)
|
||||
|
||||
val max_elt_opt: t -> elt option
|
||||
(** Same as {!Set.S.min_elt_opt}, but returns the largest element of the
|
||||
given set.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val choose: t -> elt
|
||||
(** Return one element of the given set, or raise [Not_found] if
|
||||
the set is empty. Which element is chosen is unspecified,
|
||||
but equal elements will be chosen for equal sets. *)
|
||||
|
||||
val choose_opt: t -> elt option
|
||||
(** Return one element of the given set, or [None] if
|
||||
the set is empty. Which element is chosen is unspecified,
|
||||
but equal elements will be chosen for equal sets.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val split: elt -> t -> t * bool * t
|
||||
(** [split x s] returns a triple [(l, present, r)], where
|
||||
[l] is the set of elements of [s] that are
|
||||
strictly less than [x];
|
||||
[r] is the set of elements of [s] that are
|
||||
strictly greater than [x];
|
||||
[present] is [false] if [s] contains no element equal to [x],
|
||||
or [true] if [s] contains an element equal to [x]. *)
|
||||
|
||||
val find: elt -> t -> elt
|
||||
(** [find x s] returns the element of [s] equal to [x] (according
|
||||
to [Ord.compare]), or raise [Not_found] if no such element
|
||||
exists.
|
||||
@since 4.01.0 *)
|
||||
|
||||
val find_opt: elt -> t -> elt option
|
||||
(** [find_opt x s] returns the element of [s] equal to [x] (according
|
||||
to [Ord.compare]), or [None] if no such element
|
||||
exists.
|
||||
@since 4.05 *)
|
||||
|
||||
val find_first: (elt -> bool) -> t -> elt
|
||||
(** [find_first f s], where [f] is a monotonically increasing function,
|
||||
returns the lowest element [e] of [s] such that [f e],
|
||||
or raises [Not_found] if no such element exists.
|
||||
|
||||
For example, [find_first (fun e -> Ord.compare e x >= 0) s] will return
|
||||
the first element [e] of [s] where [Ord.compare e x >= 0] (intuitively:
|
||||
[e >= x]), or raise [Not_found] if [x] is greater than any element of
|
||||
[s].
|
||||
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_first_opt: (elt -> bool) -> t -> elt option
|
||||
(** [find_first_opt f s], where [f] is a monotonically increasing function,
|
||||
returns an option containing the lowest element [e] of [s] such that
|
||||
[f e], or [None] if no such element exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_last: (elt -> bool) -> t -> elt
|
||||
(** [find_last f s], where [f] is a monotonically decreasing function,
|
||||
returns the highest element [e] of [s] such that [f e],
|
||||
or raises [Not_found] if no such element exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val find_last_opt: (elt -> bool) -> t -> elt option
|
||||
(** [find_last_opt f s], where [f] is a monotonically decreasing function,
|
||||
returns an option containing the highest element [e] of [s] such that
|
||||
[f e], or [None] if no such element exists.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val of_list: elt list -> t
|
||||
(** [of_list l] creates a set from a list of elements.
|
||||
This is usually more efficient than folding [add] over the list,
|
||||
except perhaps for lists with many duplicated elements.
|
||||
@since 4.02.0 *)
|
||||
end
|
||||
(** Output signature of the functor {!Set.Make}. *)
|
||||
|
||||
module Make (Ord : OrderedType) : S with type elt = Ord.t
|
||||
module Make (Ord : OrderedType) : S.SET with type elt = Ord.t
|
||||
(** Functor building an implementation of the set structure
|
||||
given a totally ordered type. *)
|
||||
|
||||
@ -24,7 +24,7 @@ type 'ty comparable_ty =
|
||||
|
||||
module type Boxed_set = sig
|
||||
type elt
|
||||
module OPS : Set.S with type elt = elt
|
||||
module OPS : S.SET with type elt = elt
|
||||
val boxed : OPS.t
|
||||
val size : int
|
||||
end
|
||||
@ -35,7 +35,7 @@ module type Boxed_map = sig
|
||||
type key
|
||||
type value
|
||||
val key_ty : key comparable_ty
|
||||
module OPS : Map.S with type key = key
|
||||
module OPS : S.MAP with type key = key
|
||||
val boxed : value OPS.t * int
|
||||
end
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user