mirror of
https://github.com/c-cube/iter.git
synced 2025-12-06 03:05:29 -05:00
103 lines
No EOL
97 KiB
HTML
103 lines
No EOL
97 KiB
HTML
<!DOCTYPE html>
|
||
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SequenceLabels (sequence.SequenceLabels)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><meta name="generator" content="doc-ock-html v1.0.0-1-g1fc9bf0"/></head><body><nav id="top"><a href="../index.html">Up</a> — <span class="package">package <a href="../index.html">sequence</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">SequenceLabels</span></h1></header><h2>Simple and Efficient Iterators</h2><p>Version of <a href="../Sequence/index.html">Sequence</a> with labels</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.5</li></ul><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>+'a t</code><code><span class="keyword"> = </span>(<span class="type-var">'a</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> unit</code><code></code></div><div class="doc"><p>A sequence of values of type <code class="code">'a</code>. If you give it a function <code class="code">'a -> unit</code>
|
||
it will be applied to every element of the sequence successively.</p></div></div><div class="spec type" id="type-sequence"><a href="#type-sequence" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>+'a sequence</code><code><span class="keyword"> = </span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></code><code></code></div><div class="doc"></div></div><p><b>NOTE</b> Type <code class="code">('a, 'b) t2 = ('a -> 'b -> unit) -> unit</code>
|
||
has been removed and subsumed by <code class="code">('a * 'b) t</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.0</li></ul><div class="spec type" id="type-equal"><a href="#type-equal" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a equal</code><code><span class="keyword"> = </span><span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool</code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-hash"><a href="#type-hash" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a hash</code><code><span class="keyword"> = </span><span class="type-var">'a</span> <span class="keyword">‑></span> int</code><code></code></div><div class="doc"></div></div><h3>Build a sequence</h3><div class="spec val" id="val-from_iter"><a href="#val-from_iter" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>from_iter : ((<span class="type-var">'a</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> unit) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Build a sequence from a iter function</p></div></div><div class="spec val" id="val-from_fun"><a href="#val-from_fun" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>from_fun : (unit <span class="keyword">‑></span> <span class="type-var">'a</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Call the function repeatedly until it returns None. This
|
||
sequence is transient, use <a href="index.html#val-persistent">persistent</a> if needed!</p></div></div><div class="spec val" id="val-empty"><a href="#val-empty" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>empty : <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Empty sequence. It contains no element.</p></div></div><div class="spec val" id="val-singleton"><a href="#val-singleton" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>singleton : <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Singleton sequence, with exactly one element.</p></div></div><div class="spec val" id="val-doubleton"><a href="#val-doubleton" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>doubleton : <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence with exactly two elements</p></div></div><div class="spec val" id="val-init"><a href="#val-init" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>init : f:(int <span class="keyword">‑></span> <span class="type-var">'a</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">init f</code> is the infinite sequence <code class="code">f 0; f 1; f 2; …</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-cons"><a href="#val-cons" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>cons : <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">cons x l</code> yields <code class="code">x</code>, then yields from <code class="code">l</code>.
|
||
Same as <code class="code">append (singleton x) l</code></p></div></div><div class="spec val" id="val-snoc"><a href="#val-snoc" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>snoc : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Same as <a href="index.html#val-cons">cons</a> but yields the element after iterating on <code class="code">l</code></p></div></div><div class="spec val" id="val-return"><a href="#val-return" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>return : <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Synonym to <a href="index.html#val-singleton">singleton</a></p></div></div><div class="spec val" id="val-pure"><a href="#val-pure" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>pure : <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Synonym to <a href="index.html#val-singleton">singleton</a></p></div></div><div class="spec val" id="val-repeat"><a href="#val-repeat" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>repeat : <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Infinite sequence of the same element. You may want to look
|
||
at <a href="index.html#val-take">take</a> and the likes if you iterate on it.</p></div></div><div class="spec val" id="val-iterate"><a href="#val-iterate" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>iterate : (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">iterate f x</code> is the infinite sequence <code class="code">x, f(x), f(f(x)), ...</code></p></div></div><div class="spec val" id="val-forever"><a href="#val-forever" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>forever : (unit <span class="keyword">‑></span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence that calls the given function to produce elements.
|
||
The sequence may be transient (depending on the function), and definitely
|
||
is infinite. You may want to use <a href="index.html#val-take">take</a> and <a href="index.html#val-persistent">persistent</a>.</p></div></div><div class="spec val" id="val-cycle"><a href="#val-cycle" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>cycle : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Cycle forever through the given sequence. Assume the given sequence can
|
||
be traversed any amount of times (not transient). This yields an
|
||
infinite sequence, you should use something like <a href="index.html#val-take">take</a> not to loop
|
||
forever.</p></div></div><h3>Consume a sequence</h3><div class="spec val" id="val-iter"><a href="#val-iter" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>iter : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Consume the sequence, passing all its arguments to the function.
|
||
Basically <code class="code">iter f seq</code> is just <code class="code">seq f</code>.</p></div></div><div class="spec val" id="val-iteri"><a href="#val-iteri" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>iteri : f:(int <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Iterate on elements and their index in the sequence</p></div></div><div class="spec val" id="val-fold"><a href="#val-fold" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>fold : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span>) <span class="keyword">‑></span> init:<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>Fold over elements of the sequence, consuming it</p></div></div><div class="spec val" id="val-foldi"><a href="#val-foldi" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>foldi : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> int <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span>) <span class="keyword">‑></span> init:<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>Fold over elements of the sequence and their index, consuming it</p></div></div><div class="spec val" id="val-fold_map"><a href="#val-fold_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>fold_map : f:(<span class="type-var">'acc</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'acc</span><span class="keyword"> * </span><span class="type-var">'b</span>) <span class="keyword">‑></span> init:<span class="type-var">'acc</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">fold_map f acc l</code> is like <a href="index.html#val-map">map</a>, but it carries some state as in
|
||
<a href="index.html#val-fold">fold</a>. The state is not returned, it is just used to thread some
|
||
information to the map function.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-fold_filter_map"><a href="#val-fold_filter_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>fold_filter_map : f:(<span class="type-var">'acc</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'acc</span><span class="keyword"> * </span><span class="type-var">'b</span> option) <span class="keyword">‑></span> init:<span class="type-var">'acc</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">fold_filter_map f acc l</code> is a <a href="index.html#val-fold_map">fold_map</a>-like function, but the
|
||
function can choose to skip an element by retuning <code class="code">None</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-map"><a href="#val-map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>map : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Map objects of the sequence into other elements, lazily</p></div></div><div class="spec val" id="val-mapi"><a href="#val-mapi" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>mapi : f:(int <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Map objects, along with their index in the sequence</p></div></div><div class="spec val" id="val-map_by_2"><a href="#val-map_by_2" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>map_by_2 : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Map objects two by two. lazily.
|
||
The last element is kept in the sequence if the count is odd.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.7</li></ul></div></div><div class="spec val" id="val-for_all"><a href="#val-for_all" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>for_all : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> bool</code></div><div class="doc"><p>Do all elements satisfy the predicate?</p></div></div><div class="spec val" id="val-exists"><a href="#val-exists" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>exists : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> bool</code></div><div class="doc"><p>Exists there some element satisfying the predicate?</p></div></div><div class="spec val" id="val-mem"><a href="#val-mem" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>mem : ?⁠eq:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> x:<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> bool</code></div><div class="doc"><p>Is the value a member of the sequence?</p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">eq</span>: the equality predicate to use (default <code class="code">(=)</code>)</li><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div><div class="spec val" id="val-find"><a href="#val-find" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>find : (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> option</code></div><div class="doc"><p>Find the first element on which the function doesn't return <code class="code">None</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div><div class="spec val" id="val-find_map"><a href="#val-find_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>find_map : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> option</code></div><div class="doc"><p>Alias to <a href="index.html#val-find">find</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-findi"><a href="#val-findi" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>findi : f:(int <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> option</code></div><div class="doc"><p>Indexed version of <a href="index.html#val-find">find</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-find_mapi"><a href="#val-find_mapi" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>find_mapi : f:(int <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> option</code></div><div class="doc"><p>Alias to <a href="index.html#val-findi">findi</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-find_pred"><a href="#val-find_pred" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>find_pred : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> option</code></div><div class="doc"><p><code class="code">find_pred p l</code> finds the first element of <code class="code">l</code> that satisfies <code class="code">p</code>,
|
||
or returns <code class="code">None</code> if no element satisfies <code class="code">p</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-find_pred_exn"><a href="#val-find_pred_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>find_pred_exn : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>Unsafe version of <a href="index.html#val-find_pred">find_pred</a></p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Not_found</span>: if no such element is found</li><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-length"><a href="#val-length" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>length : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> int</code></div><div class="doc"><p>How long is the sequence? Forces the sequence.</p></div></div><div class="spec val" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>is_empty : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> bool</code></div><div class="doc"><p>Is the sequence empty? Forces the sequence.</p></div></div><h3>Transform a sequence</h3><div class="spec val" id="val-filter"><a href="#val-filter" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>filter : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Filter on elements of the sequence</p></div></div><div class="spec val" id="val-append"><a href="#val-append" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>append : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Append two sequences. Iterating on the result is like iterating
|
||
on the first, then on the second.</p></div></div><div class="spec val" id="val-append_l"><a href="#val-append_l" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>append_l : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> list <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Append sequences. Iterating on the result is like iterating
|
||
on the each sequence of the list in order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-concat"><a href="#val-concat" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>concat : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Concatenate a sequence of sequences into one sequence.</p></div></div><div class="spec val" id="val-flatten"><a href="#val-flatten" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>flatten : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Alias for <a href="index.html#val-concat">concat</a></p></div></div><div class="spec val" id="val-flat_map"><a href="#val-flat_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>flat_map : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Alias to flatMap with a more explicit name</p></div></div><div class="spec val" id="val-flat_map_l"><a href="#val-flat_map_l" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>flat_map_l : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> list) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Convenience function combining <a href="index.html#val-flat_map">flat_map</a> and <a href="index.html#val-of_list">of_list</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>filter_map : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Alias to fmap with a more explicit name</p></div></div><div class="spec val" id="val-filter_mapi"><a href="#val-filter_mapi" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>filter_mapi : f:(int <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Map with indices, and only keep non-<code class="code">None</code> elements</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-seq_list"><a href="#val-seq_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>seq_list : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> list <span class="keyword">‑></span> <span class="type-var">'a</span> list <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">seq_list l</code> returns all the ways to pick one element in each sub-sequence
|
||
in <code class="code">l</code>. Assumes the sub-sequences can be iterated on several times.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-seq_list_map"><a href="#val-seq_list_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>seq_list_map : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a>) <span class="keyword">‑></span> <span class="type-var">'a</span> list <span class="keyword">‑></span> <span class="type-var">'b</span> list <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">seq_list_map f l</code> maps <code class="code">f</code> over every element of <code class="code">l</code>,
|
||
then calls <a href="index.html#val-seq_list">seq_list</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-filter_count"><a href="#val-filter_count" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>filter_count : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> int</code></div><div class="doc"><p>Count how many elements satisfy the given predicate</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.0</li></ul></div></div><div class="spec val" id="val-intersperse"><a href="#val-intersperse" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>intersperse : x:<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Insert the single element between every element of the sequence</p></div></div><div class="spec val" id="val-keep_some"><a href="#val-keep_some" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>keep_some : <span class="type-var">'a</span> option <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">filter_some l</code> retains only elements of the form <code class="code">Some x</code>.
|
||
Same as <code class="code">filter_map (fun x->x)</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.0</li></ul></div></div><div class="spec val" id="val-keep_ok"><a href="#val-keep_ok" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>keep_ok : (<span class="type-var">'a</span>, <span class="type-var">_</span>) Result.result <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">keep_ok l</code> retains only elements of the form <code class="code">Ok x</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.0</li></ul></div></div><div class="spec val" id="val-keep_error"><a href="#val-keep_error" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>keep_error : (<span class="type-var">_</span>, <span class="type-var">'e</span>) Result.result <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'e</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">keep_error l</code> retains only elements of the form <code class="code">Error x</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.0</li></ul></div></div><h3>Caching</h3><div class="spec val" id="val-persistent"><a href="#val-persistent" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>persistent : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Iterate on the sequence, storing elements in an efficient internal structure..
|
||
The resulting sequence can be iterated on as many times as needed.
|
||
<b>Note</b>: calling persistent on an already persistent sequence
|
||
will still make a new copy of the sequence!</p></div></div><div class="spec val" id="val-persistent_lazy"><a href="#val-persistent_lazy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>persistent_lazy : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Lazy version of <a href="index.html#val-persistent">persistent</a>. When calling <code class="code">persistent_lazy s</code>,
|
||
a new sequence <code class="code">s'</code> is immediately returned (without actually consuming
|
||
<code class="code">s</code>) in constant time; the first time <code class="code">s'</code> is iterated on,
|
||
it also consumes <code class="code">s</code> and caches its content into a inner data
|
||
structure that will back <code class="code">s'</code> for future iterations.</p><p><b>warning</b>: on the first traversal of <code class="code">s'</code>, if the traversal
|
||
is interrupted prematurely (<a href="index.html#val-take">take</a>, etc.) then <code class="code">s'</code> will not be
|
||
memorized, and the next call to <code class="code">s'</code> will traverse <code class="code">s</code> again.</p></div></div><h3>Misc</h3><div class="spec val" id="val-sort"><a href="#val-sort" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sort : ?⁠cmp:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> int) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
|
||
It iterates on elements of the argument sequence immediately,
|
||
before it sorts them.</p></div></div><div class="spec val" id="val-sort_uniq"><a href="#val-sort_uniq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sort_uniq : ?⁠cmp:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> int) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sort the sequence and remove duplicates. Eager, same as <code class="code">sort</code></p></div></div><div class="spec val" id="val-sorted"><a href="#val-sorted" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sorted : ?⁠cmp:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> int) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> bool</code></div><div class="doc"><p>Checks whether the sequence is sorted. Eager, same as <a href="index.html#val-sort">sort</a>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-group_succ_by"><a href="#val-group_succ_by" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>group_succ_by : ?⁠eq:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> list <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Group equal consecutive elements.
|
||
Formerly synonym to <code class="code">group</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.6</li></ul></div></div><div class="spec val" id="val-group_by"><a href="#val-group_by" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>group_by : ?⁠hash:(<span class="type-var">'a</span> <span class="keyword">‑></span> int) <span class="keyword">‑></span> ?⁠eq:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> list <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Group equal elements, disregarding their order of appearance.
|
||
The result sequence is traversable as many times as required.
|
||
precondition: for any <code class="code">x</code> and <code class="code">y</code>, if <code class="code">eq x y</code> then <code class="code">hash x=hash y</code> must hold.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.6</li></ul></div></div><div class="spec val" id="val-count"><a href="#val-count" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>count : ?⁠hash:(<span class="type-var">'a</span> <span class="keyword">‑></span> int) <span class="keyword">‑></span> ?⁠eq:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span>int) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Map each distinct element to its number of occurrences in the whole seq.
|
||
Similar to <code class="code">group_by seq |> map (fun l->List.hd l, List.length l)</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-uniq"><a href="#val-uniq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>uniq : ?⁠eq:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Remove consecutive duplicate elements. Basically this is
|
||
like <code class="code">fun seq -> map List.hd (group seq)</code>.</p></div></div><div class="spec val" id="val-product"><a href="#val-product" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>product : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Cartesian product of the sequences. When calling <code class="code">product a b</code>,
|
||
the caller <b>MUST</b> ensure that <code class="code">b</code> can be traversed as many times
|
||
as required (several times), possibly by calling <a href="index.html#val-persistent">persistent</a> on it
|
||
beforehand.</p></div></div><div class="spec val" id="val-diagonal_l"><a href="#val-diagonal_l" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>diagonal_l : <span class="type-var">'a</span> list <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'a</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>All pairs of distinct positions of the list. <code class="code">diagonal l</code> will
|
||
return the sequence of all <code class="code">List.nth i l, List.nth j l</code> if <code class="code">i < j</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-diagonal"><a href="#val-diagonal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>diagonal : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'a</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>All pairs of distinct positions of the sequence.
|
||
Iterates only once on the sequence, which must be finite.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-join"><a href="#val-join" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>join : join_row:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'c</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'c</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">join ~join_row a b</code> combines every element of <code class="code">a</code> with every
|
||
element of <code class="code">b</code> using <code class="code">join_row</code>. If <code class="code">join_row</code> returns None, then
|
||
the two elements do not combine. Assume that <code class="code">b</code> allows for multiple
|
||
iterations.</p></div></div><div class="spec val" id="val-join_by"><a href="#val-join_by" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>join_by : ?⁠eq:<span class="type-var">'key</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'key</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'key</span>) <span class="keyword">‑></span> (<span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'key</span>) <span class="keyword">‑></span> merge:(<span class="type-var">'key</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'c</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'c</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">join key1 key2 ~merge</code> is a binary operation
|
||
that takes two sequences <code class="code">a</code> and <code class="code">b</code>, projects their
|
||
elements resp. with <code class="code">key1</code> and <code class="code">key2</code>, and combine
|
||
values <code class="code">(x,y)</code> from <code class="code">(a,b)</code> with the same <code class="code">key</code>
|
||
using <code class="code">merge</code>. If <code class="code">merge</code> returns <code class="code">None</code>, the combination
|
||
of values is discarded.
|
||
precondition: for any <code class="code">x</code> and <code class="code">y</code>, if <code class="code">eq x y</code> then <code class="code">hash x=hash y</code> must hold.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-join_all_by"><a href="#val-join_all_by" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>join_all_by : ?⁠eq:<span class="type-var">'key</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'key</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'key</span>) <span class="keyword">‑></span> (<span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'key</span>) <span class="keyword">‑></span> merge:(<span class="type-var">'key</span> <span class="keyword">‑></span> <span class="type-var">'a</span> list <span class="keyword">‑></span> <span class="type-var">'b</span> list <span class="keyword">‑></span> <span class="type-var">'c</span> option) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'c</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">join_all_by key1 key2 ~merge</code> is a binary operation
|
||
that takes two sequences <code class="code">a</code> and <code class="code">b</code>, projects their
|
||
elements resp. with <code class="code">key1</code> and <code class="code">key2</code>, and, for each key <code class="code">k</code>
|
||
occurring in at least one of them:
|
||
</p><ul><li>compute the list <code class="code">l1</code> of elements of <code class="code">a</code> that map to <code class="code">k</code></li><li>compute the list <code class="code">l2</code> of elements of <code class="code">b</code> that map to <code class="code">k</code></li><li>call <code class="code">merge k l1 l2</code>. If <code class="code">merge</code> returns <code class="code">None</code>, the combination
|
||
of values is discarded, otherwise it returns <code class="code">Some c</code>
|
||
and <code class="code">c</code> is inserted in the result.</li></ul><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-group_join_by"><a href="#val-group_join_by" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>group_join_by : ?⁠eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> (<span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span> list) <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">group_join_by key2</code> associates to every element <code class="code">x</code> of
|
||
the first sequence, all the elements <code class="code">y</code> of the second
|
||
sequence such that <code class="code">eq x (key y)</code>. Elements of the first
|
||
sequences without corresponding values in the second one
|
||
are mapped to <code class="code">[]</code>
|
||
precondition: for any <code class="code">x</code> and <code class="code">y</code>, if <code class="code">eq x y</code> then <code class="code">hash x=hash y</code> must hold.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-inter"><a href="#val-inter" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>inter : ?⁠eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Intersection of two collections. Each element will occur at most once
|
||
in the result. Eager.
|
||
precondition: for any <code class="code">x</code> and <code class="code">y</code>, if <code class="code">eq x y</code> then <code class="code">hash x=hash y</code> must hold.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-union"><a href="#val-union" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>union : ?⁠eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Union of two collections. Each element will occur at most once
|
||
in the result. Eager.
|
||
precondition: for any <code class="code">x</code> and <code class="code">y</code>, if <code class="code">eq x y</code> then <code class="code">hash x=hash y</code> must hold.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-diff"><a href="#val-diff" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>diff : ?⁠eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Set difference. Eager.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-subset"><a href="#val-subset" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>subset : ?⁠eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">‑></span> ?⁠hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> bool</code></div><div class="doc"><p><code class="code">subset a b</code> returns <code class="code">true</code> if all elements of <code class="code">a</code> belong to <code class="code">b</code>. Eager.
|
||
precondition: for any <code class="code">x</code> and <code class="code">y</code>, if <code class="code">eq x y</code> then <code class="code">hash x=hash y</code> must hold.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-unfoldr"><a href="#val-unfoldr" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>unfoldr : (<span class="type-var">'b</span> <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) option) <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">unfoldr f b</code> will apply <code class="code">f</code> to <code class="code">b</code>. If it
|
||
yields <code class="code">Some (x,b')</code> then <code class="code">x</code> is returned
|
||
and unfoldr recurses with <code class="code">b'</code>.</p></div></div><div class="spec val" id="val-scan"><a href="#val-scan" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>scan : (<span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence of intermediate results</p></div></div><div class="spec val" id="val-max"><a href="#val-max" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>max : ?⁠lt:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> option</code></div><div class="doc"><p>Max element of the sequence, using the given comparison function.</p><ul class="at-tag"><li><span class="at-tag return">Returns</span> None if the sequence is empty, Some <code class="code">m</code> where <code class="code">m</code> is the maximal
|
||
element otherwise</li></ul></div></div><div class="spec val" id="val-max_exn"><a href="#val-max_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>max_exn : ?⁠lt:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>Unsafe version of <a href="index.html#val-max">max</a></p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Not_found</span>: if the sequence is empty</li><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-min"><a href="#val-min" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>min : ?⁠lt:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> option</code></div><div class="doc"><p>Min element of the sequence, using the given comparison function.
|
||
see <a href="index.html#val-max">max</a> for more details.</p></div></div><div class="spec val" id="val-min_exn"><a href="#val-min_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>min_exn : ?⁠lt:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>Unsafe version of <a href="index.html#val-min">min</a></p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Not_found</span>: if the sequence is empty</li><li><span class="at-tag since">Since</span>: 0.10</li></ul></div></div><div class="spec val" id="val-sum"><a href="#val-sum" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sum : int <a href="index.html#type-t">t</a> <span class="keyword">‑></span> int</code></div><div class="doc"><p>Sum of elements</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-sumf"><a href="#val-sumf" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sumf : float <a href="index.html#type-t">t</a> <span class="keyword">‑></span> float</code></div><div class="doc"><p>Sum of elements, using Kahan summation</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-head"><a href="#val-head" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>head : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> option</code></div><div class="doc"><p>First element, if any, otherwise <code class="code">None</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.1</li></ul></div></div><div class="spec val" id="val-head_exn"><a href="#val-head_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>head_exn : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>First element, if any, fails</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the sequence is empty</li><li><span class="at-tag since">Since</span>: 0.5.1</li></ul></div></div><div class="spec val" id="val-take"><a href="#val-take" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take : int <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Take at most <code class="code">n</code> elements from the sequence. Works on infinite
|
||
sequences.</p></div></div><div class="spec val" id="val-take_while"><a href="#val-take_while" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_while : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Take elements while they satisfy the predicate, then stops iterating.
|
||
Will work on an infinite sequence <code class="code">s</code> if the predicate is false for at
|
||
least one element of <code class="code">s</code>.</p></div></div><div class="spec val" id="val-fold_while"><a href="#val-fold_while" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>fold_while : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span><span class="keyword"> * </span>[ `Stop | `Continue ]) <span class="keyword">‑></span> init:<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span></code></div><div class="doc"><p>Folds over elements of the sequence, stopping early if the accumulator
|
||
returns <code class="code">('a, `Stop)</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.5</li></ul></div></div><div class="spec val" id="val-drop"><a href="#val-drop" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>drop : int <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Drop the <code class="code">n</code> first elements of the sequence. Lazy.</p></div></div><div class="spec val" id="val-drop_while"><a href="#val-drop_while" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>drop_while : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> bool) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Predicate version of <a href="index.html#val-drop">drop</a></p></div></div><div class="spec val" id="val-rev"><a href="#val-rev" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>rev : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Reverse the sequence. O(n) memory and time, needs the
|
||
sequence to be finite. The result is persistent and does
|
||
not depend on the input being repeatable.</p></div></div><div class="spec val" id="val-zip_i"><a href="#val-zip_i" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>zip_i : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (int<span class="keyword"> * </span><span class="type-var">'a</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-fold2"><a href="#val-fold2" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>fold2 : f:(<span class="type-var">'c</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'c</span>) <span class="keyword">‑></span> init:<span class="type-var">'c</span> <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'c</span></code></div><div class="doc"></div></div><div class="spec val" id="val-iter2"><a href="#val-iter2" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>iter2 : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"></div></div><div class="spec val" id="val-map2"><a href="#val-map2" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>map2 : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'c</span>) <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'c</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-map2_2"><a href="#val-map2_2" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>map2_2 : f:(<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'c</span>) <span class="keyword">‑></span> (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'d</span>) <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'c</span><span class="keyword"> * </span><span class="type-var">'d</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">map2_2 f g seq2</code> maps each <code class="code">x, y</code> of seq2 into <code class="code">f x y, g x y</code></p></div></div><h3>Basic data structures converters</h3><div class="spec val" id="val-to_list"><a href="#val-to_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_list : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> list</code></div><div class="doc"><p>Convert the sequence into a list. Preserves order of elements.
|
||
This function is tail-recursive, but consumes 2*n memory.
|
||
If order doesn't matter to you, consider <a href="index.html#val-to_rev_list">to_rev_list</a>.</p></div></div><div class="spec val" id="val-to_rev_list"><a href="#val-to_rev_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_rev_list : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> list</code></div><div class="doc"><p>Get the list of the reversed sequence (more efficient than <a href="index.html#val-to_list">to_list</a>)</p></div></div><div class="spec val" id="val-of_list"><a href="#val-of_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_list : <span class="type-var">'a</span> list <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-on_list"><a href="#val-on_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>on_list : (<span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a>) <span class="keyword">‑></span> <span class="type-var">'a</span> list <span class="keyword">‑></span> <span class="type-var">'b</span> list</code></div><div class="doc"><p><code class="code">on_list f l</code> is equivalent to <code class="code">to_list @@ f @@ of_list l</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.2</li></ul></div></div><div class="spec val" id="val-pair_with_idx"><a href="#val-pair_with_idx" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>pair_with_idx : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (int<span class="keyword"> * </span><span class="type-var">'a</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Similar to <a href="index.html#val-zip_i">zip_i</a> but returns a normal sequence of tuples</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div><div class="spec val" id="val-to_opt"><a href="#val-to_opt" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_opt : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> option</code></div><div class="doc"><p>Alias to <a href="index.html#val-head">head</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.1</li></ul></div></div><div class="spec val" id="val-to_array"><a href="#val-to_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_array : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> array</code></div><div class="doc"><p>Convert to an array. Currently not very efficient because
|
||
an intermediate list is used.</p></div></div><div class="spec val" id="val-of_array"><a href="#val-of_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_array : <span class="type-var">'a</span> array <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-of_array_i"><a href="#val-of_array_i" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_array_i : <span class="type-var">'a</span> array <span class="keyword">‑></span> (int<span class="keyword"> * </span><span class="type-var">'a</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Elements of the array, with their index</p></div></div><div class="spec val" id="val-array_slice"><a href="#val-array_slice" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>array_slice : <span class="type-var">'a</span> array <span class="keyword">‑></span> int <span class="keyword">‑></span> int <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">array_slice a i j</code> Sequence of elements whose indexes range
|
||
from <code class="code">i</code> to <code class="code">j</code></p></div></div><div class="spec val" id="val-of_opt"><a href="#val-of_opt" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_opt : <span class="type-var">'a</span> option <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Iterate on 0 or 1 values.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.1</li></ul></div></div><div class="spec val" id="val-of_stream"><a href="#val-of_stream" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_stream : <span class="type-var">'a</span> Stream.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence of elements of a stream (usable only once)</p></div></div><div class="spec val" id="val-to_stream"><a href="#val-to_stream" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_stream : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> Stream.t</code></div><div class="doc"><p>Convert to a stream. linear in memory and time (a copy is made in memory)</p></div></div><div class="spec val" id="val-to_stack"><a href="#val-to_stack" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_stack : <span class="type-var">'a</span> Stack.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Push elements of the sequence on the stack</p></div></div><div class="spec val" id="val-of_stack"><a href="#val-of_stack" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_stack : <span class="type-var">'a</span> Stack.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence of elements of the stack (same order as <code class="code">Stack.iter</code>)</p></div></div><div class="spec val" id="val-to_queue"><a href="#val-to_queue" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_queue : <span class="type-var">'a</span> Queue.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Push elements of the sequence into the queue</p></div></div><div class="spec val" id="val-of_queue"><a href="#val-of_queue" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_queue : <span class="type-var">'a</span> Queue.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence of elements contained in the queue, FIFO order</p></div></div><div class="spec val" id="val-hashtbl_add"><a href="#val-hashtbl_add" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hashtbl_add : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) Hashtbl.t <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Add elements of the sequence to the hashtable, with
|
||
Hashtbl.add</p></div></div><div class="spec val" id="val-hashtbl_replace"><a href="#val-hashtbl_replace" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hashtbl_replace : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) Hashtbl.t <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Add elements of the sequence to the hashtable, with
|
||
Hashtbl.replace (erases conflicting bindings)</p></div></div><div class="spec val" id="val-to_hashtbl"><a href="#val-to_hashtbl" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_hashtbl : (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) Hashtbl.t</code></div><div class="doc"><p>Build a hashtable from a sequence of key/value pairs</p></div></div><div class="spec val" id="val-of_hashtbl"><a href="#val-of_hashtbl" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_hashtbl : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) Hashtbl.t <span class="keyword">‑></span> (<span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence of key/value pairs from the hashtable</p></div></div><div class="spec val" id="val-hashtbl_keys"><a href="#val-hashtbl_keys" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hashtbl_keys : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) Hashtbl.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-hashtbl_values"><a href="#val-hashtbl_values" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hashtbl_values : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) Hashtbl.t <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-of_str"><a href="#val-of_str" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_str : string <span class="keyword">‑></span> char <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-to_str"><a href="#val-to_str" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_str : char <a href="index.html#type-t">t</a> <span class="keyword">‑></span> string</code></div><div class="doc"></div></div><div class="spec val" id="val-concat_str"><a href="#val-concat_str" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>concat_str : string <a href="index.html#type-t">t</a> <span class="keyword">‑></span> string</code></div><div class="doc"><p>Concatenate strings together, eagerly.
|
||
Also see <a href="index.html#val-intersperse">intersperse</a> to add a separator.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div><div class="spec exception" id="exception-OneShotSequence"><a href="#exception-OneShotSequence" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">OneShotSequence</span></code></div><div class="doc"><p>Raised when the user tries to iterate several times on
|
||
a transient iterator</p></div></div><div class="spec val" id="val-of_in_channel"><a href="#val-of_in_channel" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_in_channel : Pervasives.in_channel <span class="keyword">‑></span> char <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Iterates on characters of the input (can block when one
|
||
iterates over the sequence). If you need to iterate
|
||
several times on this sequence, use <a href="index.html#val-persistent">persistent</a>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">OneShotSequence</span>: when used more than once.</li></ul></div></div><div class="spec val" id="val-to_buffer"><a href="#val-to_buffer" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_buffer : char <a href="index.html#type-t">t</a> <span class="keyword">‑></span> Buffer.t <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Copy content of the sequence into the buffer</p></div></div><div class="spec val" id="val-int_range"><a href="#val-int_range" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>int_range : start:int <span class="keyword">‑></span> stop:int <span class="keyword">‑></span> int <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-int_range_dec"><a href="#val-int_range_dec" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>int_range_dec : start:int <span class="keyword">‑></span> stop:int <span class="keyword">‑></span> int <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-int_range_by"><a href="#val-int_range_by" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>int_range_by : step:int <span class="keyword">‑></span> start:int <span class="keyword">‑></span> stop:int <span class="keyword">‑></span> int <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">int_range_by ~step ~start:i ~stop:j</code> is the range starting at <code class="code">i</code>, including <code class="code">j</code>,
|
||
where the difference between successive elements is <code class="code">step</code>.
|
||
use a negative <code class="code">step</code> for a decreasing sequence.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">step=0</code></li></ul></div></div><div class="spec val" id="val-bools"><a href="#val-bools" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>bools : bool <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Iterates on <code class="code">true</code> and <code class="code">false</code></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.9</li></ul></div></div><div class="spec val" id="val-of_set"><a href="#val-of_set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_set : (<span class="keyword">module </span>Set.S <span class="keyword">with</span> <span class="keyword">type </span>elt <span class="keyword">=</span> <span class="type-var">'a</span><span class="keyword"> and </span><span class="keyword">type </span>t <span class="keyword">=</span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'b</span> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Convert the given set to a sequence. The set module must be provided.</p></div></div><div class="spec val" id="val-to_set"><a href="#val-to_set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_set : (<span class="keyword">module </span>Set.S <span class="keyword">with</span> <span class="keyword">type </span>elt <span class="keyword">=</span> <span class="type-var">'a</span><span class="keyword"> and </span><span class="keyword">type </span>t <span class="keyword">=</span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span></code></div><div class="doc"><p>Convert the sequence to a set, given the proper set module</p></div></div><div class="spec type" id="type-gen"><a href="#type-gen" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a gen</code><code><span class="keyword"> = </span>unit <span class="keyword">‑></span> <span class="type-var">'a</span> option</code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-klist"><a href="#type-klist" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a klist</code><code><span class="keyword"> = </span>unit <span class="keyword">‑></span> [ `Nil | `Cons of <span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'a</span> <a href="index.html#type-klist">klist</a> ]</code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-of_gen"><a href="#val-of_gen" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_gen : <span class="type-var">'a</span> <a href="index.html#type-gen">gen</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Traverse eagerly the generator and build a sequence from it</p></div></div><div class="spec val" id="val-to_gen"><a href="#val-to_gen" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_gen : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-gen">gen</a></code></div><div class="doc"><p>Make the sequence persistent (O(n)) and then iterate on it. Eager.</p></div></div><div class="spec val" id="val-of_klist"><a href="#val-of_klist" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_klist : <span class="type-var">'a</span> <a href="index.html#type-klist">klist</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Iterate on the lazy list</p></div></div><div class="spec val" id="val-to_klist"><a href="#val-to_klist" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_klist : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-klist">klist</a></code></div><div class="doc"><p>Make the sequence persistent and then iterate on it. Eager.</p></div></div><h3>Functorial conversions between sets and sequences</h3><div class="spec module" id="module-Set"><a href="#module-Set" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Set/index.html">Set</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><h3>Conversion between maps and sequences.</h3><div class="spec module" id="module-Map"><a href="#module-Map" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Map/index.html">Map</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><h3>Infinite sequences of random values</h3><div class="spec val" id="val-random_int"><a href="#val-random_int" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>random_int : int <span class="keyword">‑></span> int <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Infinite sequence of random integers between 0 and
|
||
the given higher bound (see Random.int)</p></div></div><div class="spec val" id="val-random_bool"><a href="#val-random_bool" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>random_bool : bool <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Infinite sequence of random bool values</p></div></div><div class="spec val" id="val-random_float"><a href="#val-random_float" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>random_float : float <span class="keyword">‑></span> float <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-random_array"><a href="#val-random_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>random_array : <span class="type-var">'a</span> array <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Sequence of choices of an element in the array</p></div></div><div class="spec val" id="val-random_list"><a href="#val-random_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>random_list : <span class="type-var">'a</span> list <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Infinite sequence of random elements of the list. Basically the
|
||
same as <a href="index.html#val-random_array">random_array</a>.</p></div></div><div class="spec val" id="val-shuffle"><a href="#val-shuffle" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>shuffle : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">shuffle seq</code> returns a perfect shuffle of <code class="code">seq</code>.
|
||
Uses O(length seq) memory and time. Eager.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.7</li></ul></div></div><div class="spec val" id="val-shuffle_buffer"><a href="#val-shuffle_buffer" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>shuffle_buffer : n:int <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">shuffle_buffer n seq</code> returns a sequence of element of <code class="code">seq</code> in random
|
||
order. The shuffling is not uniform. Uses O(n) memory.</p><p>The first <code class="code">n</code> elements of the sequence are consumed immediately. The
|
||
rest is consumed lazily.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.7</li></ul></div></div><h3>Sampling</h3><div class="spec val" id="val-sample"><a href="#val-sample" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sample : n:int <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> array</code></div><div class="doc"><p><code class="code">sample n seq</code> returns k samples of <code class="code">seq</code>, with uniform probability.
|
||
It will consume the sequence and use O(n) memory.</p><p>It returns an array of size <code class="code">min (length seq) n</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.7</li></ul></div></div><h3>Infix functions</h3><div class="spec module" id="module-Infix"><a href="#module-Infix" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Infix/index.html">Infix</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec include"><div class="doc"></div><details open="open"><summary><span class="def"><code><span class="keyword">include </span><span class="keyword">module type of </span><a href="index.html#module-Infix">Infix</a></code></span></summary><div class="spec val" id="val-(--)"><a href="#val-(--)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(--) : int <span class="keyword">‑></span> int <span class="keyword">‑></span> int <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">a -- b</code> is the range of integers from <code class="code">a</code> to <code class="code">b</code>, both included,
|
||
in increasing order. It will therefore be empty if <code class="code">a > b</code>.</p></div></div><div class="spec val" id="val-(--^)"><a href="#val-(--^)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(--^) : int <span class="keyword">‑></span> int <span class="keyword">‑></span> int <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">a --^ b</code> is the range of integers from <code class="code">b</code> to <code class="code">a</code>, both included,
|
||
in decreasing order (starts from <code class="code">a</code>).
|
||
It will therefore be empty if <code class="code">a < b</code>.</p></div></div><div class="spec val" id="val-(>>=)"><a href="#val-(>>=)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(>>=) : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a>) <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Monadic bind (infix version of <a href="index.html#val-flat_map">flat_map</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div><div class="spec val" id="val-(>|=)"><a href="#val-(>|=)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(>|=) : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span>) <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Infix version of <a href="index.html#val-map">map</a></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div><div class="spec val" id="val-(<*>)"><a href="#val-(<*>)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(<*>) : (<span class="type-var">'a</span> <span class="keyword">‑></span> <span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Applicative operator (product+application)</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div><div class="spec val" id="val-(<+>)"><a href="#val-(<+>)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(<+>) : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Concatenation of sequences</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5</li></ul></div></div></details></div><h3>Pretty printing of sequences</h3><div class="spec val" id="val-pp_seq"><a href="#val-pp_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>pp_seq : ?⁠sep:string <span class="keyword">‑></span> (Format.formatter <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> Format.formatter <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Pretty print a sequence of <code class="code">'a</code>, using the given pretty printer
|
||
to print each elements. An optional separator string can be provided.</p></div></div><div class="spec val" id="val-pp_buf"><a href="#val-pp_buf" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>pp_buf : ?⁠sep:string <span class="keyword">‑></span> (Buffer.t <span class="keyword">‑></span> <span class="type-var">'a</span> <span class="keyword">‑></span> unit) <span class="keyword">‑></span> Buffer.t <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> unit</code></div><div class="doc"><p>Print into a buffer</p></div></div><div class="spec val" id="val-to_string"><a href="#val-to_string" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_string : ?⁠sep:string <span class="keyword">‑></span> (<span class="type-var">'a</span> <span class="keyword">‑></span> string) <span class="keyword">‑></span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">‑></span> string</code></div><div class="doc"><p>Print into a string</p></div></div><h3>Basic IO</h3><p>Very basic interface to manipulate files as sequence of chunks/lines. The
|
||
sequences take care of opening and closing files properly; every time
|
||
one iterates over a sequence, the file is opened/closed again.</p><p>Example: copy a file <code class="code">"a"</code> into file <code class="code">"b"</code>, removing blank lines:</p><pre><code class="code"> Sequence.(IO.lines_of "a" |> filter (fun l-> l<> "") |> IO.write_lines "b");;</code></pre><p>By chunks of <code class="code">4096</code> bytes:</p><pre><code class="code"> Sequence.IO.(chunks_of ~size:4096 "a" |> write_to "b");;</code></pre><p>Read the lines of a file into a list:</p><pre><code class="code"> Sequence.IO.lines "a" |> Sequence.to_list</code></pre><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.5.1</li></ul><div class="spec module" id="module-IO"><a href="#module-IO" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="IO/index.html">IO</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div></body></html> |