From d18cc74ab410506bad827eaa160a5f5ccf94e904 Mon Sep 17 00:00:00 2001 From: Pierre Chambart Date: Tue, 23 Jan 2018 17:44:06 +0100 Subject: [PATCH] Proto environment: clean Array --- .../sigs/v1/array.mli | 104 +----------------- 1 file changed, 4 insertions(+), 100 deletions(-) diff --git a/src/lib_protocol_environment/sigs/v1/array.mli b/src/lib_protocol_environment/sigs/v1/array.mli index 78e941458..c342bdb20 100644 --- a/src/lib_protocol_environment/sigs/v1/array.mli +++ b/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. -*)