simon/ocaml-containers
1
0
Fork 0
mirror of https://github.com/c-cube/ocaml-containers.git synced 2026-01-24 10:06:40 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

doc for 2.0

Browse source
This commit is contained in:
Simon Cruanes 2018-01-21 15:48:04 -06:00
parent 0bbf705777
commit 01f91d42b1
288 changed files with 1966 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

0
2.0/containers.data/CCBV/.jbuilder-keep Normal file
View file

18
2.0/containers.data/CCBV/index.html Normal file
View file

@ -0,0 +1,18 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCBV (containers.data.CCBV)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCBV</span></h1></header><h3>Imperative Bitvectors</h3><p><b>BREAKING CHANGES</b> since 1.2:
size is now stored along with the bitvector. Some functions have
a new signature.</p><p>The size of the bitvector used to be rounded up to the multiple of 30 or 62.
In other words some functions such as <a href="index.html#val-iter">iter</a> would iterate on more
bits than what was originally asked for. This is not the case anymore.</p><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>A resizable bitvector</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 : unit <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Empty bitvector.</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : size:int <span class="keyword">&#8209;&gt;</span> bool <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Create a bitvector of given size, with given default value.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Copy of bitvector.</p></div></div><div class="spec val" id="val-cardinal"><a href="#val-cardinal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>cardinal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of bits set to one, seen as a set of bits.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Size of underlying bitvector.
This is not related to the underlying implementation.
Changed at 1.2</p></div></div><div class="spec val" id="val-capacity"><a href="#val-capacity" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>capacity : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>The number of bits this bitvector can store without resizing.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.2</li></ul></div></div><div class="spec val" id="val-resize"><a href="#val-resize" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>resize : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Resize the BV so that it has the specified length. This can grow or shrink
the underlying bitvector.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_arg</span>: on negative sizes.</li></ul></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Are there any true bits?</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Set i-th bit, extending the bitvector if needed.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Is the i-th bit true? Returns false if the index is too high.</p></div></div><div class="spec val" id="val-reset"><a href="#val-reset" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>reset : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Set i-th bit to 0, extending the bitvector if needed.</p></div></div><div class="spec val" id="val-flip"><a href="#val-flip" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>flip : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Flip i-th bit, extending the bitvector if needed.</p></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Set every bit to 0.</p></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (int <span class="keyword">&#8209;&gt;</span> bool <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Iterate on all bits.</p></div></div><div class="spec val" id="val-iter_true"><a href="#val-iter_true" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>iter_true : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (int <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Iterate on bits set to 1.</p></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int list</code></div><div class="doc"><p>List of indexes that are true.</p></div></div><div class="spec val" id="val-to_sorted_list"><a href="#val-to_sorted_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_sorted_list : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int list</code></div><div class="doc"><p>Same as <a href="index.html#val-to_list">to_list</a>, but also guarantees the list is sorted in
increasing order.</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 : int list <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>From a list of true bits.</p><p>The bits are interpreted as indices into the returned bitvector, so the final
bitvector will have <code class="code">length t</code> equal to 1 more than max of list indices.</p></div></div><div class="spec val" id="val-first"><a href="#val-first" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>first : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int option</code></div><div class="doc"><p>First set bit, or return None.
changed type at 1.2</p></div></div><div class="spec val" id="val-first_exn"><a href="#val-first_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>first_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>First set bit, or</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Not_found</span>: if all bits are 0.</li><li><span class="at-tag since">Since</span>: 1.2</li></ul></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (int <span class="keyword">&#8209;&gt;</span> bool) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">filter bv p</code> only keeps the true bits of <code class="code">bv</code> whose <code class="code">index</code>
satisfies <code class="code">p index</code>.</p></div></div><div class="spec val" id="val-negate_self"><a href="#val-negate_self" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>negate_self : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">negate_self t</code> flips all of the bits in <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.2</li></ul></div></div><div class="spec val" id="val-negate"><a href="#val-negate" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>negate : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">negate t</code> returns a copy of <code class="code">t</code> with all of the bits flipped.</p></div></div><div class="spec val" id="val-union_into"><a href="#val-union_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>union_into : into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">union_into ~into bv</code> sets <code class="code">into</code> to the union of itself and <code class="code">bv</code>.
Also updates the length of <code class="code">into</code> to be at least <code class="code">length bv</code>.</p></div></div><div class="spec val" id="val-inter_into"><a href="#val-inter_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>inter_into : into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">inter_into ~into bv</code> sets <code class="code">into</code> to the intersection of itself and <code class="code">bv</code>.
Also updates the length of <code class="code">into</code> to be at most <code class="code">length bv</code>.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">union bv1 bv2</code> returns the union of the two sets.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">inter bv1 bv2</code> returns the intersection of the two sets.</p></div></div><div class="spec val" id="val-diff_into"><a href="#val-diff_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>diff_into : into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">diff_into ~into t</code> modifies <code class="code">into</code> with only the bits set but not in <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.2</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">diff t1 t2</code> returns those bits found in <code class="code">t1</code> but not in <code class="code">t2</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.2</li></ul></div></div><div class="spec val" id="val-select"><a href="#val-select" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>select : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> array <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> list</code></div><div class="doc"><p><code class="code">select arr bv</code> selects the elements of <code class="code">arr</code> whose index
corresponds to a true bit in <code class="code">bv</code>. If <code class="code">bv</code> is too short, elements of <code class="code">arr</code>
with too high an index cannot be selected and are therefore not
selected.</p></div></div><div class="spec val" id="val-selecti"><a href="#val-selecti" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>selecti : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> array <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span><span class="keyword"> * </span>int) list</code></div><div class="doc"><p>Same as <a href="index.html#val-select">select</a>, but selected elements are paired with their indexes.</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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_seq : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <a href="index.html#type-sequence">sequence</a></code></div><div class="doc"></div></div><div class="spec val" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_seq : int <a href="index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-pp"><a href="#val-pp" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>pp : Format.formatter <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Print the bitvector as a string of bits.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div></body></html>

0
2.0/containers.data/CCBitField/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCBitField/Make/argument-1-X/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-X (containers.data.CCBitField.Make.1-X)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCBitField.Make.1-X</span></h1></header></body></html>

4
2.0/containers.data/CCBitField/Make/index.html Normal file
View file

@ -0,0 +1,4 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (containers.data.CCBitField.Make)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCBitField.Make</span></h1></header><div class="doc"><p>Create a new bitfield type</p></div><h3 class="heading">Parameters</h3><div><div class="spec argument" id="argument-1-X"><a href="#argument-1-X" class="anchor"></a><div class="def argument"><code><a href="argument-1-X/index.html">X</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div></div><h3 class="heading">Signature</h3><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code><span class="keyword"> = </span><span class="keyword">private </span>int</code><code></code></div><div class="doc"><p>Generative type of bitfields. Each instantiation of the functor
should create a new, incompatible type</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 : <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Empty bitfields (all bits 0).</p></div></div><div class="spec type" id="type-field"><a href="#type-field" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>field</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-field">field</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Get the value of this field.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-field">field</a> <span class="keyword">&#8209;&gt;</span> bool <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Set the value of this field.</p></div></div><div class="spec val" id="val-mk_field"><a href="#val-mk_field" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>mk_field : unit <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-field">field</a></code></div><div class="doc"><p>Make a new field.</p></div></div><div class="spec val" id="val-freeze"><a href="#val-freeze" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>freeze : unit <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Prevent new fields from being added. From now on, creating
a field will raise Frozen.</p></div></div><div class="spec val" id="val-total_width"><a href="#val-total_width" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>total_width : unit <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Current width of the bitfield.</p></div></div></body></html>

17
2.0/containers.data/CCBitField/index.html Normal file
View file

@ -0,0 +1,17 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCBitField (containers.data.CCBitField)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCBitField</span></h1></header><h2>Bit Field</h2><p>This module defines efficient bitfields
up to 30 or 62 bits (depending on the architecture) in
a relatively type-safe way.</p><pre><code class="code"> module B = CCBitField.Make(struct end);;
#install_printer B.pp;;
let x = B.mk_field ()
let y = B.mk_field ()
let z = B.mk_field ()
let f = B.empty |&gt; B.set x true |&gt; B.set y true;;
assert (not (B.get z f)) ;;
assert (f |&gt; B.set z true |&gt; B.get z);;
</code></pre><div class="spec exception" id="exception-TooManyFields"><a href="#exception-TooManyFields" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">TooManyFields</span></code></div><div class="doc"><p>Raised when too many fields are packed into one bitfield.</p></div></div><div class="spec exception" id="exception-Frozen"><a href="#exception-Frozen" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Frozen</span></code></div><div class="doc"><p>Raised when a frozen bitfield is modified.</p></div></div><div class="spec val" id="val-max_width"><a href="#val-max_width" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>max_width : int</code></div><div class="doc"><p>System-dependent maximum width for a bitfield, typically 30 or 62.</p></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>Bitfield Signature</h3></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-X/index.html">X</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span>) -&gt; <a href="index.html#module-type-S">S</a></code></div><div class="doc"><p>Create a new bitfield type</p></div></div></body></html>

4
2.0/containers.data/CCBitField/module-type-S/index.html Normal file
View file

@ -0,0 +1,4 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (containers.data.CCBitField.S)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCBitField.S</span></h1></header><div class="doc"><h3>Bitfield Signature</h3></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code><span class="keyword"> = </span><span class="keyword">private </span>int</code><code></code></div><div class="doc"><p>Generative type of bitfields. Each instantiation of the functor
should create a new, incompatible type</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 : <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Empty bitfields (all bits 0).</p></div></div><div class="spec type" id="type-field"><a href="#type-field" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>field</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-field">field</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Get the value of this field.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-field">field</a> <span class="keyword">&#8209;&gt;</span> bool <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Set the value of this field.</p></div></div><div class="spec val" id="val-mk_field"><a href="#val-mk_field" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>mk_field : unit <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-field">field</a></code></div><div class="doc"><p>Make a new field.</p></div></div><div class="spec val" id="val-freeze"><a href="#val-freeze" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>freeze : unit <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Prevent new fields from being added. From now on, creating
a field will raise Frozen.</p></div></div><div class="spec val" id="val-total_width"><a href="#val-total_width" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>total_width : unit <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Current width of the bitfield.</p></div></div></body></html>

0
2.0/containers.data/CCCache/.jbuilder-keep Normal file
View file

38
2.0/containers.data/CCCache/index.html Normal file
View file

@ -0,0 +1,38 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCCache (containers.data.CCCache)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCCache</span></h1></header><h2>Caches</h2><p>Particularly useful for memoization. See <a href="index.html#val-with_cache">with_cache</a> and <a href="index.html#val-with_cache_rec">with_cache_rec</a>
for more details.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.6</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">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</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">&#8209;&gt;</span> int</code><code></code></div><div class="doc"></div></div><h3>Value interface</h3><p>Typical use case: one wants to memoize a function <code class="code">f : 'a -&gt; 'b</code>. Code sample:
</p><pre><code class="code"> let f x =
print_endline &quot;call f&quot;;
x + 1;;
let f' = with_cache (lru 256) f;;
f' 0;; (* prints *)
f' 1;; (* prints *)
f' 0;; (* doesn't print, returns cached value *)</code></pre><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.6</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, 'b) t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : (<span class="type-var">_</span>, <span class="type-var">_</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Clear the content of the cache.</p></div></div><div class="spec type" id="type-callback"><a href="#type-callback" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>('a, 'b) callback</code><code><span class="keyword"> = </span>in_cache:bool <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"><p>Type of the callback that is called once a cached value is found
or not.
Should never raise.</p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">in_cache</span>: is <code class="code">true</code> if the value was in cache, <code class="code">false</code>
if the value was just produced.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-with_cache"><a href="#val-with_cache" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>with_cache : ?&#8288;cb:(<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-callback">callback</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span></code></div><div class="doc"><p><code class="code">with_cache c f</code> behaves like <code class="code">f</code>, but caches calls to <code class="code">f</code> in the
cache <code class="code">c</code>. It always returns the same value as
<code class="code">f x</code>, if <code class="code">f x</code> returns, or raise the same exception.
However, <code class="code">f</code> may not be called if <code class="code">x</code> is in the cache.</p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">cb</span>: called after the value is generated or retrieved.</li></ul></div></div><div class="spec val" id="val-with_cache_rec"><a href="#val-with_cache_rec" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>with_cache_rec : ?&#8288;cb:(<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-callback">callback</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> ((<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span></code></div><div class="doc"><p><code class="code">with_cache_rec c f</code> is a function that first, applies <code class="code">f</code> to
some <code class="code">f' = fix f</code>, such that recursive calls to <code class="code">f'</code> are cached in <code class="code">c</code>.
It is similar to <a href="index.html#val-with_cache">with_cache</a> but with a function that takes as
first argument its own recursive version.
Example (memoized Fibonacci function):
</p><pre><code class="code"> let fib = with_cache_rec (lru 256)
(fun fib' n -&gt; match n with
| 1 | 2 -&gt; 1
| _ -&gt; fib' (n-1) + fib' (n-2)
);;
fib 70;;</code></pre><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">cb</span>: called after the value is generated or retrieved.</li></ul></div></div><div class="spec val" id="val-size"><a href="#val-size" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>size : (<span class="type-var">_</span>, <span class="type-var">_</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Size of the cache (number of entries). At most linear in the number
of entries.</p></div></div><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 : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Iterate on cached values. Should yield <code class="code">size cache</code> pairs.</p></div></div><div class="spec val" id="val-add"><a href="#val-add" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Manually add a cached value. Returns <code class="code">true</code> if the value has successfully
been added, and <code class="code">false</code> if the value was already bound.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.5</li></ul></div></div><div class="spec val" id="val-dummy"><a href="#val-dummy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dummy : (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Dummy cache, never stores any value.</p></div></div><div class="spec val" id="val-linear"><a href="#val-linear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>linear : eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Linear cache with the given size. It stores key/value pairs in
an array and does linear search at every call, so it should only be used
with small size.</p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">eq</span>: optional equality predicate for keys.</li></ul></div></div><div class="spec val" id="val-replacing"><a href="#val-replacing" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>replacing : eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">&#8209;&gt;</span> ?&#8288;hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Replacing cache of the given size. Equality and hash functions can be
parametrized. It's a hash table that handles collisions by replacing
the old value with the new (so a cache entry is evicted when another
entry with the same hash (modulo size) is added).
Never grows wider than the given size.</p></div></div><div class="spec val" id="val-lru"><a href="#val-lru" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>lru : eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">&#8209;&gt;</span> ?&#8288;hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>LRU cache of the given size (&quot;Least Recently Used&quot;: keys that have not been
used recently are deleted first). Never grows wider than the given size.</p></div></div><div class="spec val" id="val-unbounded"><a href="#val-unbounded" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>unbounded : eq:<span class="type-var">'a</span> <a href="index.html#type-equal">equal</a> <span class="keyword">&#8209;&gt;</span> ?&#8288;hash:<span class="type-var">'a</span> <a href="index.html#type-hash">hash</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'b</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Unbounded cache, backed by a Hash table. Will grow forever
unless <a href="index.html#val-clear">clear</a> is called manually.</p></div></div></body></html>

0
2.0/containers.data/CCDeque/.jbuilder-keep Normal file
View file

12
2.0/containers.data/CCDeque/index.html Normal file
View file

@ -0,0 +1,12 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCDeque (containers.data.CCDeque)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCDeque</span></h1></header><h2>Imperative deque</h2><p>This structure provides fast access to its front and back elements,
with O(1) operations</p><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></code><code></code></div><div class="doc"><p>Contains 'a elements, queue in both ways</p></div></div><div class="spec exception" id="exception-Empty"><a href="#exception-Empty" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Empty</span></code></div><div class="doc"></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : unit <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>New deque.</p></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : <span class="type-var">_</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Remove all elements.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></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">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Is the deque empty?</p></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : eq:(<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> bool) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p><code class="code">equal a b</code> checks whether <code class="code">a</code> and <code class="code">b</code> contain the same sequence of
elements.</p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">eq</span>: comparison function for elements.</li><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : cmp:(<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> int) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">compare a b</code> compares lexicographically <code class="code">a</code> and <code class="code">b</code></p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">cmp</span>: comparison function for elements.</li><li><span class="at-tag since">Since</span>: 0.13</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">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of elements.
Used to be linear time, now constant time.</p></div></div><div class="spec val" id="val-push_front"><a href="#val-push_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>push_front : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Push value at the front.</p></div></div><div class="spec val" id="val-push_back"><a href="#val-push_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>push_back : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Push value at the back.</p></div></div><div class="spec val" id="val-peek_front"><a href="#val-peek_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span></code></div><div class="doc"><p>First value, or</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if empty.</li></ul></div></div><div class="spec val" id="val-peek_back"><a href="#val-peek_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span></code></div><div class="doc"><p>Last value, or</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if empty.</li></ul></div></div><div class="spec val" id="val-take_back"><a href="#val-take_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span></code></div><div class="doc"><p>Take last value, or</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if empty.</li></ul></div></div><div class="spec val" id="val-take_front"><a href="#val-take_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span></code></div><div class="doc"><p>Take first value, or</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if empty.</li></ul></div></div><div class="spec val" id="val-append_front"><a href="#val-append_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>append_front : into:<span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">append_front ~into q</code> adds all elements of <code class="code">q</code> at the front
of <code class="code">into</code>.
<code class="code">O(length q)</code> in time.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><div class="spec val" id="val-append_back"><a href="#val-append_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>append_back : into:<span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">append_back ~into q</code> adds all elements of <code class="code">q</code> at the back of <code class="code">into</code>.
<code class="code">O(length q)</code> in time.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><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 : (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Iterate on elements.</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 : (<span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span></code></div><div class="doc"><p>Fold on elements.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><h3>Conversions</h3><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">&#8209;&gt;</span> <span class="type-var">'a</span> option</code><code></code></div><div class="doc"></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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_seq : <span class="type-var">'a</span> <a href="index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</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-to_seq"><a href="#val-to_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_seq : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-sequence">sequence</a></code></div><div class="doc"><p>Iterate on the elements.</p></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">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">of_gen g</code> makes a deque containing the elements of <code class="code">g</code>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></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">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-gen">gen</a></code></div><div class="doc"><p>Iterate on elements of the deque.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><div class="spec val" id="val-add_seq_front"><a href="#val-add_seq_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_seq_front : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">add_seq_front q seq</code> adds elements of <code class="code">seq</code> into the front of <code class="code">q</code>,
in reverse order.
<code class="code">O(n)</code> in time, where <code class="code">n</code> is the number of elements to add.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><div class="spec val" id="val-add_seq_back"><a href="#val-add_seq_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_seq_back : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">add_seq_back q seq</code> adds elements of <code class="code">seq</code> into the back of <code class="code">q</code>,
in order.
<code class="code">O(n)</code> in time, where <code class="code">n</code> is the number of elements to add.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Fresh copy, <code class="code">O(n)</code> in time.</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">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Conversion from list, in order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><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">&#8209;&gt;</span> <span class="type-var">'a</span> list</code></div><div class="doc"><p>List of elements, in order. Less efficient than <a href="index.html#val-to_rev_list">to_rev_list</a>.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></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">&#8209;&gt;</span> <span class="type-var">'a</span> list</code></div><div class="doc"><p>Efficient conversion to list, in reverse order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div><h3>print</h3><div class="spec type" id="type-printer"><a href="#type-printer" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a printer</code><code><span class="keyword"> = </span>Format.formatter <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-pp"><a href="#val-pp" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>pp : <span class="type-var">'a</span> <a href="index.html#type-printer">printer</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <a href="index.html#type-printer">printer</a></code></div><div class="doc"><p>Print the elements.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul></div></div></body></html>

0
2.0/containers.data/CCFQueue/.jbuilder-keep Normal file
View file

8
2.0/containers.data/CCFQueue/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCGraph/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCGraph/Dot/index.html Normal file
View file

File diff suppressed because one or more lines are too long

2
2.0/containers.data/CCGraph/Lazy_tree/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lazy_tree (containers.data.CCGraph.Lazy_tree)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCGraph.Lazy_tree</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>('v, 'e) t</code><code></code><code><span class="keyword"> = </span></code><code>{</code><table class="record"><tr id="type-t.vertex" class="anchored"><td class="def field"><a href="#type-t.vertex" class="anchor"></a><code>vertex : <span class="type-var">'v</span>;</code></td></tr><tr id="type-t.children" class="anchored"><td class="def field"><a href="#type-t.children" class="anchor"></a><code>children : (<span class="type-var">'e</span><span class="keyword"> * </span>(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="index.html#type-t">t</a>) list Lazy.t;</code></td></tr></table><code>}</code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-map_v"><a href="#val-map_v" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>map_v : (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span>, <span class="type-var">'e</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'b</span>, <span class="type-var">'e</span>) <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div><div class="spec val" id="val-fold_v"><a href="#val-fold_v" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>fold_v : (<span class="type-var">'acc</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'acc</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'acc</span> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'v</span>, <span class="type-var">_</span>) <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'acc</span></code></div><div class="doc"></div></div></body></html>

4
2.0/containers.data/CCGraph/Map/index.html Normal file
View file

@ -0,0 +1,4 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Map (containers.data.CCGraph.Map)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCGraph.Map</span></h1></header><h3 class="heading">Parameters</h3><div><div class="spec argument" id="argument-1-O"><a href="#argument-1-O" class="anchor"></a><div class="def argument"><code>O : Map.OrderedType</code></div><div class="doc"></div></div></div><h3 class="heading">Signature</h3><div class="spec type" id="type-vertex"><a href="#type-vertex" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>vertex</code><code><span class="keyword"> = </span><a href="index.html#argument-1-O">O</a>.t</code><code></code></div><div class="doc"></div></div><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></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-as_graph"><a href="#val-as_graph" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>as_graph : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<a href="index.html#type-vertex">vertex</a>, <span class="type-var">'a</span>) <a href="../index.html#type-graph">graph</a></code></div><div class="doc"><p>Graph view of the map.</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"></div></div><div class="spec val" id="val-add_edge"><a href="#val-add_edge" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_edge : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-remove_edge"><a href="#val-remove_edge" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>remove_edge : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-add"><a href="#val-add" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Add a vertex, possibly with no outgoing edge.</p></div></div><div class="spec val" id="val-remove"><a href="#val-remove" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>remove : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Remove the vertex and all its outgoing edges.
Edges that point to the vertex are <b>NOT</b> removed, they must be
manually removed with <a href="index.html#val-remove_edge">remove_edge</a>.</p></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 : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-vertices"><a href="#val-vertices" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>vertices : <span class="type-var">_</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> <a href="../index.html#type-sequence">sequence</a></code></div><div class="doc"></div></div><div class="spec val" id="val-vertices_l"><a href="#val-vertices_l" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>vertices_l : <span class="type-var">_</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> list</code></div><div class="doc"></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 : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) list <span class="keyword">&#8209;&gt;</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-add_list"><a href="#val-add_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_list : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) list <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-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">&#8209;&gt;</span> (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) list</code></div><div class="doc"></div></div><div class="spec val" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_seq : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</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-add_seq"><a href="#val-add_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_seq : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-to_seq"><a href="#val-to_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_seq : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) <a href="../index.html#type-sequence">sequence</a></code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCGraph/Seq/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Seq (containers.data.CCGraph.Seq)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCGraph.Seq</span></h1></header><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> <a href="../index.html#type-sequence">sequence</a></code><code></code></div><div class="doc"></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">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-sequence">sequence</a></code></div><div class="doc"></div></div><div class="spec val" id="val-(&gt;&gt;=)"><a href="#val-(&gt;&gt;=)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(&gt;&gt;=) : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <a href="index.html#type-t">t</a>) <span class="keyword">&#8209;&gt;</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-map"><a href="#val-map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>map : (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-filter_map"><a href="#val-filter_map" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>filter_map : (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> option) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-iter"><a href="#val-iter" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>iter : (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"></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 : (<span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span></code></div><div class="doc"></div></div><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">&#8209;&gt;</span> <span class="type-var">'a</span> list</code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCGraph/Traverse/Event/index.html Normal file
View file

File diff suppressed because one or more lines are too long

7
2.0/containers.data/CCGraph/Traverse/index.html Normal file
View file

@ -0,0 +1,7 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Traverse (containers.data.CCGraph.Traverse)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCGraph.Traverse</span></h1></header><div class="spec type" id="type-path"><a href="#type-path" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>('v, 'e) path</code><code><span class="keyword"> = </span>(<span class="type-var">'v</span><span class="keyword"> * </span><span class="type-var">'e</span><span class="keyword"> * </span><span class="type-var">'v</span>) list</code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-generic"><a href="#val-generic" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>generic : tbl:<span class="type-var">'v</span> <a href="../index.html#type-set">set</a> <span class="keyword">&#8209;&gt;</span> bag:<span class="type-var">'v</span> <a href="../index.html#type-bag">bag</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"><p>Traversal of the given graph, starting from a sequence
of vertices, using the given bag to choose the next vertex to
explore. Each vertex is visited at most once.</p></div></div><div class="spec val" id="val-generic_tag"><a href="#val-generic_tag" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>generic_tag : tags:<span class="type-var">'v</span> <a href="../index.html#type-tag_set">tag_set</a> <span class="keyword">&#8209;&gt;</span> bag:<span class="type-var">'v</span> <a href="../index.html#type-bag">bag</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"><p>One-shot traversal of the graph using a tag set and the given bag</p></div></div><div class="spec val" id="val-dfs"><a href="#val-dfs" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dfs : tbl:<span class="type-var">'v</span> <a href="../index.html#type-set">set</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"></div></div><div class="spec val" id="val-dfs_tag"><a href="#val-dfs_tag" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dfs_tag : tags:<span class="type-var">'v</span> <a href="../index.html#type-tag_set">tag_set</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"></div></div><div class="spec val" id="val-bfs"><a href="#val-bfs" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>bfs : tbl:<span class="type-var">'v</span> <a href="../index.html#type-set">set</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"></div></div><div class="spec val" id="val-bfs_tag"><a href="#val-bfs_tag" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>bfs_tag : tags:<span class="type-var">'v</span> <a href="../index.html#type-tag_set">tag_set</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"></div></div><div class="spec val" id="val-dijkstra"><a href="#val-dijkstra" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dijkstra : tbl:<span class="type-var">'v</span> <a href="../index.html#type-set">set</a> <span class="keyword">&#8209;&gt;</span> ?&#8288;dist:(<span class="type-var">'e</span> <span class="keyword">&#8209;&gt;</span> int) <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'v</span><span class="keyword"> * </span>int<span class="keyword"> * </span>(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="index.html#type-path">path</a>) <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"><p>Dijkstra algorithm, traverses a graph in increasing distance order.
Yields each vertex paired with its distance to the set of initial vertices
(the smallest distance needed to reach the node from the initial vertices)</p><ul class="at-tag"><li><span class="at-tag parameter">Parameter</span> <span class="module-path">dist</span>: distance from origin of the edge to destination,
must be strictly positive. Default is 1 for every edge.</li></ul></div></div><div class="spec val" id="val-dijkstra_tag"><a href="#val-dijkstra_tag" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dijkstra_tag : ?&#8288;dist:(<span class="type-var">'e</span> <span class="keyword">&#8209;&gt;</span> int) <span class="keyword">&#8209;&gt;</span> tags:<span class="type-var">'v</span> <a href="../index.html#type-tag_set">tag_set</a> <span class="keyword">&#8209;&gt;</span> graph:(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'v</span> <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'v</span><span class="keyword"> * </span>int<span class="keyword"> * </span>(<span class="type-var">'v</span>, <span class="type-var">'e</span>) <a href="index.html#type-path">path</a>) <a href="../index.html#type-sequence_once">sequence_once</a></code></div><div class="doc"></div></div><div class="spec module" id="module-Event"><a href="#module-Event" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Event/index.html">Event</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>More detailed interface</h3></div></div></body></html>

36
2.0/containers.data/CCGraph/index.html Normal file
View file

File diff suppressed because one or more lines are too long

4
2.0/containers.data/CCGraph/module-type-MAP/index.html Normal file
View file

@ -0,0 +1,4 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>MAP (containers.data.CCGraph.MAP)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCGraph.MAP</span></h1></header><div class="spec type" id="type-vertex"><a href="#type-vertex" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>vertex</code><code></code><code></code></div><div class="doc"></div></div><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></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-as_graph"><a href="#val-as_graph" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>as_graph : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<a href="index.html#type-vertex">vertex</a>, <span class="type-var">'a</span>) <a href="../index.html#type-graph">graph</a></code></div><div class="doc"><p>Graph view of the map.</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"></div></div><div class="spec val" id="val-add_edge"><a href="#val-add_edge" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_edge : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-remove_edge"><a href="#val-remove_edge" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>remove_edge : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-add"><a href="#val-add" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Add a vertex, possibly with no outgoing edge.</p></div></div><div class="spec val" id="val-remove"><a href="#val-remove" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>remove : <a href="index.html#type-vertex">vertex</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Remove the vertex and all its outgoing edges.
Edges that point to the vertex are <b>NOT</b> removed, they must be
manually removed with <a href="index.html#val-remove_edge">remove_edge</a>.</p></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 : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-vertices"><a href="#val-vertices" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>vertices : <span class="type-var">_</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> <a href="../index.html#type-sequence">sequence</a></code></div><div class="doc"></div></div><div class="spec val" id="val-vertices_l"><a href="#val-vertices_l" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>vertices_l : <span class="type-var">_</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-vertex">vertex</a> list</code></div><div class="doc"></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 : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) list <span class="keyword">&#8209;&gt;</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-add_list"><a href="#val-add_list" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_list : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) list <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-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">&#8209;&gt;</span> (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) list</code></div><div class="doc"></div></div><div class="spec val" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>of_seq : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</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-add_seq"><a href="#val-add_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>add_seq : (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) <a href="../index.html#type-sequence">sequence</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</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-to_seq"><a href="#val-to_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_seq : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<a href="index.html#type-vertex">vertex</a><span class="keyword"> * </span><span class="type-var">'a</span><span class="keyword"> * </span><a href="index.html#type-vertex">vertex</a>) <a href="../index.html#type-sequence">sequence</a></code></div><div class="doc"></div></div></body></html>

0
2.0/containers.data/CCHashSet/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCHashSet/Make/argument-1-E/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-E (containers.data.CCHashSet.Make.1-E)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCHashSet.Make.1-E</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"></div></div><div class="spec val" id="val-hash"><a href="#val-hash" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hash : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Positive value</p></div></div></body></html>

3
2.0/containers.data/CCHashSet/Make/index.html Normal file
View file

File diff suppressed because one or more lines are too long

2
2.0/containers.data/CCHashSet/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCHashSet (containers.data.CCHashSet)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCHashSet</span></h1></header><h2>Mutable Set</h2><p><b>status: unstable</b></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul><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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-printer"><a href="#type-printer" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a printer</code><code><span class="keyword"> = </span>Format.formatter <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-ELEMENT"><a href="#module-type-ELEMENT" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-ELEMENT/index.html">ELEMENT</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-E/index.html">E</a> : <a href="index.html#module-type-ELEMENT">ELEMENT</a>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-elt">elt</a><span class="keyword"> = </span><a href="Make/argument-1-E/index.html#type-t">E.t</a></code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCHashSet/module-type-ELEMENT/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ELEMENT (containers.data.CCHashSet.ELEMENT)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCHashSet.ELEMENT</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"></div></div><div class="spec val" id="val-hash"><a href="#val-hash" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hash : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Positive value</p></div></div></body></html>

3
2.0/containers.data/CCHashSet/module-type-S/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCHashTrie/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCHashTrie/Make/argument-1-K/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-K (containers.data.CCHashTrie.Make.1-K)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCHashTrie.Make.1-K</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"></div></div><div class="spec val" id="val-hash"><a href="#val-hash" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hash : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

9
2.0/containers.data/CCHashTrie/Make/index.html Normal file
View file

File diff suppressed because one or more lines are too long

7
2.0/containers.data/CCHashTrie/Transient/index.html Normal file
View file

@ -0,0 +1,7 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Transient (containers.data.CCHashTrie.Transient)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCHashTrie.Transient</span></h1></header><div class="doc"><h3>Transient Identifiers</h3></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>Identifiers for transient modifications. A transient modification
is uniquely identified by a <code class="code">Transient.t</code>. Once <code class="code">Transient.freeze r</code>
is called, <code class="code">r</code> cannot be used to modify the structure again.</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : unit <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Create a new, active ID.</p></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Equality between IDs.</p></div></div><div class="spec val" id="val-frozen"><a href="#val-frozen" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>frozen : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p><code class="code">frozen i</code> returns <code class="code">true</code> if <code class="code">freeze i</code> was called before. In this case,
the ID cannot be used for modifications again.</p></div></div><div class="spec val" id="val-active"><a href="#val-active" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>active : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p><code class="code">active i</code> is <code class="code">not (frozen i)</code>.</p></div></div><div class="spec val" id="val-freeze"><a href="#val-freeze" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>freeze : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">freeze i</code> makes <code class="code">i</code> unusable for new modifications. The values
created with <code class="code">i</code> will now be immutable.</p></div></div><div class="spec val" id="val-with_"><a href="#val-with_" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>with_ : (<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span></code></div><div class="doc"><p><code class="code">with_ f</code> creates a transient ID <code class="code">i</code>, calls <code class="code">f i</code>,
freezes the ID <code class="code">i</code> and returns the result of <code class="code">f i</code>.</p></div></div><div class="spec exception" id="exception-Frozen"><a href="#exception-Frozen" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Frozen</span></code></div><div class="doc"><p>Raised when a frozen ID is used.</p></div></div></body></html>

6
2.0/containers.data/CCHashTrie/index.html Normal file
View file

@ -0,0 +1,6 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCHashTrie (containers.data.CCHashTrie)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCHashTrie</span></h1></header><h2>Hash Tries</h2><p>Trie indexed by the hash of the keys, where the branching factor is fixed.
The goal is to have a quite efficient functional structure with fast
update and access <b>if</b> the hash function is good.
The trie is not binary, to improve cache locality and decrease depth.</p><p>Preliminary benchmarks (see the &quot;tbl&quot; section of benchmarks) tend to show
that this type is quite efficient for small data sets.</p><p><b>status: unstable</b></p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.13</li></ul><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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></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">&#8209;&gt;</span> <span class="type-var">'a</span> option</code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-printer"><a href="#type-printer" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a printer</code><code><span class="keyword"> = </span>Format.formatter <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-ktree"><a href="#type-ktree" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a ktree</code><code><span class="keyword"> = </span>unit <span class="keyword">&#8209;&gt;</span> [ `Nil | `Node of <span class="type-var">'a</span><span class="keyword"> * </span><span class="type-var">'a</span> <a href="index.html#type-ktree">ktree</a> list ]</code><code></code></div><div class="doc"></div></div><div class="spec module" id="module-Transient"><a href="#module-Transient" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Transient/index.html">Transient</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>Transient Identifiers</h3></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>Signature</h3></div></div><div class="spec module-type" id="module-type-KEY"><a href="#module-type-KEY" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-KEY/index.html">KEY</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>Type for keys</h3></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-K/index.html">K</a> : <a href="index.html#module-type-KEY">KEY</a>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-key">key</a><span class="keyword"> = </span><a href="Make/argument-1-K/index.html#type-t">K.t</a></code></div><div class="doc"><h3>Functors</h3></div></div></body></html>

2
2.0/containers.data/CCHashTrie/module-type-KEY/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>KEY (containers.data.CCHashTrie.KEY)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCHashTrie.KEY</span></h1></header><div class="doc"><h3>Type for keys</h3></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"></div></div><div class="spec val" id="val-hash"><a href="#val-hash" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hash : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

9
2.0/containers.data/CCHashTrie/module-type-S/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCHet/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCHet/Key/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Key (containers.data.CCHet.Key)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCHet.Key</span></h1></header><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></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : unit <span class="keyword">&#8209;&gt;</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-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Compare two keys that have compatible types.</p></div></div></body></html>

2
2.0/containers.data/CCHet/Map/index.html Normal file
View file

File diff suppressed because one or more lines are too long

2
2.0/containers.data/CCHet/Tbl/index.html Normal file
View file

File diff suppressed because one or more lines are too long

3
2.0/containers.data/CCHet/index.html Normal file
View file

@ -0,0 +1,3 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCHet (containers.data.CCHet)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCHet</span></h1></header><h2>Associative containers with Heterogenerous Values</h2><p>This is similar to <a href="../CCMixtbl/index.html">CCMixtbl</a>, but the injection is directly used as
a key.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.17</li></ul><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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></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">&#8209;&gt;</span> <span class="type-var">'a</span> option</code><code></code></div><div class="doc"></div></div><div class="spec module" id="module-Key"><a href="#module-Key" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Key/index.html">Key</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec type" id="type-pair"><a href="#type-pair" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>pair</code><code></code><code><span class="keyword"> = </span></code><table class="variant"><tr id="type-pair.Pair" class="anchored"><td class="def constructor"><a href="#type-pair.Pair" class="anchor"></a><code><span class="keyword">| </span></code><code><span class="constructor">Pair</span><span class="keyword"> : </span><span class="type-var">'a</span> <a href="Key/index.html#type-t">Key.t</a><span class="keyword"> * </span><span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-pair">pair</a></code></td></tr></table><code></code></div><div class="doc"></div></div><div class="spec module" id="module-Tbl"><a href="#module-Tbl" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Tbl/index.html">Tbl</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>Imperative table indexed by <a href="Key/index.html">Key</a></h3></div></div><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"><h3>Immutable map</h3></div></div></body></html>

0
2.0/containers.data/CCImmutArray/.jbuilder-keep Normal file
View file

8
2.0/containers.data/CCImmutArray/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCIntMap/.jbuilder-keep Normal file
View file

3
2.0/containers.data/CCIntMap/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCMixmap/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCMixmap/Make/argument-1-X/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-X (containers.data.CCMixmap.Make.1-X)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCMixmap.Make.1-X</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

4
2.0/containers.data/CCMixmap/Make/index.html Normal file
View file

File diff suppressed because one or more lines are too long

8
2.0/containers.data/CCMixmap/index.html Normal file
View file

@ -0,0 +1,8 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCMixmap (containers.data.CCMixmap)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCMixmap</span></h1></header><div class="spec type" id="type-injection"><a href="#type-injection" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a injection</code><code></code><code></code></div><div class="doc"><p>An accessor for values of type 'a in any map. Values put
in the map using a key can only be retrieved using this
very same key.</p></div></div><div class="spec val" id="val-create_inj"><a href="#val-create_inj" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create_inj : unit <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-injection">injection</a></code></div><div class="doc"><p>Return a value that works for a given type of values. This function is
normally called once for each type of value. Several keys may be
created for the same type, but a value set with a given setter can only be
retrieved with the matching getter. The same key can be reused
across multiple maps (although not in a thread-safe way).</p></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-ORD"><a href="#module-type-ORD" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-ORD/index.html">ORD</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-X/index.html">X</a> : <a href="index.html#module-type-ORD">ORD</a>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-key">key</a><span class="keyword"> = </span><a href="Make/argument-1-X/index.html#type-t">X.t</a></code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCMixmap/module-type-ORD/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ORD (containers.data.CCMixmap.ORD)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCMixmap.ORD</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

4
2.0/containers.data/CCMixmap/module-type-S/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCMixset/.jbuilder-keep Normal file
View file

17
2.0/containers.data/CCMixset/index.html Normal file
View file

@ -0,0 +1,17 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCMixset (containers.data.CCMixset)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCMixset</span></h1></header><h2>Set of Heterogeneous Values</h2><pre><code class="code"> let k1 : int key = newkey () in
let k2 : int key = newkey () in
let k3 : string key = newkey () in
let set =
empty
|&gt; set ~key:k1 1
|&gt; set ~key:k2 2
|&gt; set ~key:k3 &quot;3&quot;
in
assert (get ~key:k1 set = Some 1);
assert (get ~key:k2 set = Some 2);
assert (get ~key:k3 set = Some &quot;3&quot;);
()</code></pre><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</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>t</code><code></code><code></code></div><div class="doc"><p>A set of values of heterogeneous types</p></div></div><div class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a key</code><code></code><code></code></div><div class="doc"><p>A unique &quot;key&quot; to access a value of type <code class="code">'a</code> in a <code class="code">set</code></p></div></div><div class="spec val" id="val-newkey"><a href="#val-newkey" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>newkey : unit <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="index.html#type-key">key</a></code></div><div class="doc"><p><code class="code">newkey ()</code> creates a new unique key that can be used to access
a <code class="code">'a</code> value in a set. Each key created with <code class="code">newkey</code> is distinct
from any other key, even if they have the same type.</p><p>Not thread-safe.</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 : <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Empty set</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : key:<span class="type-var">'a</span> <a href="index.html#type-key">key</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">set ~key v set</code> maps <code class="code">key</code> to <code class="code">v</code> in <code class="code">set</code>. It means that
for every <code class="code">set</code>, <code class="code">get ~key (set ~key v set) = Some v</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : key:<span class="type-var">'a</span> <a href="index.html#type-key">key</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> option</code></div><div class="doc"><p><code class="code">get ~key set</code> obtains the value for <code class="code">key</code> in <code class="code">set</code>, if any.</p></div></div><div class="spec val" id="val-get_exn"><a href="#val-get_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_exn : key:<span class="type-var">'a</span> <a href="index.html#type-key">key</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span></code></div><div class="doc"><p>Same as <a href="index.html#val-get">get</a>, but can fail.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Not_found</span>: if the key is not present.</li></ul></div></div><div class="spec val" id="val-cardinal"><a href="#val-cardinal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>cardinal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of mappings.</p></div></div></body></html>

0
2.0/containers.data/CCMixtbl/.jbuilder-keep Normal file
View file

32
2.0/containers.data/CCMixtbl/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCMultiMap/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCMultiMap/Make/argument-1-K/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-K (containers.data.CCMultiMap.Make.1-K)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCMultiMap.Make.1-K</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCMultiMap/Make/argument-2-V/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>2-V (containers.data.CCMultiMap.Make.2-V)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCMultiMap.Make.2-V</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

3
2.0/containers.data/CCMultiMap/Make/index.html Normal file
View file

File diff suppressed because one or more lines are too long

2
2.0/containers.data/CCMultiMap/MakeBidir/argument-1-L/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-L (containers.data.CCMultiMap.MakeBidir.1-L)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCMultiMap.MakeBidir.1-L</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCMultiMap/MakeBidir/argument-2-R/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>2-R (containers.data.CCMultiMap.MakeBidir.2-R)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCMultiMap.MakeBidir.2-R</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCMultiMap/MakeBidir/index.html Normal file
View file

File diff suppressed because one or more lines are too long

4
2.0/containers.data/CCMultiMap/index.html Normal file
View file

@ -0,0 +1,4 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCMultiMap (containers.data.CCMultiMap)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCMultiMap</span></h1></header><h2>Multimap</h2><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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-OrderedType"><a href="#module-type-OrderedType" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-OrderedType/index.html">OrderedType</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-K/index.html">K</a> : <a href="index.html#module-type-OrderedType">OrderedType</a>) -&gt; <span class="keyword">functor</span> (<a href="Make/argument-2-V/index.html">V</a> : <a href="index.html#module-type-OrderedType">OrderedType</a>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-key">key</a><span class="keyword"> = </span><a href="Make/argument-1-K/index.html#type-t">K.t</a><span class="keyword"> and </span><span class="keyword">type </span><a href="Make/index.html#type-value">value</a><span class="keyword"> = </span><a href="Make/argument-2-V/index.html#type-t">V.t</a></code></div><div class="doc"></div></div><h3>Two-Way Multimap</h3><p>
Represents n-to-n mappings between two types. Each element from the &quot;left&quot;
is mapped to several right values, and conversely.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.3.3</li></ul><div class="spec module-type" id="module-type-BIDIR"><a href="#module-type-BIDIR" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-BIDIR/index.html">BIDIR</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module" id="module-MakeBidir"><a href="#module-MakeBidir" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="MakeBidir/index.html">MakeBidir</a> : <span class="keyword">functor</span> (<a href="MakeBidir/argument-1-L/index.html">L</a> : <a href="index.html#module-type-OrderedType">OrderedType</a>) -&gt; <span class="keyword">functor</span> (<a href="MakeBidir/argument-2-R/index.html">R</a> : <a href="index.html#module-type-OrderedType">OrderedType</a>) -&gt; <a href="index.html#module-type-BIDIR">BIDIR</a><span class="keyword"> with </span><span class="keyword">type </span><a href="MakeBidir/index.html#type-left">left</a><span class="keyword"> = </span><a href="MakeBidir/argument-1-L/index.html#type-t">L.t</a><span class="keyword"> and </span><span class="keyword">type </span><a href="MakeBidir/index.html#type-right">right</a><span class="keyword"> = </span><a href="MakeBidir/argument-2-R/index.html#type-t">R.t</a></code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCMultiMap/module-type-BIDIR/index.html Normal file
View file

File diff suppressed because one or more lines are too long

2
2.0/containers.data/CCMultiMap/module-type-OrderedType/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>OrderedType (containers.data.CCMultiMap.OrderedType)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCMultiMap.OrderedType</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

3
2.0/containers.data/CCMultiMap/module-type-S/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCMultiSet/.jbuilder-keep Normal file
View file

8
2.0/containers.data/CCMultiSet/Make/index.html Normal file
View file

File diff suppressed because one or more lines are too long

2
2.0/containers.data/CCMultiSet/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCMultiSet (containers.data.CCMultiSet)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCMultiSet</span></h1></header><h2>Multiset</h2><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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/index.html#argument-1-O">O</a> : Set.OrderedType) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-elt">elt</a><span class="keyword"> = </span><a href="Make/index.html#argument-1-O">O</a>.t</code></div><div class="doc"></div></div></body></html>

8
2.0/containers.data/CCMultiSet/module-type-S/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCPersistentArray/.jbuilder-keep Normal file
View file

20
2.0/containers.data/CCPersistentArray/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCPersistentHashtbl/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCPersistentHashtbl/Make/argument-1-H/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-H (containers.data.CCPersistentHashtbl.Make.1-H)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCPersistentHashtbl.Make.1-H</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"></div></div><div class="spec val" id="val-hash"><a href="#val-hash" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hash : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

10
2.0/containers.data/CCPersistentHashtbl/Make/index.html Normal file
View file

File diff suppressed because one or more lines are too long

5
2.0/containers.data/CCPersistentHashtbl/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCPersistentHashtbl (containers.data.CCPersistentHashtbl)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCPersistentHashtbl</span></h1></header><h2>Persistent hash-table on top of OCaml's hashtables</h2><p>Almost as efficient as the regular Hashtbl type, but with a persistent
interface (rewinding changes to get back in the past history). This is
mostly useful for backtracking-like uses, or forward uses (never using
old values).</p><p>This module is not thread-safe.</p><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> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-printer"><a href="#type-printer" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>'a printer</code><code><span class="keyword"> = </span>Format.formatter <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> unit</code><code></code></div><div class="doc"></div></div><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">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> bool</code><code></code></div><div class="doc"></div></div><div class="spec module-type" id="module-type-HashedType"><a href="#module-type-HashedType" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-HashedType/index.html">HashedType</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><h3>Signature of such a hashtable</h3><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><h3>Implementation</h3><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-H/index.html">H</a> : <a href="index.html#module-type-HashedType">HashedType</a>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-key">key</a><span class="keyword"> = </span><a href="Make/argument-1-H/index.html#type-t">H.t</a></code></div><div class="doc"></div></div></body></html>

2
2.0/containers.data/CCPersistentHashtbl/module-type-HashedType/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>HashedType (containers.data.CCPersistentHashtbl.HashedType)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCPersistentHashtbl.HashedType</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-equal"><a href="#val-equal" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>equal : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"></div></div><div class="spec val" id="val-hash"><a href="#val-hash" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>hash : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div></body></html>

10
2.0/containers.data/CCPersistentHashtbl/module-type-S/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCRAL/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCRAL/Infix/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Infix (containers.data.CCRAL.Infix)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRAL.Infix</span></h1></header><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">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Cons (alias to <a href="../index.html#val-cons">cons</a>).</p></div></div><div class="spec val" id="val-(&gt;&gt;=)"><a href="#val-(&gt;&gt;=)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(&gt;&gt;=) : <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <a href="../index.html#type-t">t</a>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-flat_map">flat_map</a>.</p></div></div><div class="spec val" id="val-(&gt;|=)"><a href="#val-(&gt;|=)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(&gt;|=) : <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-map">map</a>.</p></div></div><div class="spec val" id="val-(&lt;*&gt;)"><a href="#val-(&lt;*&gt;)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(&lt;*&gt;) : (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-app">app</a></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">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-range">range</a>.</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">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <a href="../index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">a --^ b</code> is the integer range from <code class="code">a</code> to <code class="code">b</code>, where <code class="code">b</code> is excluded.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.17</li></ul></div></div></body></html>

6
2.0/containers.data/CCRAL/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCRingBuffer/.jbuilder-keep Normal file
View file

5
2.0/containers.data/CCRingBuffer/Array/Byte/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Byte (containers.data.CCRingBuffer.Array.Byte)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.Array.Byte</span></h1></header><div class="doc"><p>Efficient array version for the <code class="code">char</code> type</p></div><div class="spec type" id="type-elt"><a href="#type-elt" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>elt</code><code><span class="keyword"> = </span>char</code><code></code></div><div class="doc"><p>The element type</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code><span class="keyword"> = </span>Bytes.t</code><code></code></div><div class="doc"><p>The type of an array instance</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make an array of the given size, filled with dummy elements.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">length t</code> gets the total number of elements currently in <code class="code">t</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a></code></div><div class="doc"><p><code class="code">get t i</code> gets the element at position <code class="code">i</code>.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">set t i e</code> sets the element at position <code class="code">i</code> to <code class="code">e</code>.</p></div></div><div class="spec val" id="val-sub"><a href="#val-sub" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sub : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">sub t i len</code> gets the sub-array of <code class="code">t</code> from
position <code class="code">i</code> to <code class="code">i + len</code>.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">copy t</code> makes a fresh copy of the array <code class="code">t</code>.</p></div></div><div class="spec val" id="val-blit"><a href="#val-blit" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit t s arr i len</code> copies <code class="code">len</code> elements from <code class="code">arr</code> starting at <code class="code">i</code>
to position <code class="code">s</code> from <code class="code">t</code>.</p></div></div><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 : (<a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter f t</code> iterates over the array <code class="code">t</code> invoking <code class="code">f</code> with
the current element, in array order.</p></div></div></body></html>

2
2.0/containers.data/CCRingBuffer/Array/Make/argument-1-Elt/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Elt (containers.data.CCRingBuffer.Array.Make.1-Elt)</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> &mdash; <span class="package">package <a href="../../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCRingBuffer.Array.Make.1-Elt</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-dummy"><a href="#val-dummy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dummy : <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div></body></html>

5
2.0/containers.data/CCRingBuffer/Array/Make/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (containers.data.CCRingBuffer.Array.Make)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.Array.Make</span></h1></header><div class="doc"><p>Makes an array given an arbitrary element type</p></div><h3 class="heading">Parameters</h3><div><div class="spec argument" id="argument-1-Elt"><a href="#argument-1-Elt" class="anchor"></a><div class="def argument"><code><a href="argument-1-Elt/index.html">Elt</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div></div><h3 class="heading">Signature</h3><div class="spec type" id="type-elt"><a href="#type-elt" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>elt</code><code><span class="keyword"> = </span><a href="argument-1-Elt/index.html#type-t">Elt.t</a></code><code></code></div><div class="doc"><p>The element type</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code><span class="keyword"> = </span><a href="argument-1-Elt/index.html#type-t">Elt.t</a> array</code><code></code></div><div class="doc"><p>The type of an array instance</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make an array of the given size, filled with dummy elements.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">length t</code> gets the total number of elements currently in <code class="code">t</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a></code></div><div class="doc"><p><code class="code">get t i</code> gets the element at position <code class="code">i</code>.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">set t i e</code> sets the element at position <code class="code">i</code> to <code class="code">e</code>.</p></div></div><div class="spec val" id="val-sub"><a href="#val-sub" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sub : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">sub t i len</code> gets the sub-array of <code class="code">t</code> from
position <code class="code">i</code> to <code class="code">i + len</code>.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">copy t</code> makes a fresh copy of the array <code class="code">t</code>.</p></div></div><div class="spec val" id="val-blit"><a href="#val-blit" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit t s arr i len</code> copies <code class="code">len</code> elements from <code class="code">arr</code> starting at <code class="code">i</code>
to position <code class="code">s</code> from <code class="code">t</code>.</p></div></div><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 : (<a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter f t</code> iterates over the array <code class="code">t</code> invoking <code class="code">f</code> with
the current element, in array order.</p></div></div></body></html>

2
2.0/containers.data/CCRingBuffer/Array/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Array (containers.data.CCRingBuffer.Array)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.Array</span></h1></header><div class="doc"><p>The abstract type for arrays</p></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div><div class="spec module" id="module-Byte"><a href="#module-Byte" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Byte/index.html">Byte</a> : <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="module-type-S/index.html#type-elt">elt</a><span class="keyword"> = </span>char<span class="keyword"> and </span><span class="keyword">type </span><a href="module-type-S/index.html#type-t">t</a><span class="keyword"> = </span>Bytes.t</code></div><div class="doc"><p>Efficient array version for the <code class="code">char</code> type</p></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-Elt/index.html">Elt</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/index.html#type-elt">elt</a><span class="keyword"> = </span><a href="Make/argument-1-Elt/index.html#type-t">Elt.t</a><span class="keyword"> and </span><span class="keyword">type </span><a href="Make/index.html#type-t">t</a><span class="keyword"> = </span><a href="Make/argument-1-Elt/index.html#type-t">Elt.t</a> array</code></div><div class="doc"><p>Makes an array given an arbitrary element type</p></div></div></body></html>

5
2.0/containers.data/CCRingBuffer/Array/module-type-S/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (containers.data.CCRingBuffer.Array.S)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCRingBuffer.Array.S</span></h1></header><div class="spec type" id="type-elt"><a href="#type-elt" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>elt</code><code></code><code></code></div><div class="doc"><p>The element type</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>The type of an array instance</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make an array of the given size, filled with dummy elements.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">length t</code> gets the total number of elements currently in <code class="code">t</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a></code></div><div class="doc"><p><code class="code">get t i</code> gets the element at position <code class="code">i</code>.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">set t i e</code> sets the element at position <code class="code">i</code> to <code class="code">e</code>.</p></div></div><div class="spec val" id="val-sub"><a href="#val-sub" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sub : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">sub t i len</code> gets the sub-array of <code class="code">t</code> from
position <code class="code">i</code> to <code class="code">i + len</code>.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">copy t</code> makes a fresh copy of the array <code class="code">t</code>.</p></div></div><div class="spec val" id="val-blit"><a href="#val-blit" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit t s arr i len</code> copies <code class="code">len</code> elements from <code class="code">arr</code> starting at <code class="code">i</code>
to position <code class="code">s</code> from <code class="code">t</code>.</p></div></div><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 : (<a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter f t</code> iterates over the array <code class="code">t</code> invoking <code class="code">f</code> with
the current element, in array order.</p></div></div></body></html>

15
2.0/containers.data/CCRingBuffer/Byte/index.html Normal file
View file

@ -0,0 +1,15 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Byte (containers.data.CCRingBuffer.Byte)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.Byte</span></h1></header><div class="doc"><p>An efficient byte based ring buffer</p></div><div class="spec module" id="module-Array"><a href="#module-Array" class="anchor"></a><div class="def module"><code><span class="keyword">module </span>Array = <a href="../Array/index.html#module-Byte">Array.Byte</a></code></div><div class="doc"><p>The module type of Array for this ring buffer</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>Defines the bounded ring buffer type</p></div></div><div class="spec exception" id="exception-Empty"><a href="#exception-Empty" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Empty</span></code></div><div class="doc"><p>Raised in querying functions when the buffer is empty</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">create size</code> creates a new bounded buffer with given size.
The underlying array is allocated immediately and no further (large)
allocation will happen from now on.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the arguments is <code class="code">&lt; 1</code>.</li></ul></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make a fresh copy of the buffer.</p></div></div><div class="spec val" id="val-capacity"><a href="#val-capacity" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>capacity : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Length of the inner buffer.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of elements currently stored in the buffer.</p></div></div><div class="spec val" id="val-is_full"><a href="#val-is_full" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>is_full : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>true if pushing an element would erase another element.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-blit_from"><a href="#val-blit_from" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_from : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit_from buf from_buf o len</code> copies the slice <code class="code">o, ... o + len - 1</code> from
a input buffer <code class="code">from_buf</code> to the end of the buffer.
If the slice is too large for the buffer, only the last part of the array
will be copied.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></div></div><div class="spec val" id="val-blit_into"><a href="#val-blit_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_into : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">blit_into buf to_buf o len</code> copies at most <code class="code">len</code> elements from <code class="code">buf</code>
into <code class="code">to_buf</code> starting at offset <code class="code">o</code> in <code class="code">s</code>.</p><ul class="at-tag"><li><span class="at-tag return">Returns</span> the number of elements actually copied (<code class="code">min len (length buf)</code>).</li><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">append b ~into</code> copies all data from <code class="code">b</code> and adds it at the
end of <code class="code">into</code>. Erases data of <code class="code">into</code> if there is not enough room.</p></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> list</code></div><div class="doc"><p>Extract the current content into a list.</p></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Clear the content of the buffer. Doesn't actually destroy the content.</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Is the buffer empty (i.e. contains no elements)?</p></div></div><div class="spec val" id="val-junk_front"><a href="#val-junk_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the front element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-junk_back"><a href="#val-junk_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the back element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-skip"><a href="#val-skip" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>skip : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">skip b len</code> removes <code class="code">len</code> elements from the front of <code class="code">b</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">len &gt; length b</code>.</li></ul></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(<a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iteri b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</code>, with <code class="code">i</code>
being its relative index within <code class="code">buf</code>.</p></div></div><div class="spec val" id="val-get_front"><a href="#val-get_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_front buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the front, ie
the one returned by <code class="code">take_front buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_front buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-get_back"><a href="#val-get_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_back buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the back, ie
the one returned by <code class="code">take_back buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_back buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-push_back"><a href="#val-push_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>push_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Push value at the back of <code class="code">t</code>.
If <code class="code">t.bounded=false</code>, the buffer will grow as needed,
otherwise the oldest elements are replaced first.</p></div></div><div class="spec val" id="val-peek_front"><a href="#val-peek_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_front_exn"><a href="#val-peek_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-peek_back"><a href="#val-peek_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_back_exn"><a href="#val-peek_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-take_back"><a href="#val-take_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_back_exn"><a href="#val-take_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></div></div><div class="spec val" id="val-take_front"><a href="#val-take_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_front_exn"><a href="#val-take_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></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 : <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Create a buffer from an initial array, but doesn't take ownership
of it (still allocates a new internal array).</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_array"><a href="#val-to_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_array : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a></code></div><div class="doc"><p>Create an array from the elements, in order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div></body></html>

5
2.0/containers.data/CCRingBuffer/Make/Array/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Array (containers.data.CCRingBuffer.Make.Array)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.Make.Array</span></h1></header><div class="doc"><p>The module type of Array for this ring buffer</p></div><div class="spec type" id="type-elt"><a href="#type-elt" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>elt</code><code><span class="keyword"> = </span><a href="../argument-1-X/index.html#type-t">X.t</a></code><code></code></div><div class="doc"><p>The element type</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code><span class="keyword"> = </span><a href="../argument-1-X/index.html#type-t">X.t</a> array</code><code></code></div><div class="doc"><p>The type of an array instance</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make an array of the given size, filled with dummy elements.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">length t</code> gets the total number of elements currently in <code class="code">t</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a></code></div><div class="doc"><p><code class="code">get t i</code> gets the element at position <code class="code">i</code>.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">set t i e</code> sets the element at position <code class="code">i</code> to <code class="code">e</code>.</p></div></div><div class="spec val" id="val-sub"><a href="#val-sub" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sub : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">sub t i len</code> gets the sub-array of <code class="code">t</code> from
position <code class="code">i</code> to <code class="code">i + len</code>.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">copy t</code> makes a fresh copy of the array <code class="code">t</code>.</p></div></div><div class="spec val" id="val-blit"><a href="#val-blit" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit t s arr i len</code> copies <code class="code">len</code> elements from <code class="code">arr</code> starting at <code class="code">i</code>
to position <code class="code">s</code> from <code class="code">t</code>.</p></div></div><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 : (<a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter f t</code> iterates over the array <code class="code">t</code> invoking <code class="code">f</code> with
the current element, in array order.</p></div></div></body></html>

2
2.0/containers.data/CCRingBuffer/Make/argument-1-X/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-X (containers.data.CCRingBuffer.Make.1-X)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCRingBuffer.Make.1-X</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-dummy"><a href="#val-dummy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>dummy : <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div></body></html>

15
2.0/containers.data/CCRingBuffer/Make/index.html Normal file
View file

@ -0,0 +1,15 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (containers.data.CCRingBuffer.Make)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.Make</span></h1></header><div class="doc"><p>Buffer using regular arrays</p></div><h3 class="heading">Parameters</h3><div><div class="spec argument" id="argument-1-X"><a href="#argument-1-X" class="anchor"></a><div class="def argument"><code><a href="argument-1-X/index.html">X</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"></div></div></div><h3 class="heading">Signature</h3><div class="spec module" id="module-Array"><a href="#module-Array" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Array/index.html">Array</a> : <a href="../Array/index.html#module-type-S">Array.S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="../Array/module-type-S/index.html#type-elt">elt</a><span class="keyword"> = </span><a href="argument-1-X/index.html#type-t">X.t</a><span class="keyword"> and </span><span class="keyword">type </span><a href="../Array/module-type-S/index.html#type-t">t</a><span class="keyword"> = </span><a href="argument-1-X/index.html#type-t">X.t</a> array</code></div><div class="doc"><p>The module type of Array for this ring buffer</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>Defines the bounded ring buffer type</p></div></div><div class="spec exception" id="exception-Empty"><a href="#exception-Empty" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Empty</span></code></div><div class="doc"><p>Raised in querying functions when the buffer is empty</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">create size</code> creates a new bounded buffer with given size.
The underlying array is allocated immediately and no further (large)
allocation will happen from now on.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the arguments is <code class="code">&lt; 1</code>.</li></ul></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make a fresh copy of the buffer.</p></div></div><div class="spec val" id="val-capacity"><a href="#val-capacity" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>capacity : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Length of the inner buffer.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of elements currently stored in the buffer.</p></div></div><div class="spec val" id="val-is_full"><a href="#val-is_full" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>is_full : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>true if pushing an element would erase another element.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-blit_from"><a href="#val-blit_from" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_from : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit_from buf from_buf o len</code> copies the slice <code class="code">o, ... o + len - 1</code> from
a input buffer <code class="code">from_buf</code> to the end of the buffer.
If the slice is too large for the buffer, only the last part of the array
will be copied.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></div></div><div class="spec val" id="val-blit_into"><a href="#val-blit_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_into : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">blit_into buf to_buf o len</code> copies at most <code class="code">len</code> elements from <code class="code">buf</code>
into <code class="code">to_buf</code> starting at offset <code class="code">o</code> in <code class="code">s</code>.</p><ul class="at-tag"><li><span class="at-tag return">Returns</span> the number of elements actually copied (<code class="code">min len (length buf)</code>).</li><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">append b ~into</code> copies all data from <code class="code">b</code> and adds it at the
end of <code class="code">into</code>. Erases data of <code class="code">into</code> if there is not enough room.</p></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> list</code></div><div class="doc"><p>Extract the current content into a list.</p></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Clear the content of the buffer. Doesn't actually destroy the content.</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Is the buffer empty (i.e. contains no elements)?</p></div></div><div class="spec val" id="val-junk_front"><a href="#val-junk_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the front element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-junk_back"><a href="#val-junk_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the back element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-skip"><a href="#val-skip" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>skip : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">skip b len</code> removes <code class="code">len</code> elements from the front of <code class="code">b</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">len &gt; length b</code>.</li></ul></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(<a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iteri b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</code>, with <code class="code">i</code>
being its relative index within <code class="code">buf</code>.</p></div></div><div class="spec val" id="val-get_front"><a href="#val-get_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_front buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the front, ie
the one returned by <code class="code">take_front buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_front buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-get_back"><a href="#val-get_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_back buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the back, ie
the one returned by <code class="code">take_back buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_back buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-push_back"><a href="#val-push_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>push_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Push value at the back of <code class="code">t</code>.
If <code class="code">t.bounded=false</code>, the buffer will grow as needed,
otherwise the oldest elements are replaced first.</p></div></div><div class="spec val" id="val-peek_front"><a href="#val-peek_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_front_exn"><a href="#val-peek_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-peek_back"><a href="#val-peek_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_back_exn"><a href="#val-peek_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-take_back"><a href="#val-take_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_back_exn"><a href="#val-take_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></div></div><div class="spec val" id="val-take_front"><a href="#val-take_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_front_exn"><a href="#val-take_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></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 : <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Create a buffer from an initial array, but doesn't take ownership
of it (still allocates a new internal array).</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_array"><a href="#val-to_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_array : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a></code></div><div class="doc"><p>Create an array from the elements, in order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div></body></html>

5
2.0/containers.data/CCRingBuffer/MakeFromArray/argument-1-A/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-A (containers.data.CCRingBuffer.MakeFromArray.1-A)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCRingBuffer.MakeFromArray.1-A</span></h1></header><div class="spec type" id="type-elt"><a href="#type-elt" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>elt</code><code></code><code></code></div><div class="doc"><p>The element type</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>The type of an array instance</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make an array of the given size, filled with dummy elements.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">length t</code> gets the total number of elements currently in <code class="code">t</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a></code></div><div class="doc"><p><code class="code">get t i</code> gets the element at position <code class="code">i</code>.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">set t i e</code> sets the element at position <code class="code">i</code> to <code class="code">e</code>.</p></div></div><div class="spec val" id="val-sub"><a href="#val-sub" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sub : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">sub t i len</code> gets the sub-array of <code class="code">t</code> from
position <code class="code">i</code> to <code class="code">i + len</code>.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">copy t</code> makes a fresh copy of the array <code class="code">t</code>.</p></div></div><div class="spec val" id="val-blit"><a href="#val-blit" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit t s arr i len</code> copies <code class="code">len</code> elements from <code class="code">arr</code> starting at <code class="code">i</code>
to position <code class="code">s</code> from <code class="code">t</code>.</p></div></div><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 : (<a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter f t</code> iterates over the array <code class="code">t</code> invoking <code class="code">f</code> with
the current element, in array order.</p></div></div></body></html>

15
2.0/containers.data/CCRingBuffer/MakeFromArray/index.html Normal file
View file

@ -0,0 +1,15 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>MakeFromArray (containers.data.CCRingBuffer.MakeFromArray)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.MakeFromArray</span></h1></header><div class="doc"><p>Makes a ring buffer module with the given array type.</p></div><h3 class="heading">Parameters</h3><div><div class="spec argument" id="argument-1-A"><a href="#argument-1-A" class="anchor"></a><div class="def argument"><code><a href="argument-1-A/index.html">A</a> : <a href="../Array/index.html#module-type-S">Array.S</a></code></div><div class="doc"></div></div></div><h3 class="heading">Signature</h3><div class="spec module" id="module-Array"><a href="#module-Array" class="anchor"></a><div class="def module"><code><span class="keyword">module </span>Array = <a href="index.html#argument-1-A">A</a></code></div><div class="doc"><p>The module type of Array for this ring buffer</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>Defines the bounded ring buffer type</p></div></div><div class="spec exception" id="exception-Empty"><a href="#exception-Empty" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Empty</span></code></div><div class="doc"><p>Raised in querying functions when the buffer is empty</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">create size</code> creates a new bounded buffer with given size.
The underlying array is allocated immediately and no further (large)
allocation will happen from now on.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the arguments is <code class="code">&lt; 1</code>.</li></ul></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make a fresh copy of the buffer.</p></div></div><div class="spec val" id="val-capacity"><a href="#val-capacity" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>capacity : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Length of the inner buffer.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of elements currently stored in the buffer.</p></div></div><div class="spec val" id="val-is_full"><a href="#val-is_full" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>is_full : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>true if pushing an element would erase another element.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-blit_from"><a href="#val-blit_from" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_from : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit_from buf from_buf o len</code> copies the slice <code class="code">o, ... o + len - 1</code> from
a input buffer <code class="code">from_buf</code> to the end of the buffer.
If the slice is too large for the buffer, only the last part of the array
will be copied.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></div></div><div class="spec val" id="val-blit_into"><a href="#val-blit_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_into : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">blit_into buf to_buf o len</code> copies at most <code class="code">len</code> elements from <code class="code">buf</code>
into <code class="code">to_buf</code> starting at offset <code class="code">o</code> in <code class="code">s</code>.</p><ul class="at-tag"><li><span class="at-tag return">Returns</span> the number of elements actually copied (<code class="code">min len (length buf)</code>).</li><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">append b ~into</code> copies all data from <code class="code">b</code> and adds it at the
end of <code class="code">into</code>. Erases data of <code class="code">into</code> if there is not enough room.</p></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> list</code></div><div class="doc"><p>Extract the current content into a list.</p></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Clear the content of the buffer. Doesn't actually destroy the content.</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Is the buffer empty (i.e. contains no elements)?</p></div></div><div class="spec val" id="val-junk_front"><a href="#val-junk_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the front element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-junk_back"><a href="#val-junk_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the back element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-skip"><a href="#val-skip" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>skip : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">skip b len</code> removes <code class="code">len</code> elements from the front of <code class="code">b</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">len &gt; length b</code>.</li></ul></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(<a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iteri b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</code>, with <code class="code">i</code>
being its relative index within <code class="code">buf</code>.</p></div></div><div class="spec val" id="val-get_front"><a href="#val-get_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_front buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the front, ie
the one returned by <code class="code">take_front buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_front buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-get_back"><a href="#val-get_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_back buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the back, ie
the one returned by <code class="code">take_back buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_back buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-push_back"><a href="#val-push_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>push_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Push value at the back of <code class="code">t</code>.
If <code class="code">t.bounded=false</code>, the buffer will grow as needed,
otherwise the oldest elements are replaced first.</p></div></div><div class="spec val" id="val-peek_front"><a href="#val-peek_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_front_exn"><a href="#val-peek_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-peek_back"><a href="#val-peek_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_back_exn"><a href="#val-peek_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-take_back"><a href="#val-take_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_back_exn"><a href="#val-take_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></div></div><div class="spec val" id="val-take_front"><a href="#val-take_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_front_exn"><a href="#val-take_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></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 : <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Create a buffer from an initial array, but doesn't take ownership
of it (still allocates a new internal array).</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_array"><a href="#val-to_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_array : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a></code></div><div class="doc"><p>Create an array from the elements, in order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div></body></html>

2
2.0/containers.data/CCRingBuffer/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CCRingBuffer (containers.data.CCRingBuffer)</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> &mdash; <span class="package">package <a href="../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer</span></h1></header><h3>Underlying Array</h3><div class="spec module" id="module-Array"><a href="#module-Array" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Array/index.html">Array</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><p>The abstract type for arrays</p></div></div><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><div class="def module-type"><code><span class="keyword">module type </span><a href="module-type-S/index.html">S</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="doc"><h3>Ring Buffer</h3></div></div><div class="spec module" id="module-Byte"><a href="#module-Byte" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Byte/index.html">Byte</a> : <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">module </span><a href="module-type-S/Array/index.html">Array</a> = <a href="Array/index.html#module-Byte">Array.Byte</a></code></div><div class="doc"><p>An efficient byte based ring buffer</p></div></div><div class="spec module" id="module-MakeFromArray"><a href="#module-MakeFromArray" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="MakeFromArray/index.html">MakeFromArray</a> : <span class="keyword">functor</span> (<a href="MakeFromArray/argument-1-A/index.html">A</a> : <a href="Array/index.html#module-type-S">Array.S</a>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">module </span><a href="MakeFromArray/Array/index.html">Array</a> = <a href="MakeFromArray/index.html#argument-1-A">A</a></code></div><div class="doc"><p>Makes a ring buffer module with the given array type.</p></div></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-X/index.html">X</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span>) -&gt; <a href="index.html#module-type-S">S</a><span class="keyword"> with </span><span class="keyword">type </span><a href="Make/Array/index.html#type-elt">Array.elt</a><span class="keyword"> = </span><a href="Make/argument-1-X/index.html#type-t">X.t</a><span class="keyword"> and </span><span class="keyword">type </span><a href="Make/Array/index.html#type-t">Array.t</a><span class="keyword"> = </span><a href="Make/argument-1-X/index.html#type-t">X.t</a> array</code></div><div class="doc"><p>Buffer using regular arrays</p></div></div></body></html>

5
2.0/containers.data/CCRingBuffer/module-type-S/Array/index.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Array (containers.data.CCRingBuffer.S.Array)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCRingBuffer.S.Array</span></h1></header><div class="doc"><p>The module type of Array for this ring buffer</p></div><div class="spec type" id="type-elt"><a href="#type-elt" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>elt</code><code></code><code></code></div><div class="doc"><p>The element type</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>The type of an array instance</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make an array of the given size, filled with dummy elements.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">length t</code> gets the total number of elements currently in <code class="code">t</code>.</p></div></div><div class="spec val" id="val-get"><a href="#val-get" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a></code></div><div class="doc"><p><code class="code">get t i</code> gets the element at position <code class="code">i</code>.</p></div></div><div class="spec val" id="val-set"><a href="#val-set" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>set : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">set t i e</code> sets the element at position <code class="code">i</code> to <code class="code">e</code>.</p></div></div><div class="spec val" id="val-sub"><a href="#val-sub" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>sub : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">sub t i len</code> gets the sub-array of <code class="code">t</code> from
position <code class="code">i</code> to <code class="code">i + len</code>.</p></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">copy t</code> makes a fresh copy of the array <code class="code">t</code>.</p></div></div><div class="spec val" id="val-blit"><a href="#val-blit" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit t s arr i len</code> copies <code class="code">len</code> elements from <code class="code">arr</code> starting at <code class="code">i</code>
to position <code class="code">s</code> from <code class="code">t</code>.</p></div></div><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 : (<a href="index.html#type-elt">elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter f t</code> iterates over the array <code class="code">t</code> invoking <code class="code">f</code> with
the current element, in array order.</p></div></div></body></html>

16
2.0/containers.data/CCRingBuffer/module-type-S/index.html Normal file
View file

@ -0,0 +1,16 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (containers.data.CCRingBuffer.S)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module type</span> <span class="module-path">CCRingBuffer.S</span></h1></header><div class="doc"><h3>Ring Buffer</h3><p>The abstract ring buffer type, made concrete by choice of
<code class="code">ARRAY</code> module implementation</p></div><div class="spec module" id="module-Array"><a href="#module-Array" class="anchor"></a><div class="def module"><code><span class="keyword">module </span><a href="Array/index.html">Array</a> : <a href="../Array/index.html#module-type-S">Array.S</a></code></div><div class="doc"><p>The module type of Array for this ring buffer</p></div></div><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"><p>Defines the bounded ring buffer type</p></div></div><div class="spec exception" id="exception-Empty"><a href="#exception-Empty" class="anchor"></a><div class="def exception"><code><span class="keyword">exception </span></code><code><span class="exception">Empty</span></code></div><div class="doc"><p>Raised in querying functions when the buffer is empty</p></div></div><div class="spec val" id="val-create"><a href="#val-create" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>create : int <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p><code class="code">create size</code> creates a new bounded buffer with given size.
The underlying array is allocated immediately and no further (large)
allocation will happen from now on.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the arguments is <code class="code">&lt; 1</code>.</li></ul></div></div><div class="spec val" id="val-copy"><a href="#val-copy" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>copy : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Make a fresh copy of the buffer.</p></div></div><div class="spec val" id="val-capacity"><a href="#val-capacity" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>capacity : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Length of the inner buffer.</p></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p>Number of elements currently stored in the buffer.</p></div></div><div class="spec val" id="val-is_full"><a href="#val-is_full" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>is_full : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>true if pushing an element would erase another element.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-blit_from"><a href="#val-blit_from" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_from : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">blit_from buf from_buf o len</code> copies the slice <code class="code">o, ... o + len - 1</code> from
a input buffer <code class="code">from_buf</code> to the end of the buffer.
If the slice is too large for the buffer, only the last part of the array
will be copied.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></div></div><div class="spec val" id="val-blit_into"><a href="#val-blit_into" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>blit_into : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"><p><code class="code">blit_into buf to_buf o len</code> copies at most <code class="code">len</code> elements from <code class="code">buf</code>
into <code class="code">to_buf</code> starting at offset <code class="code">o</code> in <code class="code">s</code>.</p><ul class="at-tag"><li><span class="at-tag return">Returns</span> the number of elements actually copied (<code class="code">min len (length buf)</code>).</li><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">o,len</code> is not a valid slice of <code class="code">s</code>.</li></ul></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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> into:<a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">append b ~into</code> copies all data from <code class="code">b</code> and adds it at the
end of <code class="code">into</code>. Erases data of <code class="code">into</code> if there is not enough room.</p></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> list</code></div><div class="doc"><p>Extract the current content into a list.</p></div></div><div class="spec val" id="val-clear"><a href="#val-clear" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>clear : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Clear the content of the buffer. Doesn't actually destroy the content.</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> bool</code></div><div class="doc"><p>Is the buffer empty (i.e. contains no elements)?</p></div></div><div class="spec val" id="val-junk_front"><a href="#val-junk_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the front element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-junk_back"><a href="#val-junk_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>junk_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Drop the back element from <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if the buffer is already empty.</li></ul></div></div><div class="spec val" id="val-skip"><a href="#val-skip" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>skip : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">skip b len</code> removes <code class="code">len</code> elements from the front of <code class="code">b</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if <code class="code">len &gt; length b</code>.</li></ul></div></div><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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(<a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iter b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</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 : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> f:(int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit) <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p><code class="code">iteri b ~f</code> calls <code class="code">f i t</code> for each element <code class="code">t</code> in <code class="code">buf</code>, with <code class="code">i</code>
being its relative index within <code class="code">buf</code>.</p></div></div><div class="spec val" id="val-get_front"><a href="#val-get_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_front buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the front, ie
the one returned by <code class="code">take_front buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_front buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-get_back"><a href="#val-get_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>get_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> int <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p><code class="code">get_back buf i</code> returns the <code class="code">i</code>-th element of <code class="code">buf</code> from the back, ie
the one returned by <code class="code">take_back buf</code> after <code class="code">i-1</code> calls to <code class="code">junk_back buf</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Invalid_argument</span>: if the index is invalid (&gt; <code class="code">length buf</code>).</li></ul></div></div><div class="spec val" id="val-push_back"><a href="#val-push_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>push_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> <span class="keyword">&#8209;&gt;</span> unit</code></div><div class="doc"><p>Push value at the back of <code class="code">t</code>.
If <code class="code">t.bounded=false</code>, the buffer will grow as needed,
otherwise the oldest elements are replaced first.</p></div></div><div class="spec val" id="val-peek_front"><a href="#val-peek_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_front_exn"><a href="#val-peek_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>First value from front of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-peek_back"><a href="#val-peek_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p></div></div><div class="spec val" id="val-peek_back_exn"><a href="#val-peek_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>peek_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Get the last value from back of <code class="code">t</code>, without modification.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is empty.</li><li><span class="at-tag since">Since</span>: 1.3</li></ul></div></div><div class="spec val" id="val-take_back"><a href="#val-take_back" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_back_exn"><a href="#val-take_back_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_back_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the last value from back of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></div></div><div class="spec val" id="val-take_front"><a href="#val-take_front" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a> option</code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>, if any.</p></div></div><div class="spec val" id="val-take_front_exn"><a href="#val-take_front_exn" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>take_front_exn : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-elt">Array.elt</a></code></div><div class="doc"><p>Take and remove the first value from front of <code class="code">t</code>.</p><ul class="at-tag"><li><span class="at-tag raise">Raises</span> <span class="module-path">Empty</span>: if buffer is already empty.</li></ul></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 : <a href="Array/index.html#type-t">Array.t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"><p>Create a buffer from an initial array, but doesn't take ownership
of it (still allocates a new internal array).</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_array"><a href="#val-to_array" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_array : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="Array/index.html#type-t">Array.t</a></code></div><div class="doc"><p>Create an array from the elements, in order.</p><ul class="at-tag"><li><span class="at-tag since">Since</span>: 0.11</li></ul></div></div></body></html>

0
2.0/containers.data/CCSimple_queue/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCSimple_queue/Infix/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Infix (containers.data.CCSimple_queue.Infix)</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> &mdash; <span class="package">package <a href="../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Module</span> <span class="module-path">CCSimple_queue.Infix</span></h1></header><div class="spec val" id="val-(&gt;|=)"><a href="#val-(&gt;|=)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(&gt;|=) : <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> (<span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span>) <span class="keyword">&#8209;&gt;</span> <span class="type-var">'b</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-map">map</a>.</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">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-map">map</a>.</p><p>Alias to <a href="../index.html#val-append">append</a>.</p></div></div><div class="spec val" id="val-(&lt;::)"><a href="#val-(&lt;::)" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>(&lt;::) : <span class="type-var">'a</span> <a href="../index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <span class="keyword">&#8209;&gt;</span> <span class="type-var">'a</span> <a href="../index.html#type-t">t</a></code></div><div class="doc"><p>Alias to <a href="../index.html#val-append">append</a>.</p><p>Alias to <a href="../index.html#val-snoc">snoc</a>.</p></div></div></body></html>

4
2.0/containers.data/CCSimple_queue/index.html Normal file
View file

File diff suppressed because one or more lines are too long

0
2.0/containers.data/CCTrie/.jbuilder-keep Normal file
View file

2
2.0/containers.data/CCTrie/Make/argument-1-W/index.html Normal file
View file

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-W (containers.data.CCTrie.Make.1-W)</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> &mdash; <span class="package">package <a href="../../../index.html">containers.data</a></span></nav><header><h1><span class="keyword">Parameter</span> <span class="module-path">CCTrie.Make.1-W</span></h1></header><div class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>t</code><code></code><code></code></div><div class="doc"></div></div><div class="spec type" id="type-char_"><a href="#type-char_" class="anchor"></a><div class="def type"><code><span class="keyword">type </span>char_</code><code></code><code></code></div><div class="doc"></div></div><div class="spec val" id="val-compare"><a href="#val-compare" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>compare : <a href="index.html#type-char_">char_</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-char_">char_</a> <span class="keyword">&#8209;&gt;</span> int</code></div><div class="doc"></div></div><div class="spec val" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><div class="def val"><code><span class="keyword">val </span>to_seq : <a href="index.html#type-t">t</a> <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-char_">char_</a> <a href="../../index.html#type-sequence">sequence</a></code></div><div class="doc"></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 : <a href="index.html#type-char_">char_</a> list <span class="keyword">&#8209;&gt;</span> <a href="index.html#type-t">t</a></code></div><div class="doc"></div></div></body></html>

Some files were not shown because too many files have changed in this diff Show more