From 48cc2e992836379dd99480fd194fcafe0146675a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gr=C3=A9goire=20Henry?= <gregoire.henry@tezos.com>
Date: Mon, 26 Mar 2018 11:09:39 +0200
Subject: [PATCH] Proto/Env: rename `Set.S` and `Map.S` into `S.SET` and
 `S.MAP`.

---
 src/lib_base/s.ml                             |  84 +++++-
 src/lib_protocol_environment/sigs/jbuild      |   4 +-
 src/lib_protocol_environment/sigs/v1/map.mli  | 244 +-----------------
 src/lib_protocol_environment/sigs/v1/s.mli    |  84 +++++-
 src/lib_protocol_environment/sigs/v1/set.mli  | 202 +--------------
 .../lib_protocol/src/script_typed_ir.ml       |   4 +-
 6 files changed, 170 insertions(+), 452 deletions(-)

diff --git a/src/lib_base/s.ml b/src/lib_base/s.ml
index 27fe31391..2885c7237 100644
--- a/src/lib_base/s.ml
+++ b/src/lib_base/s.ml
@@ -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
 
diff --git a/src/lib_protocol_environment/sigs/jbuild b/src/lib_protocol_environment/sigs/jbuild
index 4ed9eb537..fbeae3379 100644
--- a/src/lib_protocol_environment/sigs/jbuild
+++ b/src/lib_protocol_environment/sigs/jbuild
@@ -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
diff --git a/src/lib_protocol_environment/sigs/v1/map.mli b/src/lib_protocol_environment/sigs/v1/map.mli
index d36d2e9d9..754fdba48 100644
--- a/src/lib_protocol_environment/sigs/v1/map.mli
+++ b/src/lib_protocol_environment/sigs/v1/map.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. *)
diff --git a/src/lib_protocol_environment/sigs/v1/s.mli b/src/lib_protocol_environment/sigs/v1/s.mli
index bf3137da3..f3e3fcca0 100644
--- a/src/lib_protocol_environment/sigs/v1/s.mli
+++ b/src/lib_protocol_environment/sigs/v1/s.mli
@@ -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
 
diff --git a/src/lib_protocol_environment/sigs/v1/set.mli b/src/lib_protocol_environment/sigs/v1/set.mli
index 90dd25ab0..d4bcee7f9 100644
--- a/src/lib_protocol_environment/sigs/v1/set.mli
+++ b/src/lib_protocol_environment/sigs/v1/set.mli
@@ -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. *)
diff --git a/src/proto_alpha/lib_protocol/src/script_typed_ir.ml b/src/proto_alpha/lib_protocol/src/script_typed_ir.ml
index 9d65df7c4..c54271567 100644
--- a/src/proto_alpha/lib_protocol/src/script_typed_ir.ml
+++ b/src/proto_alpha/lib_protocol/src/script_typed_ir.ml
@@ -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