mirror of
https://github.com/c-cube/ocaml-containers.git
synced 2025-12-06 11:15:31 -05:00
7 lines
No EOL
71 KiB
HTML
7 lines
No EOL
71 KiB
HTML
<!DOCTYPE html>
|
||
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCSeq (containers.CCSeq)</title><link rel="stylesheet" href="../../_odoc-theme/odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 2.2.0"/><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> » CCSeq</nav><header class="odoc-preamble"><h1>Module <code><span>CCSeq</span></code></h1><p>Helpers for the standard <b>Seq</b> type</p><p>See <a href="https://github.com/c-cube/oseq/">oseq</a> for a richer API.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></header><nav class="odoc-toc"><ul><li><a href="#basics">Basics</a><ul><li><a href="#consuming-sequences">Consuming sequences</a></li><li><a href="#constructing-sequences">Constructing sequences</a></li><li><a href="#transforming-sequences">Transforming sequences</a></li><li><a href="#combining-sequences">Combining sequences</a></li><li><a href="#splitting-a-sequence-into-two-sequences">Splitting a sequence into two sequences</a></li><li><a href="#converting-between-sequences-and-dispensers">Converting between sequences and dispensers</a></li><li><a href="#sequences-of-integers">Sequences of integers</a></li></ul></li><li><a href="#operations-on-two-collections">Operations on two Collections</a></li><li><a href="#misc">Misc</a></li><li><a href="#fair-combinations">Fair Combinations</a></li><li><a href="#implementations">Implementations</a></li><li><a href="#infix-operators">Infix operators</a></li><li><a href="#conversions">Conversions</a></li><li><a href="#io">IO</a></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><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-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="basics"><a href="#basics" class="anchor"></a>Basics</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>unit <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <a href="#type-node">node</a></span></span></code></div><div class="spec-doc"><p>A sequence <code>xs</code> of type <code>'a t</code> is a delayed list of elements of type <code>'a</code>. Such a sequence is queried by performing a function application <code>xs()</code>. This function application returns a node, allowing the caller to determine whether the sequence is empty or nonempty, and in the latter case, to obtain its head and tail.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-node"><a href="#type-node" class="anchor"></a><code><span><span class="keyword">and</span> <span>+'a node</span></span><span> = </span></code><ol><li id="type-node.Nil" class="def variant constructor anchored"><a href="#type-node.Nil" class="anchor"></a><code><span>| </span><span><span class="constructor">Nil</span></span></code></li><li id="type-node.Cons" class="def variant constructor anchored"><a href="#type-node.Cons" class="anchor"></a><code><span>| </span><span><span class="constructor">Cons</span> <span class="keyword">of</span> <span class="type-var">'a</span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></li></ol></div><div class="spec-doc"><p>A node is either <code>Nil</code>, which means that the sequence is empty, or <code>Cons (x, xs)</code>, which means that <code>x</code> is the first element of the sequence and that <code>xs</code> is the remainder of the sequence.</p></div></div><h4 id="consuming-sequences"><a href="#consuming-sequences" class="anchor"></a>Consuming sequences</h4><p>The functions in this section consume their argument, a sequence, either partially or completely:</p><ul><li><code>is_empty</code> and <code>uncons</code> consume the sequence down to depth 1. That is, they demand the first argument of the sequence, if there is one.</li><li><code>iter</code>, <code>fold_left</code>, <code>length</code>, etc., consume the sequence all the way to its end. They terminate only if the sequence is finite.</li><li><code>for_all</code>, <code>exists</code>, <code>find</code>, etc. consume the sequence down to a certain depth, which is a priori unpredictable.</li></ul><p>Similarly, among the functions that consume two sequences, one can distinguish two groups:</p><ul><li><code>iter2</code> and <code>fold_left2</code> consume both sequences all the way to the end, provided the sequences have the same length.</li><li><code>for_all2</code>, <code>exists2</code>, <code>equal</code>, <code>compare</code> consume the sequences down to a certain depth, which is a priori unpredictable.</li></ul><p>The functions that consume two sequences can be applied to two sequences of distinct lengths: in that case, the excess elements in the longer sequence are ignored. (It may be the case that one excess element is demanded, even though this element is not used.)</p><p>None of the functions in this section is lazy. These functions are consumers: they force some computation to take place.</p><h4 id="constructing-sequences"><a href="#constructing-sequences" class="anchor"></a>Constructing sequences</h4><p>The functions in this section are lazy: that is, they return sequences whose elements are computed only when demanded.</p><h4 id="transforming-sequences"><a href="#transforming-sequences" class="anchor"></a>Transforming sequences</h4><p>The functions in this section are lazy: that is, they return sequences whose elements are computed only when demanded.</p><div class="odoc-spec"><div class="spec exception anchored" id="exception-Forced_twice"><a href="#exception-Forced_twice" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Forced_twice</span></span></code></div><div class="spec-doc"><p>This exception is raised when a sequence returned by <a href="#val-once"><code>once</code></a> (or a suffix of it) is queried more than once.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-once"><a href="#val-once" class="anchor"></a><code><span><span class="keyword">val</span> once : <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>The sequence <code>once xs</code> has the same elements as the sequence <code>xs</code>.</p><p>Regardless of whether <code>xs</code> is ephemeral or persistent, <code>once xs</code> is an ephemeral sequence: it can be queried at most once. If it (or a suffix of it) is queried more than once, then the exception <code>Forced_twice</code> is raised. This can be useful, while debugging or testing, to ensure that a sequence is consumed at most once.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Forced_twice</span> <p>if <code>once xs</code>, or a suffix of it, is queried more than once.</p></li></ul><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose"><a href="#val-transpose" class="anchor"></a><code><span><span class="keyword">val</span> transpose : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</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-t">t</a></span></span></code></div><div class="spec-doc"><p>If <code>xss</code> is a matrix (a sequence of rows), then <code>transpose xss</code> is the sequence of the columns of the matrix <code>xss</code>.</p><p>The rows of the matrix <code>xss</code> are not required to have the same length.</p><p>The matrix <code>xss</code> is not required to be finite (in either direction).</p><p>The matrix <code>xss</code> must be persistent.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><h4 id="combining-sequences"><a href="#combining-sequences" class="anchor"></a>Combining sequences</h4><h4 id="splitting-a-sequence-into-two-sequences"><a href="#splitting-a-sequence-into-two-sequences" class="anchor"></a>Splitting a sequence into two sequences</h4><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><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="../../ocaml/Stdlib/Either/index.html#type-t">Stdlib.Either.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> <a href="#type-t">t</a></span> * <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>partition_map f xs</code> returns a pair of sequences <code>(ys, zs)</code>, where:</p><ul><li><code>ys</code> is the sequence of the elements <code>y</code> such that <code>f x = Left y</code>, where <code>x</code> ranges over <code>xs</code>;</li></ul><ul><li><code>zs</code> is the sequence of the elements <code>z</code> such that <code>f x = Right z</code>, where <code>x</code> ranges over <code>xs</code>.</li></ul><p><code>partition_map f xs</code> is equivalent to a pair of <code>filter_map Either.find_left (map f xs)</code> and <code>filter_map Either.find_right (map f xs)</code>.</p><p>Querying either of the sequences returned by <code>partition_map f xs</code> causes <code>xs</code> to be queried. Therefore, querying both of them causes <code>xs</code> to be queried twice. Thus, <code>xs</code> must be persistent and cheap. If that is not the case, use <code>partition_map f (memoize xs)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</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><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><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>partition p xs</code> returns a pair of the subsequence of the elements of <code>xs</code> that satisfy <code>p</code> and the subsequence of the elements of <code>xs</code> that do not satisfy <code>p</code>.</p><p><code>partition p xs</code> is equivalent to <code>filter p xs, filter (fun x -> not (p x)) xs</code>.</p><p>Consuming both of the sequences returned by <code>partition p xs</code> causes <code>xs</code> to be consumed twice and causes the function <code>f</code> to be applied twice to each element of the list. Therefore, <code>f</code> should be pure and cheap. Furthermore, <code>xs</code> should be persistent and cheap. If that is not the case, use <code>partition p (memoize xs)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><h4 id="converting-between-sequences-and-dispensers"><a href="#converting-between-sequences-and-dispensers" class="anchor"></a>Converting between sequences and dispensers</h4><p>A dispenser is a representation of a sequence as a function of type <code>unit -> 'a option</code>. Every time this function is invoked, it returns the next element of the sequence. When there are no more elements, it returns <code>None</code>. A dispenser has mutable internal state, therefore is ephemeral: the sequence that it represents can be consumed at most once.</p><div class="odoc-spec"><div class="spec value anchored" id="val-of_dispenser"><a href="#val-of_dispenser" class="anchor"></a><code><span><span class="keyword">val</span> of_dispenser : <span><span>(<span>unit <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span>)</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>of_dispenser it</code> is the sequence of the elements produced by the dispenser <code>it</code>. It is an ephemeral sequence: it can be consumed at most once. If a persistent sequence is needed, use <code>memoize (of_dispenser it)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_dispenser"><a href="#val-to_dispenser" class="anchor"></a><code><span><span class="keyword">val</span> to_dispenser : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> <span>unit <span class="arrow">-></span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p><code>to_dispenser xs</code> is a fresh dispenser on the sequence <code>xs</code>.</p><p>This dispenser has mutable internal state, which is not protected by a lock; so, it must not be used by several threads concurrently.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><h4 id="sequences-of-integers"><a href="#sequences-of-integers" class="anchor"></a>Sequences of integers</h4><div class="odoc-spec"><div class="spec value anchored" id="val-ints"><a href="#val-ints" class="anchor"></a><code><span><span class="keyword">val</span> ints : <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>ints i</code> is the infinite sequence of the integers beginning at <code>i</code> and counting up.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 4.14</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nil"><a href="#val-nil" class="anchor"></a><code><span><span class="keyword">val</span> nil : <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></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><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> <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><div class="odoc-spec"><div class="spec value anchored" id="val-singleton"><a href="#val-singleton" class="anchor"></a><code><span><span class="keyword">val</span> singleton : <span><span class="type-var">'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><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>(<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> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>init n f</code> corresponds to the sequence <code>f 0; f 1; ...; f (n-1)</code>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Invalid_argument</span> <p>if n is negative.</p></li></ul><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-repeat"><a href="#val-repeat" class="anchor"></a><code><span><span class="keyword">val</span> repeat : <span>?n: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> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>repeat ~n x</code> repeats <code>x</code> <code>n</code> times then stops. If <code>n</code> is omitted, then <code>x</code> is repeated forever.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-forever"><a href="#val-forever" class="anchor"></a><code><span><span class="keyword">val</span> forever : <span><span>(<span>unit <span class="arrow">-></span></span> <span class="type-var">'a</span>)</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>forever f</code> corresponds to the infinite sequence containing all the <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-cycle"><a href="#val-cycle" class="anchor"></a><code><span><span class="keyword">val</span> cycle : <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>Cycle through the iterator infinitely. The iterator shouldn't be empty.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iterate"><a href="#val-iterate" class="anchor"></a><code><span><span class="keyword">val</span> iterate : <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 class="type-var">'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>iterate f a</code> corresponds to the infinite sequence containing <code>a</code>, <code>f a</code>, <code>f (f a)</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-unfold"><a href="#val-unfold" class="anchor"></a><code><span><span class="keyword">val</span> unfold : <span><span>(<span><span class="type-var">'b</span> <span class="arrow">-></span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'b</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>unfold f acc</code> calls <code>f acc</code> and:</p><ul><li>if <code>f acc = Some (x, acc')</code>, yield <code>x</code>, continue with <code>unfold f acc'</code>.</li><li>if <code>f acc = None</code>, stops.</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <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>is_empty xs</code> checks in the sequence <code>xs</code> is empty</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-head"><a href="#val-head" class="anchor"></a><code><span><span class="keyword">val</span> head : <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>Head of the list.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-head_exn"><a href="#val-head_exn" class="anchor"></a><code><span><span class="keyword">val</span> head_exn : <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>Unsafe version of <a href="#val-head"><code>head</code></a>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Not_found</span> <p>if the list is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tail"><a href="#val-tail" class="anchor"></a><code><span><span class="keyword">val</span> tail : <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">'a</span> <a href="#type-t">t</a></span> option</span></span></code></div><div class="spec-doc"><p>Tail of the list.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tail_exn"><a href="#val-tail_exn" class="anchor"></a><code><span><span class="keyword">val</span> tail_exn : <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>Unsafe version of <a href="#val-tail"><code>tail</code></a>.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <span class="value">Not_found</span> <p>if the list is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uncons"><a href="#val-uncons" class="anchor"></a><code><span><span class="keyword">val</span> uncons : <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">'a</span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span>)</span> option</span></span></code></div><div class="spec-doc"><p><code>uncons xs</code> return <code>None</code> if <code>xs</code> is empty other</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-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>Equality step by step. Eager.</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>Lexicographic comparison. Eager.</p></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>(<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="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>Fold on values.</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>(<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="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>Alias for <a href="#val-fold"><code>fold</code></a></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>(<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="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_lefti f init xs</code> applies <code>f acc i x</code> where <code>acc</code> is the result of the previous computation or <code>init</code> for the first one, <code>i</code> is the index in the sequence (starts at 0) and <code>x</code> is the element of the sequence.</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_lefti"><a href="#val-fold_lefti" class="anchor"></a><code><span><span class="keyword">val</span> fold_lefti : <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="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>Alias of <a href="#val-foldi"><code>foldi</code></a>.</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-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <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> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></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>(<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> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>Iterate with index (starts at 0).</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">_</span> <a href="#type-t">t</a></span> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p>Number of elements in the list. Will not terminate if the list if infinite: use (for instance) <a href="#val-take"><code>take</code></a> to make the list finite if necessary.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take"><a href="#val-take" class="anchor"></a><code><span><span class="keyword">val</span> take : <span>int <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><div class="odoc-spec"><div class="spec value anchored" id="val-take_while"><a href="#val-take_while" class="anchor"></a><code><span><span class="keyword">val</span> take_while : <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><div class="odoc-spec"><div class="spec value anchored" id="val-drop"><a href="#val-drop" class="anchor"></a><code><span><span class="keyword">val</span> drop : <span>int <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><div class="odoc-spec"><div class="spec value anchored" id="val-drop_while"><a href="#val-drop_while" class="anchor"></a><code><span><span class="keyword">val</span> drop_while : <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><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>(<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> <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><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>(<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> <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>Map with index (starts at 0).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fmap"><a href="#val-fmap" class="anchor"></a><code><span><span class="keyword">val</span> fmap : <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><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>(<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><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> <a href="#type-t">t</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><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-product_with"><a href="#val-product_with" class="anchor"></a><code><span><span class="keyword">val</span> product_with : <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>Fair product of two (possibly infinite) lists into a new list. Lazy. The first parameter is used to combine each pair of elements.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_product"><a href="#val-map_product" class="anchor"></a><code><span><span class="keyword">val</span> map_product : <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>Alias of <a href="#val-product_with"><code>product_with</code></a>.</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-product"><a href="#val-product" class="anchor"></a><code><span><span class="keyword">val</span> product : <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 class="spec-doc"><p>Specialization of <a href="#val-product_with"><code>product_with</code></a> producing tuples.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-group"><a href="#val-group" class="anchor"></a><code><span><span class="keyword">val</span> group : <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> <span class="arrow">-></span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>group eq l</code> groups together consecutive elements that satisfy <code>eq</code>. Lazy. For instance <code>group (=) [1;1;1;2;2;3;3;1]</code> yields <code>[1;1;1]; [2;2]; [3;3]; [1]</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uniq"><a href="#val-uniq" class="anchor"></a><code><span><span class="keyword">val</span> uniq : <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> <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>uniq eq l</code> returns <code>l</code> but removes consecutive duplicates. Lazy. In other words, if several values that are equal follow one another, only the first of them is kept.</p></div></div><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>(<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> bool</span></code></div><div class="spec-doc"><p><code>for_all p [a1; ...; an]</code> checks if all elements of the sequence satisfy the predicate <code>p</code>. That is, it returns <code>(p a1) && ... && (p an)</code> for a non-empty list and <code>true</code> if the sequence is empty. It consumes the sequence until it finds an element not satisfying the predicate.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.3</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>(<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> bool</span></code></div><div class="spec-doc"><p><code>exists p [a1; ...; an]</code> checks if at least one element of the sequence satisfies the predicate <code>p</code>. That is, it returns <code>(p a1) || ... || (p an)</code> for a non-empty sequence and <code>false</code> if the list is empty. It consumes the sequence until it finds an element satisfying the predicate.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.3</li></ul></div></div><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><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> option</span></span></code></div><div class="spec-doc"><p><code>find p [a1; ...; an]</code> return <code>Some ai</code> for the first <code>ai</code> satisfying the predicate <code>p</code> and return <code>None</code> otherwise.</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-find_map"><a href="#val-find_map" class="anchor"></a><code><span><span class="keyword">val</span> find_map : <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 f [a1; ...; an]</code> return <code>Some (f ai)</code> for the first <code>ai</code> such that <code>f ai = Some _</code> and return <code>None</code> otherwise.</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-scan"><a href="#val-scan" class="anchor"></a><code><span><span class="keyword">val</span> scan : <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="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><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>scan f init xs</code> is the sequence containing the intermediate result of <code>fold f init xs</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-flat_map"><a href="#val-flat_map" class="anchor"></a><code><span><span class="keyword">val</span> flat_map : <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> <a href="#type-t">t</a></span></span></code></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><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> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Alias of <a href="#val-flat_map"><code>flat_map</code></a></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-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span><span class="keyword">val</span> filter_map : <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><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> <a href="#type-t">t</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><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> <a href="#type-t">t</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>Alias of <a href="#val-flatten"><code>flatten</code></a>.</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-range"><a href="#val-range" class="anchor"></a><code><span><span class="keyword">val</span> range : <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><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>a -- b</code> is the range of integers containing <code>a</code> and <code>b</code> (therefore, never empty).</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>a -- b</code> is the integer range from <code>a</code> to <code>b</code>, where <code>b</code> is excluded.</p></div></div><h3 id="operations-on-two-collections"><a href="#operations-on-two-collections" class="anchor"></a>Operations on two Collections</h3><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>(<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="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>Fold on two collections at once. Stop as soon as one of them ends.</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><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="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>Alias for <a href="#val-fold2"><code>fold2</code></a>.</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-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <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>Map on two collections at once. Stop as soon as one of the arguments is exhausted.</p></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>(<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>Iterate on two collections at once. Stop as soon as one of them ends.</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><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><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>(<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><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><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> <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>Merge two sorted iterators into a sorted iterator.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sorted_merge"><a href="#val-sorted_merge" class="anchor"></a><code><span><span class="keyword">val</span> sorted_merge : <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> <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>Alias of <a href="#val-merge"><code>merge</code></a>.</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-zip"><a href="#val-zip" class="anchor"></a><code><span><span class="keyword">val</span> zip : <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 class="spec-doc"><p>Combine elements pairwise. Stop as soon as one of the lists stops.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unzip"><a href="#val-unzip" class="anchor"></a><code><span><span class="keyword">val</span> unzip : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</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><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Split each tuple in the list.</p></div></div><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> <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><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Alias of <a href="#val-unzip"><code>unzip</code></a>.</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-zip_i"><a href="#val-zip_i" class="anchor"></a><code><span><span class="keyword">val</span> zip_i : <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> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>zip_i seq</code> zips the index of each element with the element itself.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.8</li></ul></div></div><h3 id="misc"><a href="#misc" class="anchor"></a>Misc</h3><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 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> <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>Eager sort. Require the iterator to be finite. <code>O(n ln(n))</code> time and space.</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 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> <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>Eager sort that removes duplicate values. Require the iterator to be finite. <code>O(n ln(n))</code> time and space.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-memoize"><a href="#val-memoize" class="anchor"></a><code><span><span class="keyword">val</span> memoize : <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>Avoid recomputations by caching intermediate results.</p></div></div><h3 id="fair-combinations"><a href="#fair-combinations" class="anchor"></a>Fair Combinations</h3><div class="odoc-spec"><div class="spec value anchored" id="val-interleave"><a href="#val-interleave" class="anchor"></a><code><span><span class="keyword">val</span> interleave : <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">'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>Fair interleaving of both streams.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fair_flat_map"><a href="#val-fair_flat_map" class="anchor"></a><code><span><span class="keyword">val</span> fair_flat_map : <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> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Fair 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-fair_app"><a href="#val-fair_app" class="anchor"></a><code><span><span class="keyword">val</span> fair_app : <span><span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <a href="#type-t">t</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><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Fair version of <a href="#val-(<*>)"><code>(<*>)</code></a>.</p></div></div><h3 id="implementations"><a href="#implementations" class="anchor"></a>Implementations</h3><div class="odoc-spec"><div class="spec value anchored" id="val-return"><a href="#val-return" class="anchor"></a><code><span><span class="keyword">val</span> return : <span><span class="type-var">'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><div class="odoc-spec"><div class="spec value anchored" id="val-pure"><a href="#val-pure" class="anchor"></a><code><span><span class="keyword">val</span> pure : <span><span class="type-var">'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><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><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><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>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <a href="#type-t">t</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><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-(>>-)"><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>Infix version of <a href="#val-fair_flat_map"><code>fair_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>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span class="type-var">'b</span>)</span> <a href="#type-t">t</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><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Infix version of <a href="#val-fair_app"><code>fair_app</code></a>.</p></div></div><h3 id="infix-operators"><a href="#infix-operators" class="anchor"></a>Infix operators</h3><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-spec"><div class="spec module-type anchored" id="module-type-MONAD"><a href="#module-type-MONAD" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-MONAD/index.html">MONAD</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Traverse"><a href="#module-Traverse" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Traverse/index.html">Traverse</a></span><span> (<a href="Traverse/argument-1-M/index.html">M</a> : <a href="module-type-MONAD/index.html">MONAD</a>) : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><h3 id="conversions"><a href="#conversions" class="anchor"></a>Conversions</h3><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> <a href="#type-t">t</a></span></span></code></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> <a href="#type-t">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>Gather all values into a list.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_array"><a href="#val-of_array" class="anchor"></a><code><span><span class="keyword">val</span> of_array : <span><span><span class="type-var">'a</span> array</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>Iterate on the array.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_array"><a href="#val-to_array" class="anchor"></a><code><span><span class="keyword">val</span> to_array : <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>Convert into array.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_rev_list"><a href="#val-to_rev_list" class="anchor"></a><code><span><span class="keyword">val</span> to_rev_list : <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> list</span></span></code></div><div class="spec-doc"><p>Convert to a list, in reverse order. More efficient than <a href="#val-to_list"><code>to_list</code></a>.</p></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><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><div class="odoc-spec"><div class="spec value anchored" id="val-of_gen"><a href="#val-of_gen" class="anchor"></a><code><span><span class="keyword">val</span> of_gen : <span><span><span class="type-var">'a</span> <a href="#type-gen">gen</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>of_gen g</code> consumes the generator and caches intermediate results.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">-></span></span> <span>char <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Iterate on characters.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.7</li></ul></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>?pp_start:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span>?pp_stop:<span>unit <a href="#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span>?pp_sep:<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 s</code> formats the sequence <code>s</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></body></html> |