Module Stdlib_stable.IarrayLabelsSource

An alias for the type of immutable arrays.

Return the length (number of elements) of the given immutable array.

get a n returns the element number n of immutable array a. The first element has number 0. The last element has number length a - 1. You can also write a.:(n) instead of get a n.

• raises Invalid_argument

  if n is outside the range 0 to (length a - 1).

A synonym for get.

init n ~f returns a fresh immutable array of length n, with element number i initialized to the result of f i. In other terms, init n ~f tabulates the results of f applied to the integers 0 to n-1.

• raises Invalid_argument

  if n < 0 or n > Sys.max_array_length. If the return type of f is float, then the maximum size is only Sys.max_array_length / 2.

The locally-allocating version of init.

append v1 v2 returns a fresh immutable array containing the concatenation of the immutable arrays v1 and v2.

• raises Invalid_argument

  if length v1 + length v2 > Sys.max_array_length.

The locally-allocating version of append.

Same as append, but concatenates a list of immutable arrays.

The locally-allocating version of concat.

sub a ~pos ~len returns a fresh immutable array of length len, containing the elements number pos to pos + len - 1 of immutable array a. This creates a copy of the selected portion of the immutable array.

• raises Invalid_argument

  if pos and len do not designate a valid subarray of a; that is, if pos < 0, or len < 0, or pos + len > length a.

The locally-allocating version of sub.

to_list a returns the list of all the elements of a.

The locally-allocating version of .

of_list l returns a fresh immutable array containing the elements of l.

• raises Invalid_argument

  if the length of l is greater than Sys.max_array_length.

The locally-allocating version of of_list.

to_array a returns a mutable copy of the immutable array a; that is, a fresh (mutable) array containing the same elements as a

of_array ma returns an immutable copy of the mutable array ma; that is, a fresh immutable array containing the same elements as ma

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.:(length a - 1); ().

The locally-scoped version of iter.

Same as iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.

The locally-scoped version of iteri.

map ~f a applies function f to all the elements of a, and builds an immutable array with the results returned by f: [| f a.:(0); f a.:(1); ...; f a.:(length a - 1) |].

The locally-scoped and locally-allocating version of map.

The locally-constrained but globally-allocating version of map.

The locally-allocating but global-input version of map.

Same as map, but the function is applied to the index of the element as first argument, and the element itself as second argument.

The locally-scoped and locally-allocating version of mapi.

The locally-constrained but globally-allocating version of mapi.

The locally-allocating but global-input version of mapi.

fold_left ~f ~init a computes f (... (f (f init a.:(0)) a.:(1)) ...) a.:(n-1), where n is the length of the immutable array a.

The locally-constrained and locally-allocating version of fold_left.

WARNING: This function consumes O(n) extra stack space, as every intermediate accumulator will be left on the local stack!

The locally-constrained but globally-allocating version of fold_left.

The locally-allocating but global-input version of fold_left.

WARNING: This function consumes O(n) extra stack space, as every intermediate accumulator will be left on the local stack!

fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.

The locally-constrained and locally-allocating version of fold_left.

WARNING: This function consumes O(n) extra stack space, as every intermediate accumulator will be left on the local stack!

The locally-constrained but globally-allocating version of fold_left.

The locally-allocating but global-input version of fold_left.

WARNING: This function consumes O(n) extra stack space, as every intermediate accumulator will be left on the local stack!

fold_right ~f a ~init computes f a.:(0) (f a.:(1) ( ... (f a.:(n-1) init) ...)), where n is the length of the immutable array a.

The locally-constrained and locally-allocating version of fold_right.

WARNING: This function consumes O(n) extra stack space, as every intermediate accumulator will be left on the local stack!

The locally-constrained but globally-allocating version of fold_right.

The locally-allocating but global-input version of fold_right.

WARNING: This function consumes O(n) extra stack space, as every intermediate accumulator will be left on the local stack!

iter2 ~f a b applies function f to all the elements of a and b.

• raises Invalid_argument

  if the immutable arrays are not the same size.

The locally-scoped version of iter2.

The first-biased partly-locally-scoped version of iter2.

The second-biased partly-locally-scoped version of iter2.

map2 ~f a b applies function f to all the elements of a and b, and builds an immutable array with the results returned by f: [| f a.:(0) b.:(0); ...; f a.:(length a - 1) b.:(length b - 1)|].

• raises Invalid_argument

  if the immutable arrays are not the same size.

The locally-scoped and locally-allocating version of map2.

The locally-scoped but globally-allocating version of map2.

The locally-allocating but global-inputs version of map2.

The first-biased partly-locally-scoped but globally-allocating version of map2.

The second-biased partly-locally-scoped but globally-allocating version of map2.

The locally-allocating and first-biased partly-locally-scoped version of map2.

The locally-allocating and second-biased partly-locally-scoped version of map2.

for_all ~f [|a1; ...; an|] checks if all elements of the immutable array satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an).

The locally-scoped version of for_all.

exists ~f [|a1; ...; an|] checks if at least one element of the immutable array satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an).

The locally-scoped version of exists.

Same as for_all, but for a two-argument predicate.

• raises Invalid_argument

  if the two immutable arrays have different lengths.

The locally-scoped version of for_all2.

The first-biased partly-locally-scoped version of for_all2.

The second-biased partly-locally-scoped version of for_all2.

Same as exists, but for a two-argument predicate.

• raises Invalid_argument

  if the two immutable arrays have different lengths.

The locally-scoped version of exists2.

The first-biased partly-locally-scoped version of exists2.

The second-biased partly-locally-scoped version of exists2.

mem a ~set is true if and only if a is structurally equal to an element of l (i.e. there is an x in l such that compare a x = 0).

Same as mem, but uses physical equality instead of structural equality to compare list elements.

find_opt ~f a returns the first element of the immutable array a that satisfies the predicate f, or None if there is no value that satisfies f in the array a.

The locally-constrained and locally-allocating version of .

find_map ~f a applies f to the elements of a in order, and returns the first result of the form Some v, or None if none exist.

The locally-constrained and locally-allocating version of find_map.

The locally-constrained but globally-allocating version of find_map.

The locally-allocating but global-input version of find_map.

split [:(a1,b1); ...; (an,bn):] is ([:a1; ...; an:], [:b1; ...; bn:]).

The locally-allocating version of split.

combine [:a1; ...; an:] [:b1; ...; bn:] is [:(a1,b1); ...; (an,bn):]. Raise Invalid_argument if the two immutable iarrays have different lengths.

The locally-allocating version of combine.

Sort an immutable 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, Stdlib.compare is a suitable comparison function. The result of calling sort is a fresh immutable array containing the same elements as the original sorted in increasing order. Other than this fresh 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 immutable 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

The result of sort, which we'll call a', contains the same elements as a, reordered in such a way that for all i and j valid indices of a (or equivalently, of a'):

• cmp a'.:(i) a'.:(j) >= 0 if and only if i >= j

Same as 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 a temporary array of length n/2, where n is the length of the immutable array. It is usually faster than the current implementation of sort.

Same as sort or stable_sort, whichever is faster on typical input.

Iterate on the immutable array, in increasing order.

Iterate on the immutable array, in increasing order, yielding indices along elements.

Create an immutable array from the generator