mirror of
https://github.com/c-cube/moonpool.git
synced 2025-12-17 08:06:43 -05:00
16 lines
No EOL
53 KiB
HTML
16 lines
No EOL
53 KiB
HTML
<!DOCTYPE html>
|
||
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ListLabels (ocaml.Stdlib.ListLabels)</title><link rel="stylesheet" href="../../../_odoc-theme/odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 2.2.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">ocaml</a> » <a href="../index.html">Stdlib</a> » ListLabels</nav><header class="odoc-preamble"><h1>Module <code><span>Stdlib.ListLabels</span></code></h1><p>List operations.</p><p>Some functions are flagged as not tail-recursive. A tail-recursive function uses constant stack space, while a non-tail-recursive function uses stack space proportional to the length of its list argument, which can be a problem with very long lists. When the function takes several list arguments, an approximate formula giving stack usage (in some unspecified constant unit) is shown in parentheses.</p><p>The above considerations can usually be ignored if your lists are not longer than about 10000 elements.</p><p>The labeled version of this module can be used as described in the <a href="../StdLabels/index.html"><code>StdLabels</code></a> module.</p></header><nav class="odoc-toc"><ul><li><a href="#comparison">Comparison</a></li><li><a href="#iterators">Iterators</a></li><li><a href="#iterators-on-two-lists">Iterators on two lists</a></li><li><a href="#list-scanning">List scanning</a></li><li><a href="#list-searching">List searching</a></li><li><a href="#association-lists">Association lists</a></li><li><a href="#lists-of-pairs">Lists of pairs</a></li><li><a href="#sorting">Sorting</a></li><li><a href="#lists-and-sequences">Lists and Sequences</a></li></ul></nav><div class="odoc-content"><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> list</span></span><span> = </span></code><ol><li id="type-t.[]" class="def variant constructor anchored"><a href="#type-t.[]" class="anchor"></a><code><span>| </span><span><span class="constructor">[]</span></span></code></li><li id="type-t.::" class="def variant constructor anchored"><a href="#type-t.::" class="anchor"></a><code><span>| </span><span><span class="constructor">::</span> <span class="keyword">of</span> <span class="type-var">'a</span> * <span><span class="type-var">'a</span> list</span></span></code></li></ol></div><div class="spec-doc"><p>An alias for the type of lists.</p></div></div><div class="odoc-spec"><div class="spec value 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> list</span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p>Return the length (number of elements) of the given list.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare_lengths"><a href="#val-compare_lengths" class="anchor"></a><code><span><span class="keyword">val</span> compare_lengths : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p>Compare the lengths of two lists. <code>compare_lengths l1 l2</code> is equivalent to <code>compare (length l1) (length l2)</code>, except that the computation stops after reaching the end of the shortest list.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare_length_with"><a href="#val-compare_length_with" class="anchor"></a><code><span><span class="keyword">val</span> compare_length_with : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span>len:int <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p>Compare the length of a list to an integer. <code>compare_length_with l len</code> is equivalent to <code>compare (length l) len</code>, except that the computation stops after at most <code>len</code> iterations on the list.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cons"><a href="#val-cons" class="anchor"></a><code><span><span class="keyword">val</span> cons : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>cons x xs</code> is <code>x :: xs</code></p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hd"><a href="#val-hd" class="anchor"></a><code><span><span class="keyword">val</span> hd : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Return the first element of the given list.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Failure</span> <p>if the list is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tl"><a href="#val-tl" class="anchor"></a><code><span><span class="keyword">val</span> tl : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Return the given list without its first element.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Failure</span> <p>if the list is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nth"><a href="#val-nth" class="anchor"></a><code><span><span class="keyword">val</span> nth : <span><span><span class="type-var">'a</span> list</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>Return the <code>n</code>-th element of the given list. The first element (head of the list) is at position 0.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Failure</span> <p>if the list is too short.</p></li></ul><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if <code>n</code> is negative.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nth_opt"><a href="#val-nth_opt" class="anchor"></a><code><span><span class="keyword">val</span> nth_opt : <span><span><span class="type-var">'a</span> list</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>Return the <code>n</code>-th element of the given list. The first element (head of the list) is at position 0. Return <code>None</code> if the list is too short.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if <code>n</code> is negative.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05</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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>List reversal.</p></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>len:int <span class="arrow">-></span></span> <span>f:<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> list</span></span></code></div><div class="spec-doc"><p><code>init ~len ~f</code> is <code>f 0; f 1; ...; f (len-1)</code>, evaluated left to right.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if <code>len < 0</code>.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.06.0</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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Concatenate two lists. Same function as the infix operator <code>@</code>. Not tail-recursive (length of the first argument). The <code>@</code> operator is not tail-recursive either.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev_append"><a href="#val-rev_append" class="anchor"></a><code><span><span class="keyword">val</span> rev_append : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>rev_append l1 l2</code> reverses <code>l1</code> and concatenates it with <code>l2</code>. This is equivalent to <code>(</code><a href="#val-rev"><code>rev</code></a><code> l1) @ l2</code>, but <code>rev_append</code> is tail-recursive and more efficient.</p></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> list</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result. Not tail-recursive (length of the argument + length of the longest sub-list).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten"><a href="#val-flatten" class="anchor"></a><code><span><span class="keyword">val</span> flatten : <span><span><span><span class="type-var">'a</span> list</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-concat"><code>concat</code></a>. Not tail-recursive (length of the argument + length of the longest sub-list).</p></div></div><h2 id="comparison"><a href="#comparison" class="anchor"></a>Comparison</h2><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>eq:<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><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>equal eq [a1; ...; an] [b1; ..; bm]</code> holds when the two input lists have the same length, and for each pair of elements <code>ai</code>, <code>bi</code> at the same position we have <code>eq ai bi</code>.</p><p>Note: the <code>eq</code> function may be called even if the lists have different length. If you know your equality function is costly, you may want to check <a href="#val-compare_lengths"><code>compare_lengths</code></a> first.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.12.0</li></ul></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>cmp:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p><code>compare cmp [a1; ...; an] [b1; ...; bm]</code> performs a lexicographic comparison of the two input lists, using the same <code>'a -> 'a -> int</code> interface as <a href="../index.html#val-compare"><code>Stdlib.compare</code></a>:</p><ul><li><code>a1 :: l1</code> is smaller than <code>a2 :: l2</code> (negative result) if <code>a1</code> is smaller than <code>a2</code>, or if they are equal (0 result) and <code>l1</code> is smaller than <code>l2</code></li><li>the empty list <code>[]</code> is strictly smaller than non-empty lists</li></ul><p>Note: the <code>cmp</code> function will be called even if the lists have different lengths.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.12.0</li></ul></div></div><h2 id="iterators"><a href="#iterators" class="anchor"></a>Iterators</h2><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>f:<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> list</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>iter ~f [a1; ...; an]</code> applies function <code>f</code> in turn to <code>a1; ...; an</code>. It is equivalent to <code>begin f a1; f a2; ...; f an; () end</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>f:<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> list</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 (counting from 0), and the element itself as second argument.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.00.0</li></ul></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>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p><code>map ~f [a1; ...; an]</code> applies function <code>f</code> to <code>a1, ..., an</code>, and builds the list <code>[f a1; ...; f an]</code> with the results returned by <code>f</code>. Not tail-recursive.</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>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</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 (counting from 0), and the element itself as second argument. Not tail-recursive.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.00.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev_map"><a href="#val-rev_map" class="anchor"></a><code><span><span class="keyword">val</span> rev_map : <span>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p><code>rev_map ~f l</code> gives the same result as <a href="#val-rev"><code>rev</code></a><code> (</code><a href="#val-map"><code>map</code></a><code> f l)</code>, but is tail-recursive and more efficient.</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>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p><code>filter_map ~f l</code> applies <code>f</code> to every element of <code>l</code>, filters out the <code>None</code> elements and returns the list of the arguments of the <code>Some</code> elements.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.08.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_map"><a href="#val-concat_map" class="anchor"></a><code><span><span class="keyword">val</span> concat_map : <span>f:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p><code>concat_map ~f l</code> gives the same result as <a href="#val-concat"><code>concat</code></a><code> (</code><a href="#val-map"><code>map</code></a><code> f l)</code>. Tail-recursive.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.10.0</li></ul></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>f:<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>init:<span class="type-var">'a</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span>
|
||
<span class="type-var">'a</span> * <span><span class="type-var">'c</span> list</span></span></code></div><div class="spec-doc"><p><code>fold_left_map</code> is a combination of <code>fold_left</code> and <code>map</code> 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.11.0</li></ul></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>f:<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>init:<span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</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 [b1; ...; bn]</code> is <code>f (... (f (f init b1) b2) ...) bn</code>.</p></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>f:<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">'b</span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span>init:<span class="type-var">'b</span> <span class="arrow">-></span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p><code>fold_right ~f [a1; ...; an] ~init</code> is <code>f a1 (f a2 (... (f an init) ...))</code>. Not tail-recursive.</p></div></div><h2 id="iterators-on-two-lists"><a href="#iterators-on-two-lists" class="anchor"></a>Iterators on two lists</h2><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>f:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>iter2 ~f [a1; ...; an] [b1; ...; bn]</code> calls in turn <code>f a1 b1; ...; f an bn</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists are determined to have different lengths.</p></li></ul></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>f:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> list</span></span></code></div><div class="spec-doc"><p><code>map2 ~f [a1; ...; an] [b1; ...; bn]</code> is <code>[f a1 b1; ...; f an bn]</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists are determined to have different lengths. Not tail-recursive.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev_map2"><a href="#val-rev_map2" class="anchor"></a><code><span><span class="keyword">val</span> rev_map2 : <span>f:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> list</span></span></code></div><div class="spec-doc"><p><code>rev_map2 ~f l1 l2</code> gives the same result as <a href="#val-rev"><code>rev</code></a><code> (</code><a href="#val-map2"><code>map2</code></a><code> f l1 l2)</code>, but is tail-recursive and more efficient.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left2"><a href="#val-fold_left2" class="anchor"></a><code><span><span class="keyword">val</span> fold_left2 :
|
||
<span>f:<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><span class="type-var">'c</span> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span>
|
||
<span>init:<span class="type-var">'a</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'c</span> list</span> <span class="arrow">-></span></span>
|
||
<span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn]</code> is <code>f (... (f (f init a1 b1) a2 b2) ...) an bn</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists are determined to have different lengths.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right2"><a href="#val-fold_right2" class="anchor"></a><code><span><span class="keyword">val</span> fold_right2 :
|
||
<span>f:<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><span class="type-var">'c</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> list</span> <span class="arrow">-></span></span>
|
||
<span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span>
|
||
<span>init:<span class="type-var">'c</span> <span class="arrow">-></span></span>
|
||
<span class="type-var">'c</span></span></code></div><div class="spec-doc"><p><code>fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init</code> is <code>f a1 b1 (f a2 b2 (... (f an bn init) ...))</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists are determined to have different lengths. Not tail-recursive.</p></li></ul></div></div><h2 id="list-scanning"><a href="#list-scanning" class="anchor"></a>List scanning</h2><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>f:<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> list</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 list satisfy the predicate <code>f</code>. That is, it returns <code>(f a1) && (f a2) && ... && (f an)</code> for a non-empty list and <code>true</code> if the list is empty.</p></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>f:<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> list</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 list satisfies the predicate <code>f</code>. That is, it returns <code>(f a1) || (f a2) || ... || (f an)</code> for a non-empty list and <code>false</code> if the list is empty.</p></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>f:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p>Same as <a href="#val-for_all"><code>for_all</code></a>, but for a two-argument predicate.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists are determined to have different lengths.</p></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>f:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p>Same as <a href="#val-exists"><code>exists</code></a>, but for a two-argument predicate.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists are determined to have different lengths.</p></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="type-var">'a</span> <span class="arrow">-></span></span> <span>set:<span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>mem a ~set</code> is true if and only if <code>a</code> is equal to an element of <code>set</code>.</p></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>set:<span><span class="type-var">'a</span> list</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></div></div><h2 id="list-searching"><a href="#list-searching" class="anchor"></a>List searching</h2><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span>f:<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> list</span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>find ~f l</code> returns the first element of the list <code>l</code> that satisfies the predicate <code>f</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Not_found</span> <p>if there is no value that satisfies <code>f</code> in the list <code>l</code>.</p></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>f:<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> list</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 ~f l</code> returns the first element of the list <code>l</code> that satisfies the predicate <code>f</code>. Returns <code>None</code> if there is no value that satisfies <code>f</code> in the list <code>l</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05</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>f:<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> list</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 l</code> applies <code>f</code> to the elements of <code>l</code> in order, and returns the first result of the form <code>Some v</code>, or <code>None</code> if none exist.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.10.0</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>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>filter ~f l</code> returns all the elements of the list <code>l</code> that satisfy the predicate <code>f</code>. The order of the elements in the input list is preserved.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>find_all</code> is another name for <a href="#val-filter"><code>filter</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filteri"><a href="#val-filteri" class="anchor"></a><code><span><span class="keyword">val</span> filteri : <span>f:<span>(<span>int <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><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-filter"><code>filter</code></a>, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.11.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition"><a href="#val-partition" class="anchor"></a><code><span><span class="keyword">val</span> partition : <span>f:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span> * <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>partition ~f l</code> returns a pair of lists <code>(l1, l2)</code>, where <code>l1</code> is the list of all the elements of <code>l</code> that satisfy the predicate <code>f</code>, and <code>l2</code> is the list of all the elements of <code>l</code> that do not satisfy <code>f</code>. The order of the elements in the input list is preserved.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition_map"><a href="#val-partition_map" class="anchor"></a><code><span><span class="keyword">val</span> partition_map : <span>f:<span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'c</span>)</span> <a href="../Either/index.html#type-t">Either.t</a></span>)</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> list</span> * <span><span class="type-var">'c</span> list</span></span></code></div><div class="spec-doc"><p><code>partition_map f l</code> returns a pair of lists <code>(l1, l2)</code> such that, for each element <code>x</code> of the input list <code>l</code>:</p><ul><li>if <code>f x</code> is <code>Left y1</code>, then <code>y1</code> is in <code>l1</code>, and</li><li>if <code>f x</code> is <code>Right y2</code>, then <code>y2</code> is in <code>l2</code>.</li></ul><p>The output elements are included in <code>l1</code> and <code>l2</code> in the same relative order as the corresponding input elements in <code>l</code>.</p><p>In particular, <code>partition_map (fun x -> if f x then Left x else Right x) l</code> is equivalent to <code>partition f l</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.12.0</li></ul></div></div><h2 id="association-lists"><a href="#association-lists" class="anchor"></a>Association lists</h2><div class="odoc-spec"><div class="spec value anchored" id="val-assoc"><a href="#val-assoc" class="anchor"></a><code><span><span class="keyword">val</span> assoc : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p><code>assoc a l</code> returns the value associated with key <code>a</code> in the list of pairs <code>l</code>. That is, <code>assoc a [ ...; (a,b); ...] = b</code> if <code>(a,b)</code> is the leftmost binding of <code>a</code> in list <code>l</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Not_found</span> <p>if there is no value associated with <code>a</code> in the list <code>l</code>.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assoc_opt"><a href="#val-assoc_opt" class="anchor"></a><code><span><span class="keyword">val</span> assoc_opt : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p><code>assoc_opt a l</code> returns the value associated with key <code>a</code> in the list of pairs <code>l</code>. That is, <code>assoc_opt a [ ...; (a,b); ...] = Some b</code> if <code>(a,b)</code> is the leftmost binding of <code>a</code> in list <code>l</code>. Returns <code>None</code> if there is no value associated with <code>a</code> in the list <code>l</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assq"><a href="#val-assq" class="anchor"></a><code><span><span class="keyword">val</span> assq : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-assoc"><code>assoc</code></a>, but uses physical equality instead of structural equality to compare keys.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assq_opt"><a href="#val-assq_opt" class="anchor"></a><code><span><span class="keyword">val</span> assq_opt : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-assoc_opt"><code>assoc_opt</code></a>, but uses physical equality instead of structural equality to compare keys.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.05.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_assoc"><a href="#val-mem_assoc" class="anchor"></a><code><span><span class="keyword">val</span> mem_assoc : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span>map:<span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p>Same as <a href="#val-assoc"><code>assoc</code></a>, but simply return <code>true</code> if a binding exists, and <code>false</code> if no bindings exist for the given key.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_assq"><a href="#val-mem_assq" class="anchor"></a><code><span><span class="keyword">val</span> mem_assq : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span>map:<span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p>Same as <a href="#val-mem_assoc"><code>mem_assoc</code></a>, but uses physical equality instead of structural equality to compare keys.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_assoc"><a href="#val-remove_assoc" class="anchor"></a><code><span><span class="keyword">val</span> remove_assoc : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div><div class="spec-doc"><p><code>remove_assoc a l</code> returns the list of pairs <code>l</code> without the first pair with key <code>a</code>, if any. Not tail-recursive.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_assq"><a href="#val-remove_assq" class="anchor"></a><code><span><span class="keyword">val</span> remove_assq : <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-remove_assoc"><code>remove_assoc</code></a>, but uses physical equality instead of structural equality to compare keys. Not tail-recursive.</p></div></div><h2 id="lists-of-pairs"><a href="#lists-of-pairs" class="anchor"></a>Lists of pairs</h2><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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span> * <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p>Transform a list of pairs into a pair of lists: <code>split [(a1,b1); ...; (an,bn)]</code> is <code>([a1; ...; an], [b1; ...; bn])</code>. Not tail-recursive.</p></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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div><div class="spec-doc"><p>Transform a pair of lists into a list of pairs: <code>combine [a1; ...; an] [b1; ...; bn]</code> is <code>[(a1,b1); ...; (an,bn)]</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if the two lists have different lengths. Not tail-recursive.</p></li></ul></div></div><h2 id="sorting"><a href="#sorting" class="anchor"></a>Sorting</h2><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>cmp:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Sort a list 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 Array.sort for a complete specification). For example, <a href="../index.html#val-compare"><code>Stdlib.compare</code></a> is a suitable comparison function. The resulting list is sorted in increasing order. <a href="#val-sort"><code>sort</code></a> is guaranteed to run in constant heap space (in addition to the size of the result list) and logarithmic stack space.</p><p>The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.</p></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>cmp:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-sort"><code>sort</code></a>, but the sorting algorithm is guaranteed to be stable (i.e. elements that compare equal are kept in their original order).</p><p>The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.</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>cmp:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></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><div class="odoc-spec"><div class="spec value anchored" id="val-sort_uniq"><a href="#val-sort_uniq" class="anchor"></a><code><span><span class="keyword">val</span> sort_uniq : <span>cmp:<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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-sort"><code>sort</code></a>, but also remove duplicates.</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-merge"><a href="#val-merge" class="anchor"></a><code><span><span class="keyword">val</span> merge : <span>cmp:<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> list</span> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Merge two lists: Assuming that <code>l1</code> and <code>l2</code> are sorted according to the comparison function <code>cmp</code>, <code>merge ~cmp l1 l2</code> will return a sorted list containing all the elements of <code>l1</code> and <code>l2</code>. If several elements compare equal, the elements of <code>l1</code> will be before the elements of <code>l2</code>. Not tail-recursive (sum of the lengths of the arguments).</p></div></div><h2 id="lists-and-sequences"><a href="#lists-and-sequences" class="anchor"></a>Lists and Sequences</h2><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> list</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="../Seq/index.html#type-t">Seq.t</a></span></span></code></div><div class="spec-doc"><p>Iterate on the list.</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="../Seq/index.html#type-t">Seq.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Create a list from a sequence.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.07</li></ul></div></div></div></body></html> |