Proto environment: clean Array

src/lib_protocol_environment/sigs/v1/array.mli

@@ -18,6 +18,10 @@
    * Import version 4.04.0
    * Remove unsafe functions
    * Remove deprecated functions
+   * Remove set, copy, fill, blit, sort, stable_sort, fast_sort:
+     mutability
+   * iter, iteri, iter2: imperative
+   * mem, memq: Use (=) and (==)
 
 *)
 
@@ -35,14 +39,6 @@ external get : 'a array -> int -> 'a = "%array_safe_get"
     Raise [Invalid_argument "index out of bounds"]
     if [n] is outside the range 0 to [(Array.length a - 1)]. *)
 
-external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
-(** [Array.set a n x] modifies array [a] in place, replacing
-    element number [n] with [x].
-    You can also write [a.(n) <- x] instead of [Array.set a n x].
-
-    Raise [Invalid_argument "index out of bounds"]
-    if [n] is outside the range 0 to [Array.length a - 1]. *)
-
 external make : int -> 'a -> 'a array = "caml_make_vect"
 (** [Array.make n x] returns a fresh array of length [n],
     initialized with [x].
@@ -100,28 +96,6 @@ val sub : 'a array -> int -> int -> 'a array
     designate a valid subarray of [a]; that is, if
     [start < 0], or [len < 0], or [start + len > Array.length a]. *)
 
-val copy : 'a array -> 'a array
-(** [Array.copy a] returns a copy of [a], that is, a fresh array
-    containing the same elements as [a]. *)
-
-val fill : 'a array -> int -> int -> 'a -> unit
-(** [Array.fill a ofs len x] modifies the array [a] in place,
-    storing [x] in elements number [ofs] to [ofs + len - 1].
-
-    Raise [Invalid_argument "Array.fill"] if [ofs] and [len] do not
-    designate a valid subarray of [a]. *)
-
-val blit : 'a array -> int -> 'a array -> int -> int -> unit
-(** [Array.blit v1 o1 v2 o2 len] copies [len] elements
-    from array [v1], starting at element number [o1], to array [v2],
-    starting at element number [o2]. It works correctly even if
-    [v1] and [v2] are the same array, and the source and
-    destination chunks overlap.
-
-    Raise [Invalid_argument "Array.blit"] if [o1] and [len] do not
-    designate a valid subarray of [v1], or if [o2] and [len] do not
-    designate a valid subarray of [v2]. *)
-
 val to_list : 'a array -> 'a list
 (** [Array.to_list a] returns the list of all the elements of [a]. *)
 
@@ -133,16 +107,6 @@ val of_list : 'a list -> 'a array
 (** {6 Iterators} *)
 
 
-val iter : ('a -> unit) -> 'a array -> unit
-(** [Array.iter f a] applies function [f] in turn to all
-    the elements of [a].  It is equivalent to
-    [f a.(0); f a.(1); ...; f a.(Array.length a - 1); ()]. *)
-
-val iteri : (int -> 'a -> unit) -> 'a array -> unit
-(** Same as {!Array.iter}, but the
-    function is applied with the index of the element as first argument,
-    and the element itself as second argument. *)
-
 val map : ('a -> 'b) -> 'a array -> 'b array
 (** [Array.map f a] applies function [f] to all the elements of [a],
     and builds an array with the results returned by [f]:
@@ -167,12 +131,6 @@ val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
 (** {6 Iterators on two arrays} *)
 
 
-val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
-(** [Array.iter2 f a b] applies function [f] to all the elements of [a]
-    and [b].
-    Raise [Invalid_argument] if the arrays are not the same size.
-    @since 4.03.0 *)
-
 val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
 (** [Array.map2 f a b] applies function [f] to all the elements of [a]
     and [b], and builds an array with the results returned by [f]:
@@ -196,58 +154,4 @@ val exists : ('a -> bool) -> 'a array -> bool
     [(p a1) || (p a2) || ... || (p an)].
     @since 4.03.0 *)
 
-val mem : 'a -> 'a array -> bool
-(** [mem a l] is true if and only if [a] is equal
-    to an element of [l].
-    @since 4.03.0 *)
-
-val memq : 'a -> 'a array -> bool
-(** Same as {!Array.mem}, but uses physical equality instead of structural
-    equality to compare array elements.
-    @since 4.03.0 *)
-
-
-(** {6 Sorting} *)
-
-
-val sort : ('a -> 'a -> int) -> 'a array -> unit
-(** Sort an array in increasing order according to a comparison
-    function.  The comparison function must return 0 if its arguments
-    compare as equal, a positive integer if the first is greater,
-    and a negative integer if the first is smaller (see below for a
-    complete specification).  For example, {!Pervasives.compare} is
-    a suitable comparison function, provided there are no floating-point
-    NaN values in the data.  After calling [Array.sort], the
-    array is sorted in place in increasing order.
-    [Array.sort] is guaranteed to run in constant heap space
-    and (at most) logarithmic stack space.
-
-    The current implementation uses Heap Sort.  It runs in constant
-    stack space.
-
-    Specification of the comparison function:
-    Let [a] be the array and [cmp] the comparison function.  The following
-    must be true for all x, y, z in a :
-    -   [cmp x y] > 0 if and only if [cmp y x] < 0
-    -   if [cmp x y] >= 0 and [cmp y z] >= 0 then [cmp x z] >= 0
-
-    When [Array.sort] returns, [a] contains the same elements as before,
-    reordered in such a way that for all i and j valid indices of [a] :
-    -   [cmp a.(i) a.(j)] >= 0 if and only if i >= j
-*)
-
-val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
-(** Same as {!Array.sort}, but the sorting algorithm is stable (i.e.
-    elements that compare equal are kept in their original order) and
-    not guaranteed to run in constant heap space.
-
-    The current implementation uses Merge Sort. It uses [n/2]
-    words of heap space, where [n] is the length of the array.
-    It is usually faster than the current implementation of {!Array.sort}.
-*)
-
-val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
-(** Same as {!Array.sort} or {!Array.stable_sort}, whichever is faster
-    on typical input.
-*)