mirror of
https://github.com/c-cube/ocaml-containers.git
synced 2025-12-06 11:15:31 -05:00
34 lines
91 KiB
HTML
34 lines
91 KiB
HTML
<!DOCTYPE html>
|
||
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCArrayLabels (containers.CCArrayLabels)</title><link rel="stylesheet" href="../../_odoc-theme/odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 2.3.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../index.html">containers</a> » CCArrayLabels</nav><header class="odoc-preamble"><h1>Module <code><span>CCArrayLabels</span></code></h1><p>Array utils (Labeled version of <a href="../CCArray/index.html"><code>CCArray</code></a>)</p></header><nav class="odoc-toc"><ul><li><a href="#arrays">Arrays</a><ul><li><a href="#iterators">Iterators</a></li><li><a href="#iterators-on-two-arrays">Iterators on two arrays</a></li><li><a href="#array-scanning">Array scanning</a></li><li><a href="#arrays-of-pairs">Arrays of pairs</a></li><li><a href="#sorting">Sorting</a></li><li><a href="#arrays-and-sequences">Arrays and Sequences</a></li></ul></li><li><a href="#io">IO</a></li><li><a href="#generic-functions">Generic Functions</a><ul><li><a href="#infix-operators">Infix Operators</a></li></ul></li></ul></nav><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-iter"><a href="#type-iter" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a iter</span></span><span> = <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>Fast internal iterator.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-gen"><a href="#type-gen" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a gen</span></span><span> = <span>unit <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-equal"><a href="#type-equal" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a equal</span></span><span> = <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ord"><a href="#type-ord" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a ord</span></span><span> = <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-random_gen"><a href="#type-random_gen" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a random_gen</span></span><span> = <span><a href="../../ocaml/Stdlib/Random/State/index.html#type-t">Stdlib.Random.State.t</a> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-printer"><a href="#type-printer" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a printer</span></span><span> = <span><a href="../../ocaml/Stdlib/Format/index.html#type-formatter">Stdlib.Format.formatter</a> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div></div><h3 id="arrays"><a href="#arrays" class="anchor"></a>Arrays</h3><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span><span> = <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p>An alias for the type of arrays.</p></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p>Return the length (number of elements) of the given array.</p></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>get a n</code> returns the element number <code>n</code> of array <code>a</code>. The first element has number 0. The last element has number <code>length a - 1</code>. You can also write <code>a.(n)</code> instead of <code>get a n</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>n</code> is outside the range 0 to <code>(length a - 1)</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>set a n x</code> modifies array <code>a</code> in place, replacing element number <code>n</code> with <code>x</code>. You can also write <code>a.(n) <- x</code> instead of <code>set a n x</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>n</code> is outside the range 0 to <code>length a - 1</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>make n x</code> returns a fresh array of length <code>n</code>, initialized with <code>x</code>. All the elements of this new array are initially physically equal to <code>x</code> (in the sense of the <code>==</code> predicate). Consequently, if <code>x</code> is mutable, it is shared among all elements of the array, and modifying <code>x</code> through one of the array entries will modify all other entries at the same time.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>n < 0</code> or <code>n > Sys.max_array_length</code>. If the value of <code>x</code> is a floating-point number, then the maximum size is only <code>Sys.max_array_length / 2</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> <p><code>create</code> is an alias for <a href="#val-make"><code>make</code></a>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-create_float"><a href="#val-create_float" class="anchor"></a><code><span><span class="keyword">val</span> create_float : <span>int <span class="arrow">-></span></span> <span>float array</span></span></code></div><div class="spec-doc"><p><code>create_float n</code> returns a fresh float array of length <code>n</code>, with uninitialized data.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.03</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make_float"><a href="#val-make_float" class="anchor"></a><code><span><span class="keyword">val</span> make_float : <span>int <span class="arrow">-></span></span> <span>float array</span></span></code></div><div class="spec-doc"><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> <p><code>make_float</code> is an alias for <a href="#val-create_float"><code>create_float</code></a>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>int <span class="arrow">-></span></span> <span><span class="label">f</span>:<span>(<span>int <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>init n ~f</code> returns a fresh array of length <code>n</code>, with element number <code>i</code> initialized to the result of <code>f i</code>. In other terms, <code>init n ~f</code> tabulates the results of <code>f</code> applied to the integers <code>0</code> to <code>n-1</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>n < 0</code> or <code>n > Sys.max_array_length</code>. If the return type of <code>f</code> is <code>float</code>, then the maximum size is only <code>Sys.max_array_length / 2</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make_matrix"><a href="#val-make_matrix" class="anchor"></a><code><span><span class="keyword">val</span> make_matrix : <span><span class="label">dimx</span>:int <span class="arrow">-></span></span> <span><span class="label">dimy</span>:int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> array</span></span></code></div><div class="spec-doc"><p><code>make_matrix ~dimx ~dimy e</code> returns a two-dimensional array (an array of arrays) with first dimension <code>dimx</code> and second dimension <code>dimy</code>. All the elements of this new matrix are initially physically equal to <code>e</code>. The element (<code>x,y</code>) of a matrix <code>m</code> is accessed with the notation <code>m.(x).(y)</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>dimx</code> or <code>dimy</code> is negative or greater than <code>Sys.max_array_length</code>. If the value of <code>e</code> is a floating-point number, then the maximum size is only <code>Sys.max_array_length / 2</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create_matrix"><a href="#val-create_matrix" class="anchor"></a><code><span><span class="keyword">val</span> create_matrix : <span><span class="label">dimx</span>:int <span class="arrow">-></span></span> <span><span class="label">dimy</span>:int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> array</span></span></code></div><div class="spec-doc"><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> <p><code>create_matrix</code> is an alias for <a href="#val-make_matrix"><code>make_matrix</code></a>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-append"><a href="#val-append" class="anchor"></a><code><span><span class="keyword">val</span> append : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>append v1 v2</code> returns a fresh array containing the concatenation of the arrays <code>v1</code> and <code>v2</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>length v1 + length v2 > Sys.max_array_length</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><span><span><span class="type-var">'a</span> array</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-append"><code>append</code></a>, but concatenates a list of arrays.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="label">pos</span>:int <span class="arrow">-></span></span> <span><span class="label">len</span>:int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>sub a ~pos ~len</code> returns a fresh array of length <code>len</code>, containing the elements number <code>pos</code> to <code>pos + len - 1</code> of array <code>a</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>pos</code> and <code>len</code> do not designate a valid subarray of <code>a</code>; that is, if <code>pos < 0</code>, or <code>len < 0</code>, or <code>pos + len > length a</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>copy a</code> returns a copy of <code>a</code>, that is, a fresh array containing the same elements as <code>a</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fill"><a href="#val-fill" class="anchor"></a><code><span><span class="keyword">val</span> fill : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="label">pos</span>:int <span class="arrow">-></span></span> <span><span class="label">len</span>:int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>fill a ~pos ~len x</code> modifies the array <code>a</code> in place, storing <code>x</code> in elements number <code>pos</code> to <code>pos + len - 1</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>pos</code> and <code>len</code> do not designate a valid subarray of <code>a</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span><span class="keyword">val</span> blit :
|
||
<span><span class="label">src</span>:<span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span>
|
||
<span><span class="label">src_pos</span>:int <span class="arrow">-></span></span>
|
||
<span><span class="label">dst</span>:<span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span>
|
||
<span><span class="label">dst_pos</span>:int <span class="arrow">-></span></span>
|
||
<span><span class="label">len</span>:int <span class="arrow">-></span></span>
|
||
unit</span></code></div><div class="spec-doc"><p><code>blit ~src ~src_pos ~dst ~dst_pos ~len</code> copies <code>len</code> elements from array <code>src</code>, starting at element number <code>src_pos</code>, to array <code>dst</code>, starting at element number <code>dst_pos</code>. It works correctly even if <code>src</code> and <code>dst</code> are the same array, and the source and destination chunks overlap.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>src_pos</code> and <code>len</code> do not designate a valid subarray of <code>src</code>, or if <code>dst_pos</code> and <code>len</code> do not designate a valid subarray of <code>dst</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>to_list a</code> returns the list of all the elements of <code>a</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_list"><a href="#val-of_list" class="anchor"></a><code><span><span class="keyword">val</span> of_list : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>of_list l</code> returns a fresh array containing the elements of <code>l</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if the length of <code>l</code> is greater than <code>Sys.max_array_length</code>.</p></li></ul></div></div><h4 id="iterators"><a href="#iterators" class="anchor"></a>Iterators</h4><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>iter ~f a</code> applies function <code>f</code> in turn to all the elements of <code>a</code>. It is equivalent to <code>f a.(0); f a.(1); ...; f a.(length a - 1); ()</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span class="label">f</span>:<span>(<span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-iter"><code>iter</code></a>, but the function is applied to the index of the element as first argument, and the element itself as second argument.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> array</span></span></code></div><div class="spec-doc"><p><code>map ~f a</code> applies function <code>f</code> to all the elements of <code>a</code>, and builds an array with the results returned by <code>f</code>: <code>[| f a.(0); f a.(1); ...; f a.(length a - 1) |]</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span class="label">f</span>:<span>(<span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> array</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-map"><code>map</code></a>, but the function is applied to the index of the element as first argument, and the element itself as second argument.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>fold_left ~f ~init a</code> computes <code>f (... (f (f init a.(0)) a.(1)) ...) a.(n-1)</code>, where <code>n</code> is the length of the array <code>a</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left_map"><a href="#val-fold_left_map" class="anchor"></a><code><span><span class="keyword">val</span> fold_left_map :
|
||
<span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'a</span> * <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span>
|
||
<span><span class="label">init</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'b</span> array</span> <span class="arrow">-></span></span>
|
||
<span class="type-var">'a</span> * <span><span class="type-var">'c</span> array</span></span></code></div><div class="spec-doc"><p><code>fold_left_map</code> is a combination of <a href="#val-fold_left"><code>fold_left</code></a> and <a href="#val-map"><code>map</code></a> that threads an accumulator through calls to <code>f</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.13.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span><span class="keyword">val</span> fold_right : <span><span class="label">f</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>fold_right ~f a ~init</code> computes <code>f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))</code>, where <code>n</code> is the length of the array <code>a</code>.</p></div></div><h4 id="iterators-on-two-arrays"><a href="#iterators-on-two-arrays" class="anchor"></a>Iterators on two arrays</h4><h4 id="array-scanning"><a href="#array-scanning" class="anchor"></a>Array scanning</h4><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>for_all ~f [|a1; ...; an|]</code> checks if all elements of the array satisfy the predicate <code>f</code>. That is, it returns <code>(f a1) && (f a2) && ... && (f an)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.03.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>exists ~f [|a1; ...; an|]</code> checks if at least one element of the array satisfies the predicate <code>f</code>. That is, it returns <code>(f a1) || (f a2) || ... || (f an)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.03.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-memq"><a href="#val-memq" class="anchor"></a><code><span><span class="keyword">val</span> memq : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="label">set</span>:<span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p>Same as <a href="#val-mem"><code>mem</code></a>, but uses physical equality instead of structural equality to compare list elements.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.03.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p><code>find_opt ~f a</code> returns the first element of the array <code>a</code> that satisfies the predicate <code>f</code>, or <code>None</code> if there is no value that satisfies <code>f</code> in the array <code>a</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.13.0</li></ul></div></div><h4 id="arrays-of-pairs"><a href="#arrays-of-pairs" class="anchor"></a>Arrays of pairs</h4><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> array</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span> * <span><span class="type-var">'b</span> array</span></span></code></div><div class="spec-doc"><p><code>split [|(a1,b1); ...; (an,bn)|]</code> is <code>([|a1; ...; an|], [|b1; ...; bn|])</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.13.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-combine"><a href="#val-combine" class="anchor"></a><code><span><span class="keyword">val</span> combine : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> array</span></span></code></div><div class="spec-doc"><p><code>combine [|a1; ...; an|] [|b1; ...; bn|]</code> is <code>[|(a1,b1); ...; (an,bn)|]</code>. Raise <code>Invalid_argument</code> if the two arrays have different lengths.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.13.0</li></ul></div></div><h4 id="sorting"><a href="#sorting" class="anchor"></a>Sorting</h4><div class="odoc-spec"><div class="spec value anchored" id="val-sort"><a href="#val-sort" class="anchor"></a><code><span><span class="keyword">val</span> sort : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>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, <a href="../../ocaml/Stdlib/index.html#val-compare"><code>Stdlib.compare</code></a> is a suitable comparison function. After calling <code>sort</code>, the array is sorted in place in increasing order. <code>sort</code> is guaranteed to run in constant heap space and (at most) logarithmic stack space.</p><p>The current implementation uses Heap Sort. It runs in constant stack space.</p><p>Specification of the comparison function: Let <code>a</code> be the array and <code>cmp</code> the comparison function. The following must be true for all <code>x</code>, <code>y</code>, <code>z</code> in <code>a</code> :</p><ul><li><code>cmp x y</code> > 0 if and only if <code>cmp y x</code> < 0</li><li>if <code>cmp x y</code> >= 0 and <code>cmp y z</code> >= 0 then <code>cmp x z</code> >= 0</li></ul><p>When <code>sort</code> returns, <code>a</code> contains the same elements as before, reordered in such a way that for all i and j valid indices of <code>a</code> :</p><ul><li><code>cmp a.(i) a.(j)</code> >= 0 if and only if i >= j</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stable_sort"><a href="#val-stable_sort" class="anchor"></a><code><span><span class="keyword">val</span> stable_sort : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-sort"><code>sort</code></a>, 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.</p><p>The current implementation uses Merge Sort. It uses a temporary array of length <code>n/2</code>, where <code>n</code> is the length of the array. It is usually faster than the current implementation of <a href="#val-sort"><code>sort</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fast_sort"><a href="#val-fast_sort" class="anchor"></a><code><span><span class="keyword">val</span> fast_sort : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-sort"><code>sort</code></a> or <a href="#val-stable_sort"><code>stable_sort</code></a>, whichever is faster on typical input.</p></div></div><h4 id="arrays-and-sequences"><a href="#arrays-and-sequences" class="anchor"></a>Arrays and Sequences</h4><div class="odoc-spec"><div class="spec value anchored" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span><span class="keyword">val</span> to_seqi : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../../ocaml/Stdlib/Seq/index.html#type-t">Stdlib.Seq.t</a></span></span></code></div><div class="spec-doc"><p>Iterate on the array, in increasing order, yielding indices along elements. Modifications of the array during iteration will be reflected in the sequence.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.07</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span class="type-var">'a</span> <a href="../../ocaml/Stdlib/Seq/index.html#type-t">Stdlib.Seq.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p>Create an array from the generator</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.07</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>empty</code> is the empty array, physically equal to <code>[||]</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span><span class="type-var">'a</span> <a href="#type-equal">equal</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-equal">equal</a></span></span></code></div><div class="spec-doc"><p><code>equal eq a1 a2</code> is <code>true</code> if the lengths of <code>a1</code> and <code>a2</code> are the same and if their corresponding elements test equal, using <code>eq</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><span><span class="type-var">'a</span> <a href="#type-ord">ord</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-ord">ord</a></span></span></code></div><div class="spec-doc"><p><code>compare cmp a1 a2</code> compares arrays <code>a1</code> and <code>a2</code> using the function comparison <code>cmp</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-swap"><a href="#val-swap" class="anchor"></a><code><span><span class="keyword">val</span> swap : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>swap a i j</code> swaps elements at indices <code>i</code> and <code>j</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.4</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_safe"><a href="#val-get_safe" class="anchor"></a><code><span><span class="keyword">val</span> get_safe : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p><code>get_safe a i</code> returns <code>Some a.(i)</code> if <code>i</code> is a valid index.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.18</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_inplace"><a href="#val-map_inplace" class="anchor"></a><code><span><span class="keyword">val</span> map_inplace : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>map_inplace ~f a</code> replace all elements of <code>a</code> by its image by <code>f</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi_inplace"><a href="#val-mapi_inplace" class="anchor"></a><code><span><span class="keyword">val</span> mapi_inplace : <span><span class="label">f</span>:<span>(<span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>mapi_inplace ~f a</code> replace all elements of <code>a</code> by its image by <code>f</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.10</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>fold ~f ~init a</code> computes <code>f (… (f (f init a.(0)) a.(1)) …) a.(n-1)</code>, where <code>n</code> is the length of the array <code>a</code>. Same as <code>ArrayLabels.fold_left</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-foldi"><a href="#val-foldi" class="anchor"></a><code><span><span class="keyword">val</span> foldi : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>foldi ~f ~init a</code> is just like <a href="#val-fold"><code>fold</code></a>, but it also passes in the index of each element as the second argument to the folded function <code>f</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_while"><a href="#val-fold_while" class="anchor"></a><code><span><span class="keyword">val</span> fold_while :
|
||
<span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'a</span> * <span>[ `Stop <span>| `Continue</span> ]</span>)</span> <span class="arrow">-></span></span>
|
||
<span><span class="label">init</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span>
|
||
<span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>fold_while ~f ~init a</code> folds left on array <code>a</code> until a stop condition via <code>('a, `Stop)</code> is indicated by the accumulator.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_map"><a href="#val-fold_map" class="anchor"></a><code><span><span class="keyword">val</span> fold_map : <span><span class="label">f</span>:<span>(<span><span class="type-var">'acc</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'acc</span> * <span class="type-var">'b</span>)</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'acc</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span class="type-var">'acc</span> * <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>fold_map ~f ~init a</code> is a <code>fold_left</code>-like function, but it also maps the array to another array.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.2, but only</li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.1 with labels</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scan_left"><a href="#val-scan_left" class="anchor"></a><code><span><span class="keyword">val</span> scan_left : <span><span class="label">f</span>:<span>(<span><span class="type-var">'acc</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'acc</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'acc</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>scan_left ~f ~init a</code> returns the array <code> [|init; f init x0; f (f init a.(0)) a.(1); …|] </code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.2, but only</li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.1 with labels</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reverse_in_place"><a href="#val-reverse_in_place" class="anchor"></a><code><span><span class="keyword">val</span> reverse_in_place : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>reverse_in_place a</code> reverses the array <code>a</code> in place.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sorted"><a href="#val-sorted" class="anchor"></a><code><span><span class="keyword">val</span> sorted : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p><code>sorted ~f a</code> makes a copy of <code>a</code> and sorts it with <code>f</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort_indices"><a href="#val-sort_indices" class="anchor"></a><code><span><span class="keyword">val</span> sort_indices : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int array</span></span></code></div><div class="spec-doc"><p><code>sort_indices ~f a</code> returns a new array <code>b</code>, with the same length as <code>a</code>, such that <code>b.(i)</code> is the index at which the <code>i</code>-th element of <code>sorted f a</code> appears in <code>a</code>. <code>a</code> is not modified.</p><p>In other words, <code>map (fun i -> a.(i)) (sort_indices f a) = sorted f a</code>. <code>sort_indices</code> yields the inverse permutation of <a href="#val-sort_ranking"><code>sort_ranking</code></a>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort_ranking"><a href="#val-sort_ranking" class="anchor"></a><code><span><span class="keyword">val</span> sort_ranking : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int array</span></span></code></div><div class="spec-doc"><p><code>sort_ranking ~f a</code> returns a new array <code>b</code>, with the same length as <code>a</code>, such that <code>b.(i)</code> is the index at which the <code>i</code>-th element of <code>a</code> appears in <code>sorted f a</code>. <code>a</code> is not modified.</p><p>In other words, <code>map (fun i -> (sorted f a).(i)) (sort_ranking f a) = a</code>. <code>sort_ranking</code> yields the inverse permutation of <a href="#val-sort_indices"><code>sort_indices</code></a>.</p><p>In the absence of duplicate elements in <code>a</code>, we also have <code>lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span class="optlabel">?eq</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>mem ~eq x a</code> return true if x is present in <code>a</code>. Linear time.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_map"><a href="#val-find_map" class="anchor"></a><code><span><span class="keyword">val</span> find_map : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p><code>find_map ~f a</code> returns <code>Some y</code> if there is an element <code>x</code> such that <code>f x = Some y</code>. Otherwise returns <code>None</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.3, but only</li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.1 with labels</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_map_i"><a href="#val-find_map_i" class="anchor"></a><code><span><span class="keyword">val</span> find_map_i : <span><span class="label">f</span>:<span>(<span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p><code>find_map_i ~f a</code> is like <a href="#val-find_map"><code>find_map</code></a>, but the index of the element is also passed to the predicate function <code>f</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.3, but only</li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.1 with labels</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_idx"><a href="#val-find_idx" class="anchor"></a><code><span><span class="keyword">val</span> find_idx : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(int * <span class="type-var">'a</span>)</span> option</span></span></code></div><div class="spec-doc"><p><code>find_idx ~f a</code> returns <code>Some (i,x)</code> where <code>x</code> is the <code>i</code>-th element of <code>a</code>, and <code>f x</code> holds. Otherwise returns <code>None</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.3.4</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max"><a href="#val-max" class="anchor"></a><code><span><span class="keyword">val</span> max : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p><code>max ~cmp a</code> returns <code>None</code> if <code>a</code> is empty, otherwise, returns <code>Some e</code> where <code>e</code> is a maximum element in <code>a</code> with respect to <code>cmp</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_exn"><a href="#val-max_exn" class="anchor"></a><code><span><span class="keyword">val</span> max_exn : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>max_exn ~cmp a</code> is like <a href="#val-max"><code>max</code></a>, but</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> is empty.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-argmax"><a href="#val-argmax" class="anchor"></a><code><span><span class="keyword">val</span> argmax : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int option</span></span></code></div><div class="spec-doc"><p><code>argmax ~cmp a</code> returns <code>None</code> if <code>a</code> is empty, otherwise, returns <code>Some i</code> where <code>i</code> is the index of a maximum element in <code>a</code> with respect to <code>cmp</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-argmax_exn"><a href="#val-argmax_exn" class="anchor"></a><code><span><span class="keyword">val</span> argmax_exn : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p><code>argmax_exn ~cmp a</code> is like <a href="#val-argmax"><code>argmax</code></a>, but</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> is empty.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min"><a href="#val-min" class="anchor"></a><code><span><span class="keyword">val</span> min : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p><code>min ~cmp a</code> returns <code>None</code> if <code>a</code> is empty, otherwise, returns <code>Some e</code> where <code>e</code> is a minimum element in <code>a</code> with respect to <code>cmp</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min_exn"><a href="#val-min_exn" class="anchor"></a><code><span><span class="keyword">val</span> min_exn : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>min_exn ~cmp a</code> is like <a href="#val-min"><code>min</code></a>, but</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> is empty.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-argmin"><a href="#val-argmin" class="anchor"></a><code><span><span class="keyword">val</span> argmin : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int option</span></span></code></div><div class="spec-doc"><p><code>argmin ~cmp a</code> returns <code>None</code> if <code>a</code> is empty, otherwise, returns <code>Some i</code> where <code>i</code> is the index of a minimum element in <code>a</code> with respect to <code>cmp</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-argmin_exn"><a href="#val-argmin_exn" class="anchor"></a><code><span><span class="keyword">val</span> argmin_exn : <span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p><code>argmin_exn ~cmp a</code> is like <a href="#val-argmin"><code>argmin</code></a>, but</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> is empty.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.12</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lookup"><a href="#val-lookup" class="anchor"></a><code><span><span class="keyword">val</span> lookup : <span><span class="label">cmp</span>:<span><span class="type-var">'a</span> <a href="#type-ord">ord</a></span> <span class="arrow">-></span></span> <span><span class="label">key</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int option</span></span></code></div><div class="spec-doc"><p><code>lookup ~cmp ~key a</code> lookups the index of some key <code>key</code> in a sorted array <code>a</code>. Undefined behavior if the array <code>a</code> is not sorted wrt <code>cmp</code>. Complexity: <code>O(log (n))</code> (dichotomic search).</p><ul class="at-tags"><li class="returns"><span class="at-tag">returns</span> <p><code>None</code> if the key <code>key</code> is not present, or <code>Some i</code> (<code>i</code> the index of the key) otherwise.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lookup_exn"><a href="#val-lookup_exn" class="anchor"></a><code><span><span class="keyword">val</span> lookup_exn : <span><span class="label">cmp</span>:<span><span class="type-var">'a</span> <a href="#type-ord">ord</a></span> <span class="arrow">-></span></span> <span><span class="label">key</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p><code>lookup_exn ~cmp ~key a</code> is like <a href="#val-lookup"><code>lookup</code></a>, but</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Not_found</code> <p>if the key <code>key</code> is not present.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bsearch"><a href="#val-bsearch" class="anchor"></a><code><span><span class="keyword">val</span> bsearch :
|
||
<span><span class="label">cmp</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span>
|
||
<span><span class="label">key</span>:<span class="type-var">'a</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span>
|
||
<span>[ `All_lower <span>| `All_bigger</span> <span><span>| `Just_after</span> of int</span> <span>| `Empty</span> <span><span>| `At</span> of int</span> ]</span></span></code></div><div class="spec-doc"><p><code>bsearch ~cmp ~key a</code> finds the index of the object <code>key</code> in the array <code>a</code>, provided <code>a</code> is <b>sorted</b> using <code>cmp</code>. If the array is not sorted, the result is not specified (may raise Invalid_argument).</p><p>Complexity: <code>O(log n)</code> where n is the length of the array <code>a</code> (dichotomic search).</p><ul class="at-tags"><li class="returns"><span class="at-tag">returns</span> <ul><li><code>`At i</code> if <code>cmp a.(i) key = 0</code> (for some i).</li><li><code>`All_lower</code> if all elements of <code>a</code> are lower than <code>key</code>.</li><li><code>`All_bigger</code> if all elements of <code>a</code> are bigger than <code>key</code>.</li><li><code>`Just_after i</code> if <code>a.(i) < key < a.(i+1)</code>.</li><li><code>`Empty</code> if the array <code>a</code> is empty.</li></ul></li></ul><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if the array is found to be unsorted w.r.t <code>cmp</code>.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.13</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all2"><a href="#val-for_all2" class="anchor"></a><code><span><span class="keyword">val</span> for_all2 : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>for_all2 ~f [|a1; …; an|] [|b1; …; bn|]</code> is <code>true</code> if each pair of elements <code>ai bi</code> satisfies the predicate <code>f</code>. That is, it returns <code>(f a1 b1) && (f a2 b2) && … && (f an bn)</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if arrays have distinct lengths. Allow different types.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.20</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists2"><a href="#val-exists2" class="anchor"></a><code><span><span class="keyword">val</span> exists2 : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>exists2 ~f [|a1; …; an|] [|b1; …; bn|]</code> is <code>true</code> if any pair of elements <code>ai bi</code> satisfies the predicate <code>f</code>. That is, it returns <code>(f a1 b1) || (f a2 b2) || … || (f an bn)</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if arrays have distinct lengths. Allow different types.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.20</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold2"><a href="#val-fold2" class="anchor"></a><code><span><span class="keyword">val</span> fold2 : <span><span class="label">f</span>:<span>(<span><span class="type-var">'acc</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">-></span></span> <span><span class="label">init</span>:<span class="type-var">'acc</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span class="type-var">'acc</span></span></code></div><div class="spec-doc"><p><code>fold2 ~f ~init a b</code> fold on two arrays <code>a</code> and <code>b</code> stepwise. It computes <code>f (… (f init a1 b1) …) an bn</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> and <code>b</code> have distinct lengths.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.20</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span><span class="keyword">val</span> iter2 : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>iter2 ~f a b</code> iterates on the two arrays <code>a</code> and <code>b</code> stepwise. It is equivalent to <code>f a0 b0; …; f a.(length a - 1) b.(length b - 1); ()</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> and <code>b</code> have distinct lengths.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.20</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shuffle"><a href="#val-shuffle" class="anchor"></a><code><span><span class="keyword">val</span> shuffle : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>shuffle a</code> randomly shuffles the array <code>a</code>, in place.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shuffle_with"><a href="#val-shuffle_with" class="anchor"></a><code><span><span class="keyword">val</span> shuffle_with : <span><a href="../../ocaml/Stdlib/Random/State/index.html#type-t">Stdlib.Random.State.t</a> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>shuffle_with rs a</code> randomly shuffles the array <code>a</code> (like <a href="#val-shuffle"><code>shuffle</code></a>) but a specialized random state <code>rs</code> is used to control the random numbers being produced during shuffling (for reproducibility).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-random_choose"><a href="#val-random_choose" class="anchor"></a><code><span><span class="keyword">val</span> random_choose : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-random_gen">random_gen</a></span></span></code></div><div class="spec-doc"><p><code>random_choose a rs</code> randomly chooses an element of <code>a</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Not_found</code> <p>if the array/slice is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><span class="optlabel">?sep</span>:string <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> string)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">-></span></span> string</span></code></div><div class="spec-doc"><p><code>to_string ~sep item_to_string a</code> print <code>a</code> to a string using <code>sep</code> as a separator between elements of <code>a</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.7</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_iter"><a href="#val-to_iter" class="anchor"></a><code><span><span class="keyword">val</span> to_iter : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-iter">iter</a></span></span></code></div><div class="spec-doc"><p><code>to_iter a</code> returns an <code>iter</code> of the elements of an array <code>a</code>. The input array <code>a</code> is shared with the sequence and modification of it will result in modification of the iterator.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="../../ocaml/Stdlib/Seq/index.html#type-t">Stdlib.Seq.t</a></span></span></code></div><div class="spec-doc"><p><code>to_seq a</code> returns a <code>Seq.t</code> of the elements of an array <code>a</code>. The input array <code>a</code> is shared with the sequence and modification of it will result in modification of the sequence. Renamed from <code>to_std_seq</code> since 3.0.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_gen"><a href="#val-to_gen" class="anchor"></a><code><span><span class="keyword">val</span> to_gen : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-gen">gen</a></span></span></code></div><div class="spec-doc"><p><code>to_gen a</code> returns a <code>gen</code> of the elements of an array <code>a</code>.</p></div></div><h3 id="io"><a href="#io" class="anchor"></a>IO</h3><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp :
|
||
<span><span class="optlabel">?pp_start</span>:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span class="optlabel">?pp_stop</span>:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span class="optlabel">?pp_sep</span>:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'a</span> <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-printer">printer</a></span></span></code></div><div class="spec-doc"><p><code>pp ~pp_start ~pp_stop ~pp_sep pp_item ppf a</code> formats the array <code>a</code> on <code>ppf</code>. Each element is formatted with <code>pp_item</code>, <code>pp_start</code> is called at the beginning, <code>pp_stop</code> is called at the end, <code>pp_sep</code> is called between each elements. By defaults <code>pp_start</code> and <code>pp_stop</code> does nothing and <code>pp_sep</code> defaults to (fun out -> Format.fprintf out ",@ ").</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_i"><a href="#val-pp_i" class="anchor"></a><code><span><span class="keyword">val</span> pp_i :
|
||
<span><span class="optlabel">?pp_start</span>:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span class="optlabel">?pp_stop</span>:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span class="optlabel">?pp_sep</span>:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span>(<span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-printer">printer</a></span>)</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-printer">printer</a></span></span></code></div><div class="spec-doc"><p><code>pp_i ~pp_start ~pp_stop ~pp_sep pp_item ppf a</code> prints the array <code>a</code> on <code>ppf</code>. The printing function <code>pp_item</code> is giving both index and element. <code>pp_start</code> is called at the beginning, <code>pp_stop</code> is called at the end, <code>pp_sep</code> is called between each elements. By defaults <code>pp_start</code> and <code>pp_stop</code> does nothing and <code>pp_sep</code> defaults to (fun out -> Format.fprintf out ",@ ").</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>map2 ~f a b</code> applies function <code>f</code> to all elements of <code>a</code> and <code>b</code>, and builds an array with the results returned by <code>f</code>: <code>[| f a.(0) b.(0); …; f a.(length a - 1) b.(length b - 1)|]</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <code>Invalid_argument</code> <p>if <code>a</code> and <code>b</code> have distinct lengths.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.20</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev"><a href="#val-rev" class="anchor"></a><code><span><span class="keyword">val</span> rev : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>rev a</code> copies the array <code>a</code> and reverses it in place.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.20</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span><span class="keyword">val</span> filter : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>filter ~f a</code> filters elements out of the array <code>a</code>. Only the elements satisfying the given predicate <code>f</code> will be kept.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span><span class="keyword">val</span> filter_map : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>filter_map ~f [|a1; …; an|]</code> calls <code>(f a1) … (f an)</code> and returns an array <code>b</code> consisting of all elements <code>bi</code> such as <code>f ai = Some bi</code>. When <code>f</code> returns <code>None</code>, the corresponding element of <code>a</code> is discarded.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-monoid_product"><a href="#val-monoid_product" class="anchor"></a><code><span><span class="keyword">val</span> monoid_product : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>monoid_product ~f a b</code> passes all combinaisons of tuples from the two arrays <code>a</code> and <code>b</code> to the function <code>f</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flat_map"><a href="#val-flat_map" class="anchor"></a><code><span><span class="keyword">val</span> flat_map : <span><span class="label">f</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> array</span></span></code></div><div class="spec-doc"><p><code>flat_map ~f a</code> transforms each element of <code>a</code> into an array, then flattens.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-except_idx"><a href="#val-except_idx" class="anchor"></a><code><span><span class="keyword">val</span> except_idx : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>except_idx a i</code> removes the element of <code>a</code> at given index <code>i</code>, and returns the list of the other elements.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-random"><a href="#val-random" class="anchor"></a><code><span><span class="keyword">val</span> random : <span><span><span class="type-var">'a</span> <a href="#type-random_gen">random_gen</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-random_gen">random_gen</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-random_non_empty"><a href="#val-random_non_empty" class="anchor"></a><code><span><span class="keyword">val</span> random_non_empty : <span><span><span class="type-var">'a</span> <a href="#type-random_gen">random_gen</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-random_gen">random_gen</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-random_len"><a href="#val-random_len" class="anchor"></a><code><span><span class="keyword">val</span> random_len : <span>int <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-random_gen">random_gen</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-random_gen">random_gen</a></span></span></code></div></div><h3 id="generic-functions"><a href="#generic-functions" class="anchor"></a>Generic Functions</h3><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-MONO_ARRAY"><a href="#module-type-MONO_ARRAY" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-MONO_ARRAY/index.html">MONO_ARRAY</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort_generic"><a href="#val-sort_generic" class="anchor"></a><code><span><span class="keyword">val</span> sort_generic :
|
||
<span><span>(<span class="keyword">module</span> <a href="module-type-MONO_ARRAY/index.html">MONO_ARRAY</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="module-type-MONO_ARRAY/index.html#type-elt">elt</a> = <span class="type-var">'elt</span> <span class="keyword">and</span> <span class="keyword">type</span> <a href="module-type-MONO_ARRAY/index.html#type-t">t</a> = <span class="type-var">'arr</span>)</span> <span class="arrow">-></span></span>
|
||
<span><span class="label">cmp</span>:<span>(<span><span class="type-var">'elt</span> <span class="arrow">-></span></span> <span><span class="type-var">'elt</span> <span class="arrow">-></span></span> int)</span> <span class="arrow">-></span></span>
|
||
<span><span class="type-var">'arr</span> <span class="arrow">-></span></span>
|
||
unit</span></code></div><div class="spec-doc"><p><code>sort_generic (module M) ~cmp a</code> sorts the array <code>a</code>, without allocating (eats stack space though). Performance might be lower than <code>Array.sort</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.14</li></ul></div></div><h4 id="infix-operators"><a href="#infix-operators" class="anchor"></a>Infix Operators</h4><p>It is convenient to <code>open CCArray.Infix</code> to access the infix operators without cluttering the scope too much.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.7</li></ul><div class="odoc-spec"><div class="spec module anchored" id="module-Infix"><a href="#module-Infix" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Infix/index.html">Infix</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <a href="Infix/index.html">Infix</a></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-(>>=)"><a href="#val-(>>=)" class="anchor"></a><code><span><span class="keyword">val</span> (>>=) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>a >>= f</code> is the infix version of <a href="#val-flat_map"><code>flat_map</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>>|)"><a href="#val-(>>|)" class="anchor"></a><code><span><span class="keyword">val</span> (>>|) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>a >>| f</code> is the infix version of <a href="#val-map"><code>map</code></a>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>|=)"><a href="#val-(>|=)" class="anchor"></a><code><span><span class="keyword">val</span> (>|=) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>a >|= f</code> is the infix version of <a href="#val-map"><code>map</code></a>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(--)"><a href="#val-(--)" class="anchor"></a><code><span><span class="keyword">val</span> (--) : <span>int <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span>int <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>x -- y</code> creates an array containing integers in the range <code>x .. y</code>. Bounds included.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(--^)"><a href="#val-(--^)" class="anchor"></a><code><span><span class="keyword">val</span> (--^) : <span>int <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span>int <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>x --^ y</code> creates an array containing integers in the range <code>x .. y</code>. Right bound excluded.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.17</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-let+"><a href="#val-let+" class="anchor"></a><code><span><span class="keyword">val</span> let+ : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-and+"><a href="#val-and+" class="anchor"></a><code><span><span class="keyword">val</span> and+ : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-let*"><a href="#val-let*" class="anchor"></a><code><span><span class="keyword">val</span> let* : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-and*"><a href="#val-and*" class="anchor"></a><code><span><span class="keyword">val</span> and* : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div></details></div></div></body></html>
|