Module CCArray

The empty array, physically equal to ||.

Hoist an equality test for elements to arrays. Arrays are only equal if their lengths are the same and corresponding elements test equal.

swap arr i j swaps elements at indices i and j.

• Since: 1.4

get a n returns the element number n of 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.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to (length a - 1).

get_safe a i returns Some a.(i) if i is a valid index.

• Since: 0.18

set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of set a n x.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to length a - 1.

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

fold f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.

Fold left on array, with index.

Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator.

• Since: 0.8

fold_map f acc a is a fold_left-like function, but it also maps the array to another array.

• Since: 1.2

scan_left f acc a returns the array [|acc; f acc x0; f (f acc a.(0)) a.(1); …|] .

• Since: 1.2

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); ().

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

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.

Reverse the array in place.

sorted cmp a makes a copy of a and sorts it with cmp.

• Since: 1.0

sort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index at which the i-th element of sorted cmp a appears in a. a is not modified.

In other words, map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a. sort_indices yields the inverse permutation of sort_ranking.

• Since: 1.0

sort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the index at which the i-the element of a appears in sorted cmp a. a is not modified.

In other words, map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a. sort_ranking yields the inverse permutation of sort_indices.

In the absence of duplicate elements in a, we also have lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i).

• Since: 1.0

find_map f a returns Some y if there is an element x such that f x = Some y, else it returns None.

• Since: 1.3

Alias to find_map.

• Deprecated since 1.3

Like find_map, but also pass the index to the predicate function.

• Since: 1.3

Alias to find_map_i.

• Since: 0.3.4
• Deprecated since 1.3

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds. Otherwise returns None.

• Since: 0.3.4

Lookup the index of some value in a sorted array. Undefined behavior if the array is not sorted wrt cmp. Complexity: O(log (n)) (dichotomic search).

• Returns None if the key is not present, or Some i (i the index of the key) otherwise.

Like lookup, but

• Raises Not_found: if the key is not present.

bsearch ?cmp x arr finds the index of the object x in the array arr, provided arr is sorted using cmp. If the array is not sorted, the result is not specified (may

• Raises Invalid_argument: ).

  Complexity: O(log n) where n is the length of the array (dichotomic search).

• Returns

  • `At i if cmp arr.(i) x = 0 (for some i).
  • `All_lower if all elements of arr are lower than x.
  • `All_bigger if all elements of arr are bigger than x.
  • `Just_after i if arr.(i) < x < arr.(i+1).
  • `Empty if the array is empty.
• Raises Invalid_argument: if the array is found to be unsorted w.r.t cmp.
• Since: 0.13

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

Forall on pairs of arrays.

• Raises Invalid_argument: if they have distinct lengths. Allow different types.
• Since: 0.20

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

Exists on pairs of arrays.

• Raises Invalid_argument: if they have distinct lengths. Allow different types.
• Since: 0.20

Fold on two arrays stepwise.

• Raises Invalid_argument: if they have distinct lengths.
• Since: 0.20

Iterate on two arrays stepwise.

• Raises Invalid_argument: if they have distinct lengths.
• Since: 0.20

Shuffle randomly the array, in place.

Like shuffle but using a specialized random state.

Choose an element randomly.

• Raises Not_found: if the array/slice is empty.

Return a sequence of the elements of an array. The input array is shared with the sequence and modifications of it will result in modification of the sequence.

Return a gen of the elements of an array.

Return a klist of the elements of an array.

Print an array of items with printing function.

Print an array, giving the printing function both index and item.

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

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: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].

• Raises Invalid_argument: if they have distinct lengths.
• Since: 0.20

Copy + reverse in place.

• Since: 0.20

Filter elements out of the array. Only the elements satisfying the given predicate will be kept.

Map each element into another value, or discard it.

Transform each element into an array, then flatten.

Infix version of flat_map.

Infix version of map.

• Since: 0.8

Infix version of map.

• Since: 0.8

Remove given index, obtaining the list of the other elements.

Range array. Bounds included.

Range array, excluding right bound.

• Since: 0.17

Sort the array, without allocating (eats stack space though). Performance might be lower than Array.sort.

• Since: 0.14