mirror of
https://github.com/c-cube/iter.git
synced 2026-01-21 16:56:40 -05:00
update api
This commit is contained in:
Simon Cruanes
parent
b45371d06d
commit
19ee791141
32 changed files with 2536 additions and 972 deletions
|
|
@ -4,18 +4,54 @@
|
|||
<link rel="stylesheet" href="style.css" type="text/css">
|
||||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link rel="previous" href="Sequence.TypeClass.html">
|
||||
<link rel="previous" href="Sequence.Map.html">
|
||||
<link rel="next" href="Sequence.IO.html">
|
||||
<link rel="Up" href="Sequence.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Infix</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Infix</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"><a class="pre" href="Sequence.TypeClass.html" title="Sequence.TypeClass">Previous</a>
|
||||
<div class="navbar"><a class="pre" href="Sequence.Map.html" title="Sequence.Map">Previous</a>
|
||||
<a class="up" href="Sequence.html" title="Sequence">Up</a>
|
||||
</div>
|
||||
<a class="post" href="Sequence.IO.html" title="Sequence.IO">Next</a>
|
||||
</div>
|
||||
<h1>Module <a href="type_Sequence.Infix.html">Sequence.Infix</a></h1>
|
||||
|
||||
<pre><span class="keyword">module</span> Infix: <code class="code">sig</code> <a href="Sequence.Infix.html">..</a> <code class="code">end</code></pre><hr width="100%">
|
||||
<pre><span id="VAL(--)"><span class="keyword">val</span> (--)</span> : <code class="type">int -> int -> int <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VAL(|>)"><span class="keyword">val</span> (|>)</span> : <code class="type">'a -> ('a -> 'b) -> 'b</code></pre><pre><span id="VAL(@@)"><span class="keyword">val</span> (@@)</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VAL(--)"><span class="keyword">val</span> (--)</span> : <code class="type">int -> int -> int <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><div class="info ">
|
||||
<code class="code">a -- b</code> is the range of integers from <code class="code">a</code> to <code class="code">b</code>, both included,
|
||||
in increasing order. It will therefore be empty if <code class="code">a > b</code>.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VAL(--^)"><span class="keyword">val</span> (--^)</span> : <code class="type">int -> int -> int <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><div class="info ">
|
||||
<code class="code">a --^ b</code> is the range of integers from <code class="code">b</code> to <code class="code">a</code>, both included,
|
||||
in decreasing order (starts from <code class="code">a</code>).
|
||||
It will therefore be empty if <code class="code">a < b</code>.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VAL(>>=)"><span class="keyword">val</span> (>>=)</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> ('a -> 'b <a href="Sequence.html#TYPEt">Sequence.t</a>) -> 'b <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><div class="info ">
|
||||
Monadic bind (infix version of <a href="Sequence.html#VALflat_map"><code class="code">Sequence.flat_map</code></a><br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VAL(>|=)"><span class="keyword">val</span> (>|=)</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> ('a -> 'b) -> 'b <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><div class="info ">
|
||||
Infix version of <a href="Sequence.html#VALmap"><code class="code">Sequence.map</code></a><br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VAL(<*>)"><span class="keyword">val</span> (<*>)</span> : <code class="type">('a -> 'b) <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'b <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><div class="info ">
|
||||
Applicative operator (product+application)<br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VAL(<+>)"><span class="keyword">val</span> (<+>)</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><div class="info ">
|
||||
Concatenation of sequences<br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
</body></html>
|
||||
|
|
@ -7,17 +7,20 @@
|
|||
<link rel="next" href="Sequence.Map.Make.html">
|
||||
<link rel="Up" href="Sequence.Map.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map.Adapt</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map.Adapt</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="Sequence.Map.html" title="Sequence.Map">Up</a>
|
||||
<a class="post" href="Sequence.Map.Make.html" title="Sequence.Map.Make">Next</a>
|
||||
</div>
|
||||
<h1>Functor <a href="type_Sequence.Map.Adapt.html">Sequence.Map.Adapt</a></h1>
|
||||
<pre><span class="keyword">module</span> Adapt: <div class="sig_block"><code class="code">functor (</code><code class="code">M</code><code class="code"> : </code><code class="type">Map.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = M.key and type 'a map = 'a M.t</code></div></pre><div class="info">
|
||||
|
||||
<pre><span class="keyword">module</span> Adapt: <div class="sig_block"><code class="code">functor (</code><code class="code">M</code><code class="code"> : </code><code class="type">Map.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = M.key and type 'a t = 'a M.t</code></div></pre><div class="info module top">
|
||||
Adapt a pre-existing Map module to make it sequence-aware<br>
|
||||
</div>
|
||||
<table border="0" cellpadding="3" width="100%">
|
||||
|
|
@ -35,7 +38,12 @@ Adapt a pre-existing Map module to make it sequence-aware<br>
|
|||
</tr>
|
||||
</table>
|
||||
<hr width="100%">
|
||||
<pre><span id="TYPEmap"><span class="keyword">type</span> <code class="type">+'a</code> map</span> </pre>
|
||||
|
||||
<pre><span class="keyword">include</span> Map.S</pre>
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> (key * 'a) <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">(key * 'a) <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.Map.S.html#TYPEmap">map</a></code></pre><pre><span id="VALkeys"><span class="keyword">val</span> keys</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> key <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VALvalues"><span class="keyword">val</span> values</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> (key * 'a) <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">(key * 'a) <a href="Sequence.html#TYPEsequence">Sequence.sequence</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre>
|
||||
<pre><span id="VALkeys"><span class="keyword">val</span> keys</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> key <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALvalues"><span class="keyword">val</span> values</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> (key * 'a) list</code></pre>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">(key * 'a) list -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
|
@ -7,17 +7,20 @@
|
|||
<link rel="previous" href="Sequence.Map.Adapt.html">
|
||||
<link rel="Up" href="Sequence.Map.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map.Make</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map.Make</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"><a class="pre" href="Sequence.Map.Adapt.html" title="Sequence.Map.Adapt">Previous</a>
|
||||
<a class="up" href="Sequence.Map.html" title="Sequence.Map">Up</a>
|
||||
</div>
|
||||
<h1>Functor <a href="type_Sequence.Map.Make.html">Sequence.Map.Make</a></h1>
|
||||
<pre><span class="keyword">module</span> Make: <div class="sig_block"><code class="code">functor (</code><code class="code">V</code><code class="code"> : </code><code class="type">Map.OrderedType</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = V.t</code></div></pre><div class="info">
|
||||
|
||||
<pre><span class="keyword">module</span> Make: <div class="sig_block"><code class="code">functor (</code><code class="code">V</code><code class="code"> : </code><code class="type">Map.OrderedType</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = V.t</code></div></pre><div class="info module top">
|
||||
Create an enriched Map module, with sequence-aware functions<br>
|
||||
</div>
|
||||
<table border="0" cellpadding="3" width="100%">
|
||||
|
|
@ -35,7 +38,12 @@ Create an enriched Map module, with sequence-aware functions<br>
|
|||
</tr>
|
||||
</table>
|
||||
<hr width="100%">
|
||||
<pre><span id="TYPEmap"><span class="keyword">type</span> <code class="type">+'a</code> map</span> </pre>
|
||||
|
||||
<pre><span class="keyword">include</span> Map.S</pre>
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> (key * 'a) <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">(key * 'a) <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.Map.S.html#TYPEmap">map</a></code></pre><pre><span id="VALkeys"><span class="keyword">val</span> keys</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> key <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VALvalues"><span class="keyword">val</span> values</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> (key * 'a) <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">(key * 'a) <a href="Sequence.html#TYPEsequence">Sequence.sequence</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre>
|
||||
<pre><span id="VALkeys"><span class="keyword">val</span> keys</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> key <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALvalues"><span class="keyword">val</span> values</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> (key * 'a) list</code></pre>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">(key * 'a) list -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
|
@ -6,17 +6,25 @@
|
|||
<link rel="Start" href="index.html">
|
||||
<link rel="Up" href="Sequence.Map.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map.S</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map.S</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="Sequence.Map.html" title="Sequence.Map">Up</a>
|
||||
</div>
|
||||
<h1>Module type <a href="type_Sequence.Map.S.html">Sequence.Map.S</a></h1>
|
||||
|
||||
<pre><span class="keyword">module type</span> S = <code class="code">sig</code> <a href="Sequence.Map.S.html">..</a> <code class="code">end</code></pre><hr width="100%">
|
||||
<pre><span id="TYPEmap"><span class="keyword">type</span> <code class="type">+'a</code> map</span> </pre>
|
||||
|
||||
<pre><span class="keyword">include</span> Map.S</pre>
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> (key * 'a) <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">(key * 'a) <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.Map.S.html#TYPEmap">map</a></code></pre><pre><span id="VALkeys"><span class="keyword">val</span> keys</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> key <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre><pre><span id="VALvalues"><span class="keyword">val</span> values</span> : <code class="type">'a <a href="Sequence.Map.S.html#TYPEmap">map</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> (key * 'a) <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">(key * 'a) <a href="Sequence.html#TYPEsequence">Sequence.sequence</a> -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre>
|
||||
<pre><span id="VALkeys"><span class="keyword">val</span> keys</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> key <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALvalues"><span class="keyword">val</span> values</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> 'a <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">Sequence.t</a> -> (key * 'a) list</code></pre>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">(key * 'a) list -> 'a <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
|
@ -5,24 +5,30 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link rel="previous" href="Sequence.Set.html">
|
||||
<link rel="next" href="Sequence.TypeClass.html">
|
||||
<link rel="next" href="Sequence.Infix.html">
|
||||
<link rel="Up" href="Sequence.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"><a class="pre" href="Sequence.Set.html" title="Sequence.Set">Previous</a>
|
||||
<a class="up" href="Sequence.html" title="Sequence">Up</a>
|
||||
<a class="post" href="Sequence.TypeClass.html" title="Sequence.TypeClass">Next</a>
|
||||
<a class="post" href="Sequence.Infix.html" title="Sequence.Infix">Next</a>
|
||||
</div>
|
||||
<h1>Module <a href="type_Sequence.Map.html">Sequence.Map</a></h1>
|
||||
|
||||
<pre><span class="keyword">module</span> Map: <code class="code">sig</code> <a href="Sequence.Map.html">..</a> <code class="code">end</code></pre><hr width="100%">
|
||||
<pre><span class="keyword">module type</span> <a href="Sequence.Map.S.html">S</a> = <code class="code">sig</code> <a href="Sequence.Map.S.html">..</a> <code class="code">end</code></pre><pre><span class="keyword">module</span> <a href="Sequence.Map.Adapt.html">Adapt</a>: <div class="sig_block"><code class="code">functor (</code><code class="code">M</code><code class="code"> : </code><code class="type">Map.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = M.key and type 'a map = 'a M.t</code></div></pre><div class="info">
|
||||
|
||||
<pre><span class="keyword">module type</span> <a href="Sequence.Map.S.html">S</a> = <code class="code">sig</code> <a href="Sequence.Map.S.html">..</a> <code class="code">end</code></pre>
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Map.Adapt.html">Adapt</a>: <div class="sig_block"><code class="code">functor (</code><code class="code">M</code><code class="code"> : </code><code class="type">Map.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = M.key and type 'a t = 'a M.t</code></div></pre><div class="info">
|
||||
Adapt a pre-existing Map module to make it sequence-aware
|
||||
</div>
|
||||
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Map.Make.html">Make</a>: <div class="sig_block"><code class="code">functor (</code><code class="code">V</code><code class="code"> : </code><code class="type">Map.OrderedType</code><code class="code">) -> </code><code class="type"><a href="Sequence.Map.S.html">S</a></code><code class="type"> with type key = V.t</code></div></pre><div class="info">
|
||||
Create an enriched Map module, with sequence-aware functions
|
||||
</div>
|
||||
|
|
|
|||
|
|
@ -7,17 +7,20 @@
|
|||
<link rel="next" href="Sequence.Set.Make.html">
|
||||
<link rel="Up" href="Sequence.Set.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set.Adapt</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set.Adapt</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="Sequence.Set.html" title="Sequence.Set">Up</a>
|
||||
<a class="post" href="Sequence.Set.Make.html" title="Sequence.Set.Make">Next</a>
|
||||
</div>
|
||||
<h1>Functor <a href="type_Sequence.Set.Adapt.html">Sequence.Set.Adapt</a></h1>
|
||||
<pre><span class="keyword">module</span> Adapt: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.elt and type set = X.t</code></div></pre><div class="info">
|
||||
|
||||
<pre><span class="keyword">module</span> Adapt: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.elt and type t = X.t</code></div></pre><div class="info module top">
|
||||
Create an enriched Set module from the given one<br>
|
||||
</div>
|
||||
<table border="0" cellpadding="3" width="100%">
|
||||
|
|
@ -35,7 +38,10 @@ Create an enriched Set module from the given one<br>
|
|||
</tr>
|
||||
</table>
|
||||
<hr width="100%">
|
||||
<pre><span id="TYPEset"><span class="keyword">type</span> <code class="type"></code>set</span> </pre>
|
||||
|
||||
<pre><span class="keyword">include</span> Set.S</pre>
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">elt <a href="Sequence.html#TYPEt">Sequence.t</a> -> <a href="Sequence.Set.S.html#TYPEset">set</a></code></pre><pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="Sequence.Set.S.html#TYPEset">set</a> -> elt <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">elt <a href="Sequence.html#TYPEsequence">Sequence.sequence</a> -> <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre>
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="Sequence.html#TYPEt">Sequence.t</a> -> elt <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type"><a href="Sequence.html#TYPEt">Sequence.t</a> -> elt list</code></pre>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">elt list -> <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
|
@ -7,17 +7,20 @@
|
|||
<link rel="previous" href="Sequence.Set.Adapt.html">
|
||||
<link rel="Up" href="Sequence.Set.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set.Make</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set.Make</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"><a class="pre" href="Sequence.Set.Adapt.html" title="Sequence.Set.Adapt">Previous</a>
|
||||
<a class="up" href="Sequence.Set.html" title="Sequence.Set">Up</a>
|
||||
</div>
|
||||
<h1>Functor <a href="type_Sequence.Set.Make.html">Sequence.Set.Make</a></h1>
|
||||
<pre><span class="keyword">module</span> Make: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.OrderedType</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.t</code></div></pre><div class="info">
|
||||
|
||||
<pre><span class="keyword">module</span> Make: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.OrderedType</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.t</code></div></pre><div class="info module top">
|
||||
Functor to build an extended Set module from an ordered type<br>
|
||||
</div>
|
||||
<table border="0" cellpadding="3" width="100%">
|
||||
|
|
@ -35,7 +38,10 @@ Functor to build an extended Set module from an ordered type<br>
|
|||
</tr>
|
||||
</table>
|
||||
<hr width="100%">
|
||||
<pre><span id="TYPEset"><span class="keyword">type</span> <code class="type"></code>set</span> </pre>
|
||||
|
||||
<pre><span class="keyword">include</span> Set.S</pre>
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">elt <a href="Sequence.html#TYPEt">Sequence.t</a> -> <a href="Sequence.Set.S.html#TYPEset">set</a></code></pre><pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="Sequence.Set.S.html#TYPEset">set</a> -> elt <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">elt <a href="Sequence.html#TYPEsequence">Sequence.sequence</a> -> <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre>
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="Sequence.html#TYPEt">Sequence.t</a> -> elt <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type"><a href="Sequence.html#TYPEt">Sequence.t</a> -> elt list</code></pre>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">elt list -> <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
|
@ -6,17 +6,23 @@
|
|||
<link rel="Start" href="index.html">
|
||||
<link rel="Up" href="Sequence.Set.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set.S</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set.S</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="Sequence.Set.html" title="Sequence.Set">Up</a>
|
||||
</div>
|
||||
<h1>Module type <a href="type_Sequence.Set.S.html">Sequence.Set.S</a></h1>
|
||||
|
||||
<pre><span class="keyword">module type</span> S = <code class="code">sig</code> <a href="Sequence.Set.S.html">..</a> <code class="code">end</code></pre><hr width="100%">
|
||||
<pre><span id="TYPEset"><span class="keyword">type</span> <code class="type"></code>set</span> </pre>
|
||||
|
||||
<pre><span class="keyword">include</span> Set.S</pre>
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">elt <a href="Sequence.html#TYPEt">Sequence.t</a> -> <a href="Sequence.Set.S.html#TYPEset">set</a></code></pre><pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="Sequence.Set.S.html#TYPEset">set</a> -> elt <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
||||
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">elt <a href="Sequence.html#TYPEsequence">Sequence.sequence</a> -> <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre>
|
||||
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="Sequence.html#TYPEt">Sequence.t</a> -> elt <a href="Sequence.html#TYPEsequence">Sequence.sequence</a></code></pre>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type"><a href="Sequence.html#TYPEt">Sequence.t</a> -> elt list</code></pre>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">elt list -> <a href="Sequence.html#TYPEt">Sequence.t</a></code></pre></body></html>
|
||||
|
|
@ -7,20 +7,26 @@
|
|||
<link rel="next" href="Sequence.Map.html">
|
||||
<link rel="Up" href="Sequence.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="Sequence.html" title="Sequence">Up</a>
|
||||
<a class="post" href="Sequence.Map.html" title="Sequence.Map">Next</a>
|
||||
</div>
|
||||
<h1>Module <a href="type_Sequence.Set.html">Sequence.Set</a></h1>
|
||||
|
||||
<pre><span class="keyword">module</span> Set: <code class="code">sig</code> <a href="Sequence.Set.html">..</a> <code class="code">end</code></pre><hr width="100%">
|
||||
<pre><span class="keyword">module type</span> <a href="Sequence.Set.S.html">S</a> = <code class="code">sig</code> <a href="Sequence.Set.S.html">..</a> <code class="code">end</code></pre><pre><span class="keyword">module</span> <a href="Sequence.Set.Adapt.html">Adapt</a>: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.elt and type set = X.t</code></div></pre><div class="info">
|
||||
|
||||
<pre><span class="keyword">module type</span> <a href="Sequence.Set.S.html">S</a> = <code class="code">sig</code> <a href="Sequence.Set.S.html">..</a> <code class="code">end</code></pre>
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Set.Adapt.html">Adapt</a>: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.S</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.elt and type t = X.t</code></div></pre><div class="info">
|
||||
Create an enriched Set module from the given one
|
||||
</div>
|
||||
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Set.Make.html">Make</a>: <div class="sig_block"><code class="code">functor (</code><code class="code">X</code><code class="code"> : </code><code class="type">Set.OrderedType</code><code class="code">) -> </code><code class="type"><a href="Sequence.Set.S.html">S</a></code><code class="type"> with type elt = X.t</code></div></pre><div class="info">
|
||||
Functor to build an extended Set module from an ordered type
|
||||
</div>
|
||||
|
|
|
|||
|
|
@ -4,280 +4,674 @@
|
|||
<link rel="stylesheet" href="style.css" type="text/css">
|
||||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link rel="next" href="SequenceLabels.html">
|
||||
<link rel="Up" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><link title="Build a sequence" rel="Section" href="#2_Buildasequence">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><link title="Build a sequence" rel="Section" href="#2_Buildasequence">
|
||||
<link title="Consume a sequence" rel="Section" href="#2_Consumeasequence">
|
||||
<link title="Transform a sequence" rel="Section" href="#2_Transformasequence">
|
||||
<link title="Caching" rel="Section" href="#2_Caching">
|
||||
<link title="Misc" rel="Section" href="#2_Misc">
|
||||
<link title="Binary sequences" rel="Section" href="#2_Binarysequences">
|
||||
<link title="Basic data structures converters" rel="Section" href="#2_Basicdatastructuresconverters">
|
||||
<link title="Functorial conversions between sets and sequences" rel="Section" href="#2_Functorialconversionsbetweensetsandsequences">
|
||||
<link title="Conversion between maps and sequences." rel="Section" href="#2_Conversionbetweenmapsandsequences">
|
||||
<link title="Infinite sequences of random values" rel="Section" href="#2_Infinitesequencesofrandomvalues">
|
||||
<link title="Type-classes" rel="Section" href="#2_Typeclasses">
|
||||
<link title="Sampling" rel="Section" href="#2_Sampling">
|
||||
<link title="Infix functions" rel="Section" href="#2_Infixfunctions">
|
||||
<link title="Pretty printing of sequences" rel="Section" href="#2_Prettyprintingofsequences">
|
||||
<link title="Basic IO" rel="Section" href="#2_BasicIO">
|
||||
<title>Sequence</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
</div>
|
||||
<a class="post" href="SequenceLabels.html" title="SequenceLabels">Next</a>
|
||||
</div>
|
||||
<h1>Module <a href="type_Sequence.html">Sequence</a></h1>
|
||||
<pre><span class="keyword">module</span> Sequence: <code class="code">sig</code> <a href="Sequence.html">..</a> <code class="code">end</code></pre><div class="info">
|
||||
<h1 id="1_Transientiteratorsthatabstractonafinitesequenceofelements">Transient iterators, that abstract on a finite sequence of elements.</h1><br>
|
||||
|
||||
<pre><span class="keyword">module</span> Sequence: <code class="code">sig</code> <a href="Sequence.html">..</a> <code class="code">end</code></pre><div class="info module top">
|
||||
<h1 id="1_SimpleandEfficientIterators">Simple and Efficient Iterators</h1><br>
|
||||
</div>
|
||||
<hr width="100%">
|
||||
<br>
|
||||
The iterators are designed to allow easy transfer (mappings) between data
|
||||
structures, without defining n^2 conversions between the n types. The
|
||||
structures, without defining <code class="code">n^2</code> conversions between the <code class="code">n</code> types. The
|
||||
implementation relies on the assumption that a sequence can be iterated
|
||||
on as many times as needed; this choice allows for high performance
|
||||
of many combinators. However, for transient iterators, the <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a>
|
||||
function is provided, storing elements of a transient iterator
|
||||
in memory; the iterator can then be used several times.
|
||||
in memory; the iterator can then be used several times (See further).
|
||||
<p>
|
||||
|
||||
Note that some combinators also return sequences (e.g. <a href="Sequence.html#VALgroup"><code class="code">Sequence.group</code></a>). The
|
||||
Note that some combinators also return sequences (e.g. <code class="code">group</code>). The
|
||||
transformation is computed on the fly every time one iterates over
|
||||
the resulting sequence. If a transformation performs heavy computation,
|
||||
<a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a> can also be used as intermediate storage.<br>
|
||||
<a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a> can also be used as intermediate storage.
|
||||
<p>
|
||||
|
||||
Most functions are <b>lazy</b>, i.e. they do not actually use their arguments
|
||||
until their result is iterated on. For instance, if one calls <a href="Sequence.html#VALmap"><code class="code">Sequence.map</code></a>
|
||||
on a sequence, one gets a new sequence, but nothing else happens until
|
||||
this new sequence is used (by folding or iterating on it).
|
||||
<p>
|
||||
|
||||
If a sequence is built from an iteration function that is <b>repeatable</b>
|
||||
(i.e. calling it several times always iterates on the same set of
|
||||
elements, for instance List.iter or Map.iter), then
|
||||
the resulting <a href="Sequence.html#TYPEt"><code class="code">Sequence.t</code></a> object is also repeatable. For <b>one-time iter functions</b>
|
||||
such as iteration on a file descriptor or a <code class="code">Stream</code>,
|
||||
the <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a> function can be used to iterate and store elements in
|
||||
a memory structure; the result is a sequence that iterates on the elements
|
||||
of this memory structure, cheaply and repeatably.<br>
|
||||
|
||||
<pre><span id="TYPEt"><span class="keyword">type</span> <code class="type">'a</code> t</span> = <code class="type">('a -> unit) -> unit</code> </pre>
|
||||
<div class="info">
|
||||
Sequence abstract iterator type, representing a finite sequence of
|
||||
values of type <code class="code">'a</code>.<br>
|
||||
<div class="info ">
|
||||
A sequence of values of type <code class="code">'a</code>. If you give it a function <code class="code">'a -> unit</code>
|
||||
it will be applied to every element of the sequence successively.<br>
|
||||
</div>
|
||||
|
||||
|
||||
<pre><span id="TYPEsequence"><span class="keyword">type</span> <code class="type">'a</code> sequence</span> = <code class="type">'a <a href="Sequence.html#TYPEt">t</a></code> </pre>
|
||||
|
||||
|
||||
<pre><span id="TYPEt2"><span class="keyword">type</span> <code class="type">('a, 'b)</code> t2</span> = <code class="type">('a -> 'b -> unit) -> unit</code> </pre>
|
||||
<div class="info">
|
||||
<div class="info ">
|
||||
Sequence of pairs of values of type <code class="code">'a</code> and <code class="code">'b</code>.<br>
|
||||
</div>
|
||||
|
||||
<br>
|
||||
<h2 id="2_Buildasequence">Build a sequence</h2><br>
|
||||
<pre><span id="VALfrom_iter"><span class="keyword">val</span> from_iter</span> : <code class="type">(('a -> unit) -> unit) -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALfrom_iter"><span class="keyword">val</span> from_iter</span> : <code class="type">(('a -> unit) -> unit) -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Build a sequence from a iter function<br>
|
||||
</div>
|
||||
<pre><span id="VALfrom_fun"><span class="keyword">val</span> from_fun</span> : <code class="type">(unit -> 'a option) -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALfrom_fun"><span class="keyword">val</span> from_fun</span> : <code class="type">(unit -> 'a option) -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Call the function repeatedly until it returns None. This
|
||||
sequence is transient, use <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a> if needed!<br>
|
||||
sequence is transient, use <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a> if needed!<br>
|
||||
</div>
|
||||
<pre><span id="VALempty"><span class="keyword">val</span> empty</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Empty sequence<br>
|
||||
|
||||
<pre><span id="VALempty"><span class="keyword">val</span> empty</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Empty sequence. It contains no element.<br>
|
||||
</div>
|
||||
<pre><span id="VALsingleton"><span class="keyword">val</span> singleton</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Singleton sequence<br>
|
||||
|
||||
<pre><span id="VALsingleton"><span class="keyword">val</span> singleton</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Singleton sequence, with exactly one element.<br>
|
||||
</div>
|
||||
<pre><span id="VALrepeat"><span class="keyword">val</span> repeat</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Infinite sequence of the same element<br>
|
||||
|
||||
<pre><span id="VALdoubleton"><span class="keyword">val</span> doubleton</span> : <code class="type">'a -> 'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence with exactly two elements<br>
|
||||
</div>
|
||||
<pre><span id="VALiterate"><span class="keyword">val</span> iterate</span> : <code class="type">('a -> 'a) -> 'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
<code class="code">iterate f x</code> is the infinite sequence (x, f(x), f(f(x)), ...)<br>
|
||||
|
||||
<pre><span id="VALcons"><span class="keyword">val</span> cons</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">cons x l</code> yields <code class="code">x</code>, then yields from <code class="code">l</code>.
|
||||
Same as <code class="code">append (singleton x) l</code><br>
|
||||
</div>
|
||||
<pre><span id="VALforever"><span class="keyword">val</span> forever</span> : <code class="type">(unit -> 'b) -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Sequence that calls the given function to produce elements<br>
|
||||
|
||||
<pre><span id="VALsnoc"><span class="keyword">val</span> snoc</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Same as <a href="Sequence.html#VALcons"><code class="code">Sequence.cons</code></a> but yields the element after iterating on <code class="code">l</code><br>
|
||||
</div>
|
||||
<pre><span id="VALcycle"><span class="keyword">val</span> cycle</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Cycle forever through the given sequence.<br>
|
||||
|
||||
<pre><span id="VALreturn"><span class="keyword">val</span> return</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Synonym to <a href="Sequence.html#VALsingleton"><code class="code">Sequence.singleton</code></a><br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALpure"><span class="keyword">val</span> pure</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Synonym to <a href="Sequence.html#VALsingleton"><code class="code">Sequence.singleton</code></a><br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALrepeat"><span class="keyword">val</span> repeat</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Infinite sequence of the same element. You may want to look
|
||||
at <a href="Sequence.html#VALtake"><code class="code">Sequence.take</code></a> and the likes if you iterate on it.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALiterate"><span class="keyword">val</span> iterate</span> : <code class="type">('a -> 'a) -> 'a -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">iterate f x</code> is the infinite sequence <code class="code">x, f(x), f(f(x)), ...</code><br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALforever"><span class="keyword">val</span> forever</span> : <code class="type">(unit -> 'b) -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence that calls the given function to produce elements.
|
||||
The sequence may be transient (depending on the function), and definitely
|
||||
is infinite. You may want to use <a href="Sequence.html#VALtake"><code class="code">Sequence.take</code></a> and <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a>.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALcycle"><span class="keyword">val</span> cycle</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Cycle forever through the given sequence. Assume the given sequence can
|
||||
be traversed any amount of times (not transient). This yields an
|
||||
infinite sequence, you should use something like <a href="Sequence.html#VALtake"><code class="code">Sequence.take</code></a> not to loop
|
||||
forever.<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Consumeasequence">Consume a sequence</h2><br>
|
||||
<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <code class="type">('a -> unit) -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
Consume the sequence, passing all its arguments to the function<br>
|
||||
|
||||
<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <code class="type">('a -> unit) -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Consume the sequence, passing all its arguments to the function.
|
||||
Basically <code class="code">iter f seq</code> is just <code class="code">seq f</code>.<br>
|
||||
</div>
|
||||
<pre><span id="VALiteri"><span class="keyword">val</span> iteri</span> : <code class="type">(int -> 'a -> unit) -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALiteri"><span class="keyword">val</span> iteri</span> : <code class="type">(int -> 'a -> unit) -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Iterate on elements and their index in the sequence<br>
|
||||
</div>
|
||||
<pre><span id="VALfold"><span class="keyword">val</span> fold</span> : <code class="type">('b -> 'a -> 'b) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALfold"><span class="keyword">val</span> fold</span> : <code class="type">('a -> 'b -> 'a) -> 'a -> 'b <a href="Sequence.html#TYPEt">t</a> -> 'a</code></pre><div class="info ">
|
||||
Fold over elements of the sequence, consuming it<br>
|
||||
</div>
|
||||
<pre><span id="VALfoldi"><span class="keyword">val</span> foldi</span> : <code class="type">('b -> int -> 'a -> 'b) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALfoldi"><span class="keyword">val</span> foldi</span> : <code class="type">('a -> int -> 'b -> 'a) -> 'a -> 'b <a href="Sequence.html#TYPEt">t</a> -> 'a</code></pre><div class="info ">
|
||||
Fold over elements of the sequence and their index, consuming it<br>
|
||||
</div>
|
||||
<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">('a -> 'b) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">('a -> 'b) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Map objects of the sequence into other elements, lazily<br>
|
||||
</div>
|
||||
<pre><span id="VALmapi"><span class="keyword">val</span> mapi</span> : <code class="type">(int -> 'a -> 'b) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALmapi"><span class="keyword">val</span> mapi</span> : <code class="type">(int -> 'a -> 'b) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Map objects, along with their index in the sequence<br>
|
||||
</div>
|
||||
<pre><span id="VALfor_all"><span class="keyword">val</span> for_all</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALmap_by_2"><span class="keyword">val</span> map_by_2</span> : <code class="type">('a -> 'a -> 'a) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Map objects two by two. lazily.
|
||||
The last element is kept in the sequence if the count is odd.<br>
|
||||
<b>Since</b> 0.7<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALfor_all"><span class="keyword">val</span> for_all</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info ">
|
||||
Do all elements satisfy the predicate?<br>
|
||||
</div>
|
||||
<pre><span id="VALexists"><span class="keyword">val</span> exists</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALexists"><span class="keyword">val</span> exists</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info ">
|
||||
Exists there some element satisfying the predicate?<br>
|
||||
</div>
|
||||
<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> int</code></pre><div class="info">
|
||||
How long is the sequence?<br>
|
||||
|
||||
<pre><span id="VALmem"><span class="keyword">val</span> mem</span> : <code class="type">?eq:('a -> 'a -> bool) -> 'a -> 'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info ">
|
||||
Is the value a member of the sequence?<br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
<pre><span id="VALis_empty"><span class="keyword">val</span> is_empty</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info">
|
||||
Is the sequence empty?<br>
|
||||
<div class="param_info"><code class="code">eq</code> : the equality predicate to use (default <code class="code">(=)</code>)</div>
|
||||
|
||||
<pre><span id="VALfind"><span class="keyword">val</span> find</span> : <code class="type">('a -> 'b option) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b option</code></pre><div class="info ">
|
||||
Find the first element on which the function doesn't return <code class="code">None</code><br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> int</code></pre><div class="info ">
|
||||
How long is the sequence? Forces the sequence.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALis_empty"><span class="keyword">val</span> is_empty</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> bool</code></pre><div class="info ">
|
||||
Is the sequence empty? Forces the sequence.<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Transformasequence">Transform a sequence</h2><br>
|
||||
<pre><span id="VALfilter"><span class="keyword">val</span> filter</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALfilter"><span class="keyword">val</span> filter</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Filter on elements of the sequence<br>
|
||||
</div>
|
||||
<pre><span id="VALappend"><span class="keyword">val</span> append</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Append two sequences<br>
|
||||
|
||||
<pre><span id="VALappend"><span class="keyword">val</span> append</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Append two sequences. Iterating on the result is like iterating
|
||||
on the first, then on the second.<br>
|
||||
</div>
|
||||
<pre><span id="VALconcat"><span class="keyword">val</span> concat</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Concatenate a sequence of sequences into one sequence<br>
|
||||
|
||||
<pre><span id="VALconcat"><span class="keyword">val</span> concat</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Concatenate a sequence of sequences into one sequence.<br>
|
||||
</div>
|
||||
<pre><span id="VALflatten"><span class="keyword">val</span> flatten</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALflatten"><span class="keyword">val</span> flatten</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Alias for <a href="Sequence.html#VALconcat"><code class="code">Sequence.concat</code></a><br>
|
||||
</div>
|
||||
<pre><span id="VALflatMap"><span class="keyword">val</span> flatMap</span> : <code class="type">('a -> 'b <a href="Sequence.html#TYPEt">t</a>) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Monadic bind. It applies the function to every element of the
|
||||
initial sequence, and calls <code class="code">concat</code>.<br>
|
||||
|
||||
<pre><span id="VALflat_map"><span class="keyword">val</span> flat_map</span> : <code class="type">('a -> 'b <a href="Sequence.html#TYPEt">t</a>) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Monadic bind. Intuitively, it applies the function to every
|
||||
element of the initial sequence, and calls <a href="Sequence.html#VALconcat"><code class="code">Sequence.concat</code></a>.
|
||||
Formerly <code class="code">flatMap</code><br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
<pre><span id="VALintersperse"><span class="keyword">val</span> intersperse</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Insert the second element between every element of the sequence<br>
|
||||
|
||||
<pre><span id="VALflat_map_l"><span class="keyword">val</span> flat_map_l</span> : <code class="type">('a -> 'b list) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Convenience function combining <a href="Sequence.html#VALflat_map"><code class="code">Sequence.flat_map</code></a> and <a href="Sequence.html#VALof_list"><code class="code">Sequence.of_list</code></a><br>
|
||||
<b>Since</b> NEXT_RELEASE<br>
|
||||
</div>
|
||||
<pre><span id="VALpersistent"><span class="keyword">val</span> persistent</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Iterate on the sequence, storing elements in a data structure.
|
||||
The resulting sequence can be iterated on as many times as needed.<br>
|
||||
|
||||
<pre><span id="VALfilter_map"><span class="keyword">val</span> filter_map</span> : <code class="type">('a -> 'b option) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Map and only keep non-<code class="code">None</code> elements
|
||||
Formerly <code class="code">fmap</code><br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
<pre><span id="VALsort"><span class="keyword">val</span> sort</span> : <code class="type">?cmp:('a -> 'a -> int) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.<br>
|
||||
|
||||
<pre><span id="VALintersperse"><span class="keyword">val</span> intersperse</span> : <code class="type">'a -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Insert the single element between every element of the sequence<br>
|
||||
</div>
|
||||
<pre><span id="VALsort_uniq"><span class="keyword">val</span> sort_uniq</span> : <code class="type">?cmp:('a -> 'a -> int) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
<br>
|
||||
<h2 id="2_Caching">Caching</h2><br>
|
||||
|
||||
<pre><span id="VALpersistent"><span class="keyword">val</span> persistent</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterate on the sequence, storing elements in an efficient internal structure..
|
||||
The resulting sequence can be iterated on as many times as needed.
|
||||
<b>Note</b>: calling persistent on an already persistent sequence
|
||||
will still make a new copy of the sequence!<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALpersistent_lazy"><span class="keyword">val</span> persistent_lazy</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Lazy version of <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a>. When calling <code class="code">persistent_lazy s</code>,
|
||||
a new sequence <code class="code">s'</code> is immediately returned (without actually consuming
|
||||
<code class="code">s</code>) in constant time; the first time <code class="code">s'</code> is iterated on,
|
||||
it also consumes <code class="code">s</code> and caches its content into a inner data
|
||||
structure that will back <code class="code">s'</code> for future iterations.
|
||||
<p>
|
||||
|
||||
<b>warning</b>: on the first traversal of <code class="code">s'</code>, if the traversal
|
||||
is interrupted prematurely (<a href="Sequence.html#VALtake"><code class="code">Sequence.take</code></a>, etc.) then <code class="code">s'</code> will not be
|
||||
memorized, and the next call to <code class="code">s'</code> will traverse <code class="code">s</code> again.<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Misc">Misc</h2><br>
|
||||
|
||||
<pre><span id="VALsort"><span class="keyword">val</span> sort</span> : <code class="type">?cmp:('a -> 'a -> int) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
|
||||
It iterates on elements of the argument sequence immediately,
|
||||
before it sorts them.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALsort_uniq"><span class="keyword">val</span> sort_uniq</span> : <code class="type">?cmp:('a -> 'a -> int) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sort the sequence and remove duplicates. Eager, same as <code class="code">sort</code><br>
|
||||
</div>
|
||||
<pre><span id="VALgroup"><span class="keyword">val</span> group</span> : <code class="type">?eq:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a list <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Group equal consecutive elements.<br>
|
||||
|
||||
<pre><span id="VALgroup_succ_by"><span class="keyword">val</span> group_succ_by</span> : <code class="type">?eq:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a list <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Group equal consecutive elements.
|
||||
Formerly synonym to <code class="code">group</code>.<br>
|
||||
<b>Since</b> 0.6<br>
|
||||
</div>
|
||||
<pre><span id="VALuniq"><span class="keyword">val</span> uniq</span> : <code class="type">?eq:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALgroup_by"><span class="keyword">val</span> group_by</span> : <code class="type">?hash:('a -> int) -><br> ?eq:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a list <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Group equal elements, disregarding their order of appearance.
|
||||
The result sequence is traversable as many times as required.<br>
|
||||
<b>Since</b> 0.6<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALuniq"><span class="keyword">val</span> uniq</span> : <code class="type">?eq:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Remove consecutive duplicate elements. Basically this is
|
||||
like <code class="code">fun seq -> map List.hd (group seq)</code>.<br>
|
||||
like <code class="code">fun seq -> map List.hd (group seq)</code>.<br>
|
||||
</div>
|
||||
<pre><span id="VALproduct"><span class="keyword">val</span> product</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a> -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Cartesian product of the sequences. The first one is transformed
|
||||
by calling <code class="code">persistent</code> on it, so that it can be traversed
|
||||
several times (outer loop of the product)<br>
|
||||
|
||||
<pre><span id="VALproduct"><span class="keyword">val</span> product</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a> -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Cartesian product of the sequences. When calling <code class="code">product a b</code>,
|
||||
the caller <b>MUST</b> ensure that <code class="code">b</code> can be traversed as many times
|
||||
as required (several times), possibly by calling <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a> on it
|
||||
beforehand.<br>
|
||||
</div>
|
||||
<pre><span id="VALjoin"><span class="keyword">val</span> join</span> : <code class="type">join_row:('a -> 'b -> 'c option) -><br> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a> -> 'c <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALproduct2"><span class="keyword">val</span> product2</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a> -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info ">
|
||||
Binary version of <a href="Sequence.html#VALproduct"><code class="code">Sequence.product</code></a>. Same requirements.<br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALjoin"><span class="keyword">val</span> join</span> : <code class="type">join_row:('a -> 'b -> 'c option) -><br> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a> -> 'c <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">join ~join_row a b</code> combines every element of <code class="code">a</code> with every
|
||||
element of <code class="code">b</code> using <code class="code">join_row</code>. If <code class="code">join_row</code> returns None, then
|
||||
the two elements do not combine. Assume that <code class="code">b</code> allows for multiple
|
||||
iterations.<br>
|
||||
element of <code class="code">b</code> using <code class="code">join_row</code>. If <code class="code">join_row</code> returns None, then
|
||||
the two elements do not combine. Assume that <code class="code">b</code> allows for multiple
|
||||
iterations.<br>
|
||||
</div>
|
||||
<pre><span id="VALunfoldr"><span class="keyword">val</span> unfoldr</span> : <code class="type">('b -> ('a * 'b) option) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALunfoldr"><span class="keyword">val</span> unfoldr</span> : <code class="type">('b -> ('a * 'b) option) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">unfoldr f b</code> will apply <code class="code">f</code> to <code class="code">b</code>. If it
|
||||
yields <code class="code">Some (x,b')</code> then <code class="code">x</code> is returned
|
||||
and unfoldr recurses with <code class="code">b'</code>.<br>
|
||||
yields <code class="code">Some (x,b')</code> then <code class="code">x</code> is returned
|
||||
and unfoldr recurses with <code class="code">b'</code>.<br>
|
||||
</div>
|
||||
<pre><span id="VALscan"><span class="keyword">val</span> scan</span> : <code class="type">('b -> 'a -> 'b) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALscan"><span class="keyword">val</span> scan</span> : <code class="type">('b -> 'a -> 'b) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence of intermediate results<br>
|
||||
</div>
|
||||
<pre><span id="VALmax"><span class="keyword">val</span> max</span> : <code class="type">?lt:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a -> 'a</code></pre><div class="info">
|
||||
Max element of the sequence, using the given comparison
|
||||
function. A default element has to be provided.<br>
|
||||
|
||||
<pre><span id="VALmax"><span class="keyword">val</span> max</span> : <code class="type">?lt:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a option</code></pre><div class="info ">
|
||||
Max element of the sequence, using the given comparison function.<br>
|
||||
<b>Returns</b> None if the sequence is empty, Some <code class="code">m</code> where <code class="code">m</code> is the maximal
|
||||
element otherwise<br>
|
||||
</div>
|
||||
<pre><span id="VALmin"><span class="keyword">val</span> min</span> : <code class="type">?lt:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a -> 'a</code></pre><div class="info">
|
||||
Min element of the sequence, using the given comparison function<br>
|
||||
|
||||
<pre><span id="VALmin"><span class="keyword">val</span> min</span> : <code class="type">?lt:('a -> 'a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a option</code></pre><div class="info ">
|
||||
Min element of the sequence, using the given comparison function.
|
||||
see <a href="Sequence.html#VALmax"><code class="code">Sequence.max</code></a> for more details.<br>
|
||||
</div>
|
||||
<pre><span id="VALtake"><span class="keyword">val</span> take</span> : <code class="type">int -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Take at most <code class="code">n</code> elements from the sequence<br>
|
||||
|
||||
<pre><span id="VALhead"><span class="keyword">val</span> head</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a option</code></pre><div class="info ">
|
||||
First element, if any, otherwise <code class="code">None</code><br>
|
||||
<b>Since</b> 0.5.1<br>
|
||||
</div>
|
||||
<pre><span id="VALdrop"><span class="keyword">val</span> drop</span> : <code class="type">int -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Drop the <code class="code">n</code> first elements of the sequence<br>
|
||||
|
||||
<pre><span id="VALhead_exn"><span class="keyword">val</span> head_exn</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a</code></pre><div class="info ">
|
||||
First element, if any, fails<br>
|
||||
<b>Since</b> 0.5.1<br>
|
||||
<b>Raises</b> <code>Invalid_argument</code> if the sequence is empty<br>
|
||||
</div>
|
||||
<pre><span id="VALrev"><span class="keyword">val</span> rev</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Reverse the sequence. O(n) memory and time.<br>
|
||||
|
||||
<pre><span id="VALtake"><span class="keyword">val</span> take</span> : <code class="type">int -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Take at most <code class="code">n</code> elements from the sequence. Works on infinite
|
||||
sequences.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALtake_while"><span class="keyword">val</span> take_while</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Take elements while they satisfy the predicate, then stops iterating.
|
||||
Will work on an infinite sequence <code class="code">s</code> if the predicate is false for at
|
||||
least one element of <code class="code">s</code>.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALfold_while"><span class="keyword">val</span> fold_while</span> : <code class="type">('a -> 'b -> 'a * [ `Continue | `Stop ]) -> 'a -> 'b <a href="Sequence.html#TYPEt">t</a> -> 'a</code></pre><div class="info ">
|
||||
Folds over elements of the sequence, stopping early if the accumulator
|
||||
returns <code class="code">('a, `Stop)</code><br>
|
||||
<b>Since</b> 0.5.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALdrop"><span class="keyword">val</span> drop</span> : <code class="type">int -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Drop the <code class="code">n</code> first elements of the sequence. Lazy.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALdrop_while"><span class="keyword">val</span> drop_while</span> : <code class="type">('a -> bool) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Predicate version of <a href="Sequence.html#VALdrop"><code class="code">Sequence.drop</code></a><br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALrev"><span class="keyword">val</span> rev</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Reverse the sequence. O(n) memory and time, needs the
|
||||
sequence to be finite. The result is persistent and does
|
||||
not depend on the input being repeatable.<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Binarysequences">Binary sequences</h2><br>
|
||||
<pre><span id="VALempty2"><span class="keyword">val</span> empty2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre><pre><span id="VALis_empty2"><span class="keyword">val</span> is_empty2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> bool</code></pre><pre><span id="VALlength2"><span class="keyword">val</span> length2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> int</code></pre><pre><span id="VALzip"><span class="keyword">val</span> zip</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALunzip"><span class="keyword">val</span> unzip</span> : <code class="type">('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre><pre><span id="VALzip_i"><span class="keyword">val</span> zip_i</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> (int, 'a) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALempty2"><span class="keyword">val</span> empty2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre>
|
||||
<pre><span id="VALis_empty2"><span class="keyword">val</span> is_empty2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> bool</code></pre>
|
||||
<pre><span id="VALlength2"><span class="keyword">val</span> length2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> int</code></pre>
|
||||
<pre><span id="VALzip"><span class="keyword">val</span> zip</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALunzip"><span class="keyword">val</span> unzip</span> : <code class="type">('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre>
|
||||
<pre><span id="VALzip_i"><span class="keyword">val</span> zip_i</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> (int, 'a) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info ">
|
||||
Zip elements of the sequence with their index in the sequence<br>
|
||||
</div>
|
||||
<pre><span id="VALfold2"><span class="keyword">val</span> fold2</span> : <code class="type">('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> 'c</code></pre><pre><span id="VALiter2"><span class="keyword">val</span> iter2</span> : <code class="type">('a -> 'b -> unit) -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> unit</code></pre><pre><span id="VALmap2"><span class="keyword">val</span> map2</span> : <code class="type">('a -> 'b -> 'c) -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> 'c <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALmap2_2"><span class="keyword">val</span> map2_2</span> : <code class="type">('a -> 'b -> 'c) -><br> ('a -> 'b -> 'd) -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> ('c, 'd) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALfold2"><span class="keyword">val</span> fold2</span> : <code class="type">('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> 'c</code></pre>
|
||||
<pre><span id="VALiter2"><span class="keyword">val</span> iter2</span> : <code class="type">('a -> 'b -> unit) -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> unit</code></pre>
|
||||
<pre><span id="VALmap2"><span class="keyword">val</span> map2</span> : <code class="type">('a -> 'b -> 'c) -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> 'c <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALmap2_2"><span class="keyword">val</span> map2_2</span> : <code class="type">('a -> 'b -> 'c) -><br> ('a -> 'b -> 'd) -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> ('c, 'd) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info ">
|
||||
<code class="code">map2_2 f g seq2</code> maps each <code class="code">x, y</code> of seq2 into <code class="code">f x y, g x y</code><br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Basicdatastructuresconverters">Basic data structures converters</h2><br>
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a list</code></pre><pre><span id="VALto_rev_list"><span class="keyword">val</span> to_rev_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a list</code></pre><div class="info">
|
||||
Get the list of the reversed sequence (more efficient)<br>
|
||||
|
||||
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a list</code></pre><div class="info ">
|
||||
Convert the sequence into a list. Preserves order of elements.
|
||||
This function is tail-recursive, but consumes 2*n memory.
|
||||
If order doesn't matter to you, consider <a href="Sequence.html#VALto_rev_list"><code class="code">Sequence.to_rev_list</code></a>.<br>
|
||||
</div>
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">'a list -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALto_array"><span class="keyword">val</span> to_array</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a array</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_rev_list"><span class="keyword">val</span> to_rev_list</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a list</code></pre><div class="info ">
|
||||
Get the list of the reversed sequence (more efficient than <a href="Sequence.html#VALto_list"><code class="code">Sequence.to_list</code></a>)<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">'a list -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALon_list"><span class="keyword">val</span> on_list</span> : <code class="type">('a <a href="Sequence.html#TYPEt">t</a> -> 'b <a href="Sequence.html#TYPEt">t</a>) -> 'a list -> 'b list</code></pre><div class="info ">
|
||||
<code class="code">on_list f l</code> is equivalent to <code class="code">to_list @@ f @@ of_list l</code>.<br>
|
||||
<b>Since</b> 0.5.2<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALto_opt"><span class="keyword">val</span> to_opt</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a option</code></pre><div class="info ">
|
||||
Alias to <a href="Sequence.html#VALhead"><code class="code">Sequence.head</code></a><br>
|
||||
<b>Since</b> 0.5.1<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALto_array"><span class="keyword">val</span> to_array</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a array</code></pre><div class="info ">
|
||||
Convert to an array. Currently not very efficient because
|
||||
and intermediate list is used.<br>
|
||||
an intermediate list is used.<br>
|
||||
</div>
|
||||
<pre><span id="VALof_array"><span class="keyword">val</span> of_array</span> : <code class="type">'a array -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALof_array_i"><span class="keyword">val</span> of_array_i</span> : <code class="type">'a array -> (int * 'a) <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_array"><span class="keyword">val</span> of_array</span> : <code class="type">'a array -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALof_array_i"><span class="keyword">val</span> of_array_i</span> : <code class="type">'a array -> (int * 'a) <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Elements of the array, with their index<br>
|
||||
</div>
|
||||
<pre><span id="VALof_array2"><span class="keyword">val</span> of_array2</span> : <code class="type">'a array -> (int, 'a) <a href="Sequence.html#TYPEt2">t2</a></code></pre><pre><span id="VALarray_slice"><span class="keyword">val</span> array_slice</span> : <code class="type">'a array -> int -> int -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_array2"><span class="keyword">val</span> of_array2</span> : <code class="type">'a array -> (int, 'a) <a href="Sequence.html#TYPEt2">t2</a></code></pre>
|
||||
<pre><span id="VALarray_slice"><span class="keyword">val</span> array_slice</span> : <code class="type">'a array -> int -> int -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">array_slice a i j</code> Sequence of elements whose indexes range
|
||||
from <code class="code">i</code> to <code class="code">j</code><br>
|
||||
from <code class="code">i</code> to <code class="code">j</code><br>
|
||||
</div>
|
||||
<pre><span id="VALof_stream"><span class="keyword">val</span> of_stream</span> : <code class="type">'a Stream.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_opt"><span class="keyword">val</span> of_opt</span> : <code class="type">'a option -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterate on 0 or 1 values.<br>
|
||||
<b>Since</b> 0.5.1<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALof_stream"><span class="keyword">val</span> of_stream</span> : <code class="type">'a Stream.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence of elements of a stream (usable only once)<br>
|
||||
</div>
|
||||
<pre><span id="VALto_stream"><span class="keyword">val</span> to_stream</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a Stream.t</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_stream"><span class="keyword">val</span> to_stream</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a Stream.t</code></pre><div class="info ">
|
||||
Convert to a stream. linear in memory and time (a copy is made in memory)<br>
|
||||
</div>
|
||||
<pre><span id="VALto_stack"><span class="keyword">val</span> to_stack</span> : <code class="type">'a Stack.t -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_stack"><span class="keyword">val</span> to_stack</span> : <code class="type">'a Stack.t -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Push elements of the sequence on the stack<br>
|
||||
</div>
|
||||
<pre><span id="VALof_stack"><span class="keyword">val</span> of_stack</span> : <code class="type">'a Stack.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_stack"><span class="keyword">val</span> of_stack</span> : <code class="type">'a Stack.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence of elements of the stack (same order as <code class="code">Stack.iter</code>)<br>
|
||||
</div>
|
||||
<pre><span id="VALto_queue"><span class="keyword">val</span> to_queue</span> : <code class="type">'a Queue.t -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_queue"><span class="keyword">val</span> to_queue</span> : <code class="type">'a Queue.t -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Push elements of the sequence into the queue<br>
|
||||
</div>
|
||||
<pre><span id="VALof_queue"><span class="keyword">val</span> of_queue</span> : <code class="type">'a Queue.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_queue"><span class="keyword">val</span> of_queue</span> : <code class="type">'a Queue.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence of elements contained in the queue, FIFO order<br>
|
||||
</div>
|
||||
<pre><span id="VALhashtbl_add"><span class="keyword">val</span> hashtbl_add</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALhashtbl_add"><span class="keyword">val</span> hashtbl_add</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Add elements of the sequence to the hashtable, with
|
||||
Hashtbl.add<br>
|
||||
Hashtbl.add<br>
|
||||
</div>
|
||||
<pre><span id="VALhashtbl_replace"><span class="keyword">val</span> hashtbl_replace</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALhashtbl_replace"><span class="keyword">val</span> hashtbl_replace</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Add elements of the sequence to the hashtable, with
|
||||
Hashtbl.replace (erases conflicting bindings)<br>
|
||||
Hashtbl.replace (erases conflicting bindings)<br>
|
||||
</div>
|
||||
<pre><span id="VALto_hashtbl"><span class="keyword">val</span> to_hashtbl</span> : <code class="type">('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> ('a, 'b) Hashtbl.t</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_hashtbl"><span class="keyword">val</span> to_hashtbl</span> : <code class="type">('a * 'b) <a href="Sequence.html#TYPEt">t</a> -> ('a, 'b) Hashtbl.t</code></pre><div class="info ">
|
||||
Build a hashtable from a sequence of key/value pairs<br>
|
||||
</div>
|
||||
<pre><span id="VALto_hashtbl2"><span class="keyword">val</span> to_hashtbl2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> ('a, 'b) Hashtbl.t</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_hashtbl2"><span class="keyword">val</span> to_hashtbl2</span> : <code class="type">('a, 'b) <a href="Sequence.html#TYPEt2">t2</a> -> ('a, 'b) Hashtbl.t</code></pre><div class="info ">
|
||||
Build a hashtable from a sequence of key/value pairs<br>
|
||||
</div>
|
||||
<pre><span id="VALof_hashtbl"><span class="keyword">val</span> of_hashtbl</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_hashtbl"><span class="keyword">val</span> of_hashtbl</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence of key/value pairs from the hashtable<br>
|
||||
</div>
|
||||
<pre><span id="VALof_hashtbl2"><span class="keyword">val</span> of_hashtbl2</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALof_hashtbl2"><span class="keyword">val</span> of_hashtbl2</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a, 'b) <a href="Sequence.html#TYPEt2">t2</a></code></pre><div class="info ">
|
||||
Sequence of key/value pairs from the hashtable<br>
|
||||
</div>
|
||||
<pre><span id="VALhashtbl_keys"><span class="keyword">val</span> hashtbl_keys</span> : <code class="type">('a, 'b) Hashtbl.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALhashtbl_values"><span class="keyword">val</span> hashtbl_values</span> : <code class="type">('a, 'b) Hashtbl.t -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALof_str"><span class="keyword">val</span> of_str</span> : <code class="type">string -> char <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALto_str"><span class="keyword">val</span> to_str</span> : <code class="type">char <a href="Sequence.html#TYPEt">t</a> -> string</code></pre><pre><span id="VALof_in_channel"><span class="keyword">val</span> of_in_channel</span> : <code class="type">Pervasives.in_channel -> char <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALto_buffer"><span class="keyword">val</span> to_buffer</span> : <code class="type">char <a href="Sequence.html#TYPEt">t</a> -> Buffer.t -> unit</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALhashtbl_keys"><span class="keyword">val</span> hashtbl_keys</span> : <code class="type">('a, 'b) Hashtbl.t -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALhashtbl_values"><span class="keyword">val</span> hashtbl_values</span> : <code class="type">('a, 'b) Hashtbl.t -> 'b <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALof_str"><span class="keyword">val</span> of_str</span> : <code class="type">string -> char <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALto_str"><span class="keyword">val</span> to_str</span> : <code class="type">char <a href="Sequence.html#TYPEt">t</a> -> string</code></pre>
|
||||
<pre><span id="VALconcat_str"><span class="keyword">val</span> concat_str</span> : <code class="type">string <a href="Sequence.html#TYPEt">t</a> -> string</code></pre><div class="info ">
|
||||
Concatenate strings together, eagerly.
|
||||
Also see <a href="Sequence.html#VALintersperse"><code class="code">Sequence.intersperse</code></a> to add a separator.<br>
|
||||
<b>Since</b> 0.5<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="EXCEPTIONOneShotSequence"><span class="keyword">exception</span> OneShotSequence</span></pre>
|
||||
<div class="info ">
|
||||
Raised when the user tries to iterate several times on
|
||||
a transient iterator<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALof_in_channel"><span class="keyword">val</span> of_in_channel</span> : <code class="type">Pervasives.in_channel -> char <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterates on characters of the input (can block when one
|
||||
iterates over the sequence). If you need to iterate
|
||||
several times on this sequence, use <a href="Sequence.html#VALpersistent"><code class="code">Sequence.persistent</code></a>.<br>
|
||||
<b>Raises</b> <code>OneShotSequence</code> when used more than once.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALto_buffer"><span class="keyword">val</span> to_buffer</span> : <code class="type">char <a href="Sequence.html#TYPEt">t</a> -> Buffer.t -> unit</code></pre><div class="info ">
|
||||
Copy content of the sequence into the buffer<br>
|
||||
</div>
|
||||
<pre><span id="VALint_range"><span class="keyword">val</span> int_range</span> : <code class="type">start:int -> stop:int -> int <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
Iterator on integers in <code class="code">start...stop</code> by steps 1<br>
|
||||
|
||||
<pre><span id="VALint_range"><span class="keyword">val</span> int_range</span> : <code class="type">start:int -> stop:int -> int <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterator on integers in <code class="code">start...stop</code> by steps 1. Also see
|
||||
<code class="code">(--)</code> for an infix version.<br>
|
||||
</div>
|
||||
<pre><span id="VALof_set"><span class="keyword">val</span> of_set</span> : <code class="type">(module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALint_range_dec"><span class="keyword">val</span> int_range_dec</span> : <code class="type">start:int -> stop:int -> int <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterator on decreasing integers in <code class="code">stop...start</code> by steps -1.
|
||||
See <code class="code">(--^)</code> for an infix version<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALint_range_by"><span class="keyword">val</span> int_range_by</span> : <code class="type">step:int -> int -> int -> int <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">int_range_by ~step i j</code> is the range starting at <code class="code">i</code>, including <code class="code">j</code>,
|
||||
where the difference between successive elements is <code class="code">step</code>.
|
||||
use a negative <code class="code">step</code> for a decreasing sequence.<br>
|
||||
<b>Raises</b> <code>Invalid_argument</code> if <code class="code">step=0</code><br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALbools"><span class="keyword">val</span> bools</span> : <code class="type">bool <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterates on <code class="code">true</code> and <code class="code">false</code><br>
|
||||
<b>Since</b> 0.7<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALof_set"><span class="keyword">val</span> of_set</span> : <code class="type">(module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Convert the given set to a sequence. The set module must be provided.<br>
|
||||
</div>
|
||||
<pre><span id="VALto_set"><span class="keyword">val</span> to_set</span> : <code class="type">(module Set.S with type elt = 'a and type t = 'b) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b</code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALto_set"><span class="keyword">val</span> to_set</span> : <code class="type">(module Set.S with type elt = 'a and type t = 'b) -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'b</code></pre><div class="info ">
|
||||
Convert the sequence to a set, given the proper set module<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="TYPEgen"><span class="keyword">type</span> <code class="type">'a</code> gen</span> = <code class="type">unit -> 'a option</code> </pre>
|
||||
|
||||
|
||||
<pre><span id="TYPEklist"><span class="keyword">type</span> <code class="type">'a</code> klist</span> = <code class="type">unit -> [ `Cons of 'a * 'a <a href="Sequence.html#TYPEklist">klist</a> | `Nil ]</code> </pre>
|
||||
|
||||
|
||||
<pre><span id="VALof_gen"><span class="keyword">val</span> of_gen</span> : <code class="type">'a <a href="Sequence.html#TYPEgen">gen</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Traverse eagerly the generator and build a sequence from it<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALto_gen"><span class="keyword">val</span> to_gen</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEgen">gen</a></code></pre><div class="info ">
|
||||
Make the sequence persistent (O(n)) and then iterate on it. Eager.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALof_klist"><span class="keyword">val</span> of_klist</span> : <code class="type">'a <a href="Sequence.html#TYPEklist">klist</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Iterate on the lazy list<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALto_klist"><span class="keyword">val</span> to_klist</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEklist">klist</a></code></pre><div class="info ">
|
||||
Make the sequence persistent and then iterate on it. Eager.<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Functorialconversionsbetweensetsandsequences">Functorial conversions between sets and sequences</h2><br>
|
||||
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Set.html">Set</a>: <code class="code">sig</code> <a href="Sequence.Set.html">..</a> <code class="code">end</code></pre><br>
|
||||
<h2 id="2_Conversionbetweenmapsandsequences">Conversion between maps and sequences.</h2><br>
|
||||
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Map.html">Map</a>: <code class="code">sig</code> <a href="Sequence.Map.html">..</a> <code class="code">end</code></pre><br>
|
||||
<h2 id="2_Infinitesequencesofrandomvalues">Infinite sequences of random values</h2><br>
|
||||
<pre><span id="VALrandom_int"><span class="keyword">val</span> random_int</span> : <code class="type">int -> int <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALrandom_bool"><span class="keyword">val</span> random_bool</span> : <code class="type">bool <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALrandom_float"><span class="keyword">val</span> random_float</span> : <code class="type">float -> float <a href="Sequence.html#TYPEt">t</a></code></pre><pre><span id="VALrandom_array"><span class="keyword">val</span> random_array</span> : <code class="type">'a array -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info">
|
||||
|
||||
<pre><span id="VALrandom_int"><span class="keyword">val</span> random_int</span> : <code class="type">int -> int <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Infinite sequence of random integers between 0 and
|
||||
the given higher bound (see Random.int)<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALrandom_bool"><span class="keyword">val</span> random_bool</span> : <code class="type">bool <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Infinite sequence of random bool values<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALrandom_float"><span class="keyword">val</span> random_float</span> : <code class="type">float -> float <a href="Sequence.html#TYPEt">t</a></code></pre>
|
||||
<pre><span id="VALrandom_array"><span class="keyword">val</span> random_array</span> : <code class="type">'a array -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Sequence of choices of an element in the array<br>
|
||||
</div>
|
||||
<pre><span id="VALrandom_list"><span class="keyword">val</span> random_list</span> : <code class="type">'a list -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><br>
|
||||
<h2 id="2_Typeclasses">Type-classes</h2><br>
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.TypeClass.html">TypeClass</a>: <code class="code">sig</code> <a href="Sequence.TypeClass.html">..</a> <code class="code">end</code></pre><br>
|
||||
<h2 id="2_Infixfunctions">Infix functions</h2><br>
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Infix.html">Infix</a>: <code class="code">sig</code> <a href="Sequence.Infix.html">..</a> <code class="code">end</code></pre><br>
|
||||
<h2 id="2_Prettyprintingofsequences">Pretty printing of sequences</h2><br>
|
||||
<pre><span id="VALpp_seq"><span class="keyword">val</span> pp_seq</span> : <code class="type">?sep:string -><br> (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info">
|
||||
Pretty print a sequence of <code class="code">'a</code>, using the given pretty printer
|
||||
to print each elements. An optional separator string can be provided.<br>
|
||||
|
||||
<pre><span id="VALrandom_list"><span class="keyword">val</span> random_list</span> : <code class="type">'a list -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
Infinite sequence of random elements of the list. Basically the
|
||||
same as <a href="Sequence.html#VALrandom_array"><code class="code">Sequence.random_array</code></a>.<br>
|
||||
</div>
|
||||
</body></html>
|
||||
|
||||
<pre><span id="VALshuffle"><span class="keyword">val</span> shuffle</span> : <code class="type">'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">shuffle seq</code> returns a perfect shuffle of <code class="code">seq</code>.
|
||||
Uses O(length seq) memory and time. Eager.<br>
|
||||
<b>Since</b> 0.7<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALshuffle_buffer"><span class="keyword">val</span> shuffle_buffer</span> : <code class="type">int -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a <a href="Sequence.html#TYPEt">t</a></code></pre><div class="info ">
|
||||
<code class="code">shuffle_buffer n seq</code> returns a sequence of element of <code class="code">seq</code> in random
|
||||
order. The shuffling is *not* uniform. Uses O(n) memory.
|
||||
<p>
|
||||
|
||||
The first <code class="code">n</code> elements of the sequence are consumed immediately. The
|
||||
rest is consumed lazily.<br>
|
||||
<b>Since</b> 0.7<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Sampling">Sampling</h2><br>
|
||||
|
||||
<pre><span id="VALsample"><span class="keyword">val</span> sample</span> : <code class="type">int -> 'a <a href="Sequence.html#TYPEt">t</a> -> 'a array</code></pre><div class="info ">
|
||||
<code class="code">sample n seq</code> returns k samples of <code class="code">seq</code>, with uniform probability.
|
||||
It will consume the sequence and use O(n) memory.
|
||||
<p>
|
||||
|
||||
It returns an array of size <code class="code">min (length seq) n</code>.<br>
|
||||
<b>Since</b> 0.7<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_Infixfunctions">Infix functions</h2><br>
|
||||
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.Infix.html">Infix</a>: <code class="code">sig</code> <a href="Sequence.Infix.html">..</a> <code class="code">end</code></pre>
|
||||
<pre><span class="keyword">include</span> <a href="Sequence.Infix.html">Sequence.Infix</a></pre>
|
||||
<br>
|
||||
<h2 id="2_Prettyprintingofsequences">Pretty printing of sequences</h2><br>
|
||||
|
||||
<pre><span id="VALpp_seq"><span class="keyword">val</span> pp_seq</span> : <code class="type">?sep:string -><br> (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Pretty print a sequence of <code class="code">'a</code>, using the given pretty printer
|
||||
to print each elements. An optional separator string can be provided.<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALpp_buf"><span class="keyword">val</span> pp_buf</span> : <code class="type">?sep:string -> (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a <a href="Sequence.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
|
||||
Print into a buffer<br>
|
||||
</div>
|
||||
|
||||
<pre><span id="VALto_string"><span class="keyword">val</span> to_string</span> : <code class="type">?sep:string -> ('a -> string) -> 'a <a href="Sequence.html#TYPEt">t</a> -> string</code></pre><div class="info ">
|
||||
Print into a string<br>
|
||||
</div>
|
||||
<br>
|
||||
<h2 id="2_BasicIO">Basic IO</h2>
|
||||
<p>
|
||||
|
||||
Very basic interface to manipulate files as sequence of chunks/lines. The
|
||||
sequences take care of opening and closing files properly; every time
|
||||
one iterates over a sequence, the file is opened/closed again.
|
||||
<p>
|
||||
|
||||
Example: copy a file <code class="code">"a"</code> into file <code class="code">"b"</code>, removing blank lines:
|
||||
<p>
|
||||
|
||||
<pre class="codepre"><code class="code"> Sequence.(IO.lines_of "a" |> filter (fun l-> l<> "") |> IO.write_lines "b");;
|
||||
</code></pre>
|
||||
<p>
|
||||
|
||||
By chunks of <code class="code">4096</code> bytes:
|
||||
<p>
|
||||
|
||||
<pre class="codepre"><code class="code"> Sequence.IO.(chunks_of ~size:4096 "a" |> write_to "b");;
|
||||
</code></pre>
|
||||
<p>
|
||||
|
||||
Read the lines of a file into a list:
|
||||
<p>
|
||||
|
||||
<pre class="codepre"><code class="code"> Sequence.IO.lines "a" |> Sequence.to_list
|
||||
</code></pre><br>
|
||||
|
||||
<pre><span class="keyword">module</span> <a href="Sequence.IO.html">IO</a>: <code class="code">sig</code> <a href="Sequence.IO.html">..</a> <code class="code">end</code></pre></body></html>
|
||||
|
|
@ -1 +1 @@
|
|||
8860b0ecfcc48b9b2fb5adef35908225
|
||||
f0710dfe44cf0fb5dacae3bfdb0e21a2
|
||||
|
|
@ -5,15 +5,18 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title></title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title></title>
|
||||
</head>
|
||||
<body>
|
||||
<h1></h1>
|
||||
<ul class="indexlist">
|
||||
<li><a href="index_types.html">Index of types</a></li>
|
||||
<li><a href="index_exceptions.html">Index of exceptions</a></li>
|
||||
<li><a href="index_values.html">Index of values</a></li>
|
||||
<li><a href="index_modules.html">Index of modules</a></li>
|
||||
<li><a href="index_module_types.html">Index of module types</a></li>
|
||||
|
|
@ -21,7 +24,11 @@
|
|||
<br/><br>
|
||||
<table class="indextable">
|
||||
<tr><td class="module"><a href="Sequence.html">Sequence</a></td><td><div class="info">
|
||||
Transient iterators, that abstract on a finite sequence of elements.
|
||||
Simple and Efficient Iterators
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td class="module"><a href="SequenceLabels.html">SequenceLabels</a></td><td><div class="info">
|
||||
Simple and Efficient Iterators
|
||||
</div>
|
||||
</td></tr>
|
||||
</table>
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of class attributes</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of class attributes</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of class types</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of class types</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of classes</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of classes</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
|
|
|
|||
|
|
@ -4,16 +4,31 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of exceptions</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of exceptions</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
</div>
|
||||
<h1>Index of exceptions</h1>
|
||||
<table>
|
||||
<tr><td align="left"><br>O</td></tr>
|
||||
<tr><td><a href="SequenceLabels.html#EXCEPTIONOneShotSequence">OneShotSequence</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td><div class="info">
|
||||
Raised when the user tries to iterate several times on
|
||||
a transient iterator
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.html#EXCEPTIONOneShotSequence">OneShotSequence</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td><div class="info">
|
||||
Raised when the user tries to iterate several times on
|
||||
a transient iterator
|
||||
</div>
|
||||
</td></tr>
|
||||
</table>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -4,10 +4,12 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of class methods</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of class methods</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of module types</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of module types</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
|
|
@ -15,6 +17,10 @@
|
|||
<h1>Index of module types</h1>
|
||||
<table>
|
||||
<tr><td align="left"><br>S</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Map.S.html">S</a> [<a href="SequenceLabels.Map.html">SequenceLabels.Map</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="SequenceLabels.Set.S.html">S</a> [<a href="SequenceLabels.Set.html">SequenceLabels.Set</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.Map.S.html">S</a> [<a href="Sequence.Map.html">Sequence.Map</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.Set.S.html">S</a> [<a href="Sequence.Set.html">Sequence.Set</a>]</td>
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of modules</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of modules</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
|
|
@ -15,6 +17,16 @@
|
|||
<h1>Index of modules</h1>
|
||||
<table>
|
||||
<tr><td align="left"><br>A</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Map.Adapt.html">Adapt</a> [<a href="SequenceLabels.Map.html">SequenceLabels.Map</a>]</td>
|
||||
<td><div class="info">
|
||||
Adapt a pre-existing Map module to make it sequence-aware
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Set.Adapt.html">Adapt</a> [<a href="SequenceLabels.Set.html">SequenceLabels.Set</a>]</td>
|
||||
<td><div class="info">
|
||||
Create an enriched Set module from the given one
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.Map.Adapt.html">Adapt</a> [<a href="Sequence.Map.html">Sequence.Map</a>]</td>
|
||||
<td><div class="info">
|
||||
Adapt a pre-existing Map module to make it sequence-aware
|
||||
|
|
@ -26,9 +38,25 @@ Create an enriched Set module from the given one
|
|||
</div>
|
||||
</td></tr>
|
||||
<tr><td align="left"><br>I</td></tr>
|
||||
<tr><td><a href="SequenceLabels.IO.html">IO</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.IO.html">IO</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="SequenceLabels.Infix.html">Infix</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.Infix.html">Infix</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>M</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Map.Make.html">Make</a> [<a href="SequenceLabels.Map.html">SequenceLabels.Map</a>]</td>
|
||||
<td><div class="info">
|
||||
Create an enriched Map module, with sequence-aware functions
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Set.Make.html">Make</a> [<a href="SequenceLabels.Set.html">SequenceLabels.Set</a>]</td>
|
||||
<td><div class="info">
|
||||
Functor to build an extended Set module from an ordered type
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.Map.Make.html">Make</a> [<a href="Sequence.Map.html">Sequence.Map</a>]</td>
|
||||
<td><div class="info">
|
||||
Create an enriched Map module, with sequence-aware functions
|
||||
|
|
@ -39,18 +67,24 @@ Create an enriched Map module, with sequence-aware functions
|
|||
Functor to build an extended Set module from an ordered type
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Map.html">Map</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.Map.html">Map</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>S</td></tr>
|
||||
<tr><td><a href="Sequence.html">Sequence</a> </td>
|
||||
<td><div class="info">
|
||||
Transient iterators, that abstract on a finite sequence of elements.
|
||||
Simple and Efficient Iterators
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.Set.html">Set</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<tr><td><a href="SequenceLabels.html">SequenceLabels</a> </td>
|
||||
<td><div class="info">
|
||||
Simple and Efficient Iterators
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="SequenceLabels.Set.html">Set</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>T</td></tr>
|
||||
<tr><td><a href="Sequence.TypeClass.html">TypeClass</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<tr><td><a href="Sequence.Set.html">Set</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
</table>
|
||||
</body>
|
||||
|
|
|
|||
|
|
@ -4,40 +4,47 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Index of types</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Index of types</title>
|
||||
</head>
|
||||
<body>
|
||||
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
|
||||
</div>
|
||||
<h1>Index of types</h1>
|
||||
<table>
|
||||
<tr><td align="left"><br>A</td></tr>
|
||||
<tr><td><a href="Sequence.TypeClass.html#TYPEaddable">addable</a> [<a href="Sequence.TypeClass.html">Sequence.TypeClass</a>]</td>
|
||||
<tr><td align="left"><br>G</td></tr>
|
||||
<tr><td><a href="SequenceLabels.html#TYPEgen">gen</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>I</td></tr>
|
||||
<tr><td><a href="Sequence.TypeClass.html#TYPEiterable">iterable</a> [<a href="Sequence.TypeClass.html">Sequence.TypeClass</a>]</td>
|
||||
<tr><td><a href="Sequence.html#TYPEgen">gen</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>M</td></tr>
|
||||
<tr><td><a href="Sequence.Map.S.html#TYPEmap">map</a> [<a href="Sequence.Map.S.html">Sequence.Map.S</a>]</td>
|
||||
<tr><td align="left"><br>K</td></tr>
|
||||
<tr><td><a href="SequenceLabels.html#TYPEklist">klist</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.TypeClass.html#TYPEmonoid">monoid</a> [<a href="Sequence.TypeClass.html">Sequence.TypeClass</a>]</td>
|
||||
<tr><td><a href="Sequence.html#TYPEklist">klist</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>S</td></tr>
|
||||
<tr><td><a href="Sequence.TypeClass.html#TYPEsequenceable">sequenceable</a> [<a href="Sequence.TypeClass.html">Sequence.TypeClass</a>]</td>
|
||||
<td><div class="info">
|
||||
Classes
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.Set.S.html#TYPEset">set</a> [<a href="Sequence.Set.S.html">Sequence.Set.S</a>]</td>
|
||||
<tr><td><a href="SequenceLabels.html#TYPEsequence">sequence</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td><a href="Sequence.html#TYPEsequence">sequence</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td></td></tr>
|
||||
<tr><td align="left"><br>T</td></tr>
|
||||
<tr><td><a href="SequenceLabels.html#TYPEt">t</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td><div class="info">
|
||||
A sequence of values of type <code class="code">'a</code>.
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.html#TYPEt">t</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
<td><div class="info">
|
||||
Sequence abstract iterator type, representing a finite sequence of
|
||||
values of type <code class="code">'a</code>.
|
||||
A sequence of values of type <code class="code">'a</code>.
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="SequenceLabels.html#TYPEt2">t2</a> [<a href="SequenceLabels.html">SequenceLabels</a>]</td>
|
||||
<td><div class="info">
|
||||
Sequence of pairs of values of type <code class="code">'a</code> and <code class="code">'b</code>.
|
||||
</div>
|
||||
</td></tr>
|
||||
<tr><td><a href="Sequence.html#TYPEt2">t2</a> [<a href="Sequence.html">Sequence</a>]</td>
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,7 +1,5 @@
|
|||
.keyword { font-weight : bold ; color : Red }
|
||||
.keywordsign { color : #C04600 }
|
||||
.superscript { font-size : 4 }
|
||||
.subscript { font-size : 4 }
|
||||
.comment { color : Green }
|
||||
.constructor { color : Blue }
|
||||
.type { color : #5C6585 }
|
||||
|
|
|
|||
|
|
@ -3,14 +3,19 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Infix</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Infix</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">sig</span><br>
|
||||
<span class="keyword">val</span> ( -- ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> ( |> ) : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> ( @@ ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<code class="code"><span class="keyword">sig</span>
|
||||
<span class="keyword">val</span> ( -- ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( --^ ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( >>= ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( >|= ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( <*> ) : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( <+> ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,44 +3,48 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map.Adapt</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map.Adapt</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">M</span> : <span class="constructor">Map</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a map = <span class="keywordsign">'</span>a <span class="constructor">M</span>.t<br>
|
||||
<span class="keyword">type</span> key = <span class="constructor">M</span>.key<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t<br>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">M</span> : <span class="constructor">Map</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key = <span class="constructor">M</span>.key
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a t = <span class="keywordsign">'</span>a <span class="constructor">M</span>.t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,44 +3,48 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map.Make</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map.Make</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">V</span> : <span class="constructor">Map</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">type</span> key = <span class="constructor">V</span>.t<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t<br>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">V</span> : <span class="constructor">Map</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key = <span class="constructor">V</span>.t
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,43 +3,47 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map.S</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map.S</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">type</span> key<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> key <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<code class="code"><span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> key <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,118 +3,128 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Map</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Map</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">sig</span><br>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">type</span> key<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> key <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">M</span> : <span class="constructor">Map</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a map = <span class="keywordsign">'</span>a <span class="constructor">M</span>.t<br>
|
||||
<span class="keyword">type</span> key = <span class="constructor">M</span>.key<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">V</span> : <span class="constructor">Map</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">type</span> key = <span class="constructor">V</span>.t<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<code class="code"><span class="keyword">sig</span>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> key <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">M</span> : <span class="constructor">Map</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key = <span class="constructor">M</span>.key
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a t = <span class="keywordsign">'</span>a <span class="constructor">M</span>.t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span>
|
||||
<span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">V</span> : <span class="constructor">Map</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key = <span class="constructor">V</span>.t
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span>
|
||||
<span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,40 +3,45 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set.Adapt</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set.Adapt</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set = <span class="constructor">X</span>.t<br>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.elt<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt t <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> to_seq : set <span class="keywordsign">-></span> elt t<br>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.elt
|
||||
<span class="keyword">type</span> t = <span class="constructor">X</span>.t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt sequence <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> to_seq : t <span class="keywordsign">-></span> elt sequence
|
||||
<span class="keyword">val</span> to_list : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,40 +3,45 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set.Make</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set.Make</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set<br>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.t<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt t <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> to_seq : set <span class="keywordsign">-></span> elt t<br>
|
||||
<code class="code"><span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.t
|
||||
<span class="keyword">type</span> t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt sequence <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> to_seq : t <span class="keywordsign">-></span> elt sequence
|
||||
<span class="keyword">val</span> to_list : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,39 +3,44 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set.S</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set.S</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set<br>
|
||||
<span class="keyword">type</span> elt<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.<span class="constructor">Set</span>.<span class="constructor">S</span>.set<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="constructor">Sequence</span>.<span class="constructor">Set</span>.<span class="constructor">S</span>.set <span class="keywordsign">-></span> elt <span class="constructor">Sequence</span>.t<br>
|
||||
<code class="code"><span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt
|
||||
<span class="keyword">type</span> t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt <span class="constructor">Sequence</span>.sequence <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_seq : <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> elt <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> to_list : <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,106 +3,117 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence.Set</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence.Set</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">sig</span><br>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set<br>
|
||||
<span class="keyword">type</span> elt<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.<span class="constructor">Set</span>.<span class="constructor">S</span>.set<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="constructor">Sequence</span>.<span class="constructor">Set</span>.<span class="constructor">S</span>.set <span class="keywordsign">-></span> elt <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set = <span class="constructor">X</span>.t<br>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.elt<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt t <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> to_seq : set <span class="keywordsign">-></span> elt t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set<br>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.t<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt t <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> to_seq : set <span class="keywordsign">-></span> elt t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<code class="code"><span class="keyword">sig</span>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt
|
||||
<span class="keyword">type</span> t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt <span class="constructor">Sequence</span>.sequence <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_seq : <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> elt <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> to_list : <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.elt
|
||||
<span class="keyword">type</span> t = <span class="constructor">X</span>.t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt sequence <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> to_seq : t <span class="keywordsign">-></span> elt sequence
|
||||
<span class="keyword">val</span> to_list : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.t
|
||||
<span class="keyword">type</span> t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt sequence <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> to_seq : t <span class="keywordsign">-></span> elt sequence
|
||||
<span class="keyword">val</span> to_list : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
|
|
@ -3,336 +3,420 @@
|
|||
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
|
||||
<link rel="Start" href="index.html">
|
||||
<link title="Index of types" rel=Appendix href="index_types.html">
|
||||
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
|
||||
<link title="Index of values" rel=Appendix href="index_values.html">
|
||||
<link title="Index of modules" rel=Appendix href="index_modules.html">
|
||||
<link title="Index of module types" rel=Appendix href="index_module_types.html">
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html"><title>Sequence</title>
|
||||
<link title="Sequence" rel="Chapter" href="Sequence.html">
|
||||
<link title="SequenceLabels" rel="Chapter" href="SequenceLabels.html"><title>Sequence</title>
|
||||
</head>
|
||||
<body>
|
||||
<code class="code"><span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a t = (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">type</span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) t2 = (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> from_iter : ((<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> from_fun : (unit <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> singleton : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> repeat : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> iterate : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> forever : (unit <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> cycle : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> iter : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> iteri : (int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (<span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> foldi : (<span class="keywordsign">'</span>b <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> mapi : (int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> for_all : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> length : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> append : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> concat : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> flatten : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> flatMap : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> intersperse : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> persistent : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> sort : ?cmp:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> sort_uniq : ?cmp:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> group : ?eq:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> uniq : ?eq:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> product : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> join :<br>
|
||||
join_row:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> unfoldr : (<span class="keywordsign">'</span>b <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> scan : (<span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> max : ?lt:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> min : ?lt:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> take : int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> drop : int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> rev : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> empty2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2<br>
|
||||
<span class="keyword">val</span> is_empty2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> length2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> zip : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> unzip : (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2<br>
|
||||
<span class="keyword">val</span> zip_i : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (int, <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t2<br>
|
||||
<span class="keyword">val</span> fold2 : (<span class="keywordsign">'</span>c <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c) <span class="keywordsign">-></span> <span class="keywordsign">'</span>c <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> <span class="keywordsign">'</span>c<br>
|
||||
<span class="keyword">val</span> iter2 : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> map2 : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c) <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> <span class="keywordsign">'</span>c <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> map2_2 :<br>
|
||||
(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c) <span class="keywordsign">-></span><br>
|
||||
(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>d) <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> (<span class="keywordsign">'</span>c, <span class="keywordsign">'</span>d) <span class="constructor">Sequence</span>.t2<br>
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list<br>
|
||||
<span class="keyword">val</span> to_rev_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list<br>
|
||||
<span class="keyword">val</span> of_list : <span class="keywordsign">'</span>a list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_array : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a array<br>
|
||||
<span class="keyword">val</span> of_array : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_array_i : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> (int * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_array2 : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> (int, <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t2<br>
|
||||
<span class="keyword">val</span> array_slice : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_stream : <span class="keywordsign">'</span>a <span class="constructor">Stream</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_stream : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Stream</span>.t<br>
|
||||
<span class="keyword">val</span> to_stack : <span class="keywordsign">'</span>a <span class="constructor">Stack</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> of_stack : <span class="keywordsign">'</span>a <span class="constructor">Stack</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_queue : <span class="keywordsign">'</span>a <span class="constructor">Queue</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> of_queue : <span class="keywordsign">'</span>a <span class="constructor">Queue</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> hashtbl_add : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> hashtbl_replace : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> to_hashtbl : (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t<br>
|
||||
<span class="keyword">val</span> to_hashtbl2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t<br>
|
||||
<span class="keyword">val</span> of_hashtbl : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_hashtbl2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2<br>
|
||||
<span class="keyword">val</span> hashtbl_keys : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> hashtbl_values : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_str : string <span class="keywordsign">-></span> char <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_str : char <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> string<br>
|
||||
<span class="keyword">val</span> of_in_channel : <span class="constructor">Pervasives</span>.in_channel <span class="keywordsign">-></span> char <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_buffer : char <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="constructor">Buffer</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> int_range : start:int <span class="keywordsign">-></span> stop:int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_set :<br>
|
||||
(<span class="keyword">module</span> <span class="constructor">Set</span>.<span class="constructor">S</span> <span class="keyword">with</span> <span class="keyword">type</span> elt = <span class="keywordsign">'</span>a <span class="keyword">and</span> <span class="keyword">type</span> t = <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_set :<br>
|
||||
(<span class="keyword">module</span> <span class="constructor">Set</span>.<span class="constructor">S</span> <span class="keyword">with</span> <span class="keyword">type</span> elt = <span class="keywordsign">'</span>a <span class="keyword">and</span> <span class="keyword">type</span> t = <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">module</span> <span class="constructor">Set</span> :<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set<br>
|
||||
<span class="keyword">type</span> elt<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.<span class="constructor">Set</span>.<span class="constructor">S</span>.set<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="constructor">Sequence</span>.<span class="constructor">Set</span>.<span class="constructor">S</span>.set <span class="keywordsign">-></span> elt <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set = <span class="constructor">X</span>.t<br>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.elt<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt t <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> to_seq : set <span class="keywordsign">-></span> elt t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> set<br>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.t<br>
|
||||
<span class="keyword">val</span> empty : set<br>
|
||||
<span class="keyword">val</span> is_empty : set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> union : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> inter : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> diff : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> compare : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> subset : set <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * set<br>
|
||||
<span class="keyword">val</span> cardinal : set <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> elements : set <span class="keywordsign">-></span> elt list<br>
|
||||
<span class="keyword">val</span> min_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> max_elt : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> choose : set <span class="keywordsign">-></span> elt<br>
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> set <span class="keywordsign">-></span> set * bool * set<br>
|
||||
<span class="keyword">val</span> of_seq : elt t <span class="keywordsign">-></span> set<br>
|
||||
<span class="keyword">val</span> to_seq : set <span class="keywordsign">-></span> elt t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Map</span> :<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">type</span> key<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> key <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.<span class="constructor">Map</span>.<span class="constructor">S</span>.map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">M</span> : <span class="constructor">Map</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a map = <span class="keywordsign">'</span>a <span class="constructor">M</span>.t<br>
|
||||
<span class="keyword">type</span> key = <span class="constructor">M</span>.key<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :<br>
|
||||
<span class="keyword">functor</span> (<span class="constructor">V</span> : <span class="constructor">Map</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span><br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">type</span> key = <span class="constructor">V</span>.t<br>
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> merge :<br>
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span><br>
|
||||
<span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map <span class="keywordsign">-></span> <span class="keywordsign">'</span>c map<br>
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> unit<br>
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> bool<br>
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> int<br>
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list<br>
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a<br>
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>b map<br>
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) t<br>
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a map<br>
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> key t<br>
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a map <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">val</span> random_int : int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> random_bool : bool <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> random_float : float <span class="keywordsign">-></span> float <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> random_array : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> random_list : <span class="keywordsign">'</span>a list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">module</span> <span class="constructor">TypeClass</span> :<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">type</span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) sequenceable = {<br>
|
||||
to_seq : <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t;<br>
|
||||
of_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b;<br>
|
||||
}<br>
|
||||
<span class="keyword">type</span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) addable = { empty : <span class="keywordsign">'</span>b; add : <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b; }<br>
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a monoid = (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.<span class="constructor">TypeClass</span>.addable<br>
|
||||
<span class="keyword">type</span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) iterable = { iter : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> unit; }<br>
|
||||
<span class="keyword">val</span> sequenceable : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t) <span class="constructor">Sequence</span>.<span class="constructor">TypeClass</span>.sequenceable<br>
|
||||
<span class="keyword">val</span> iterable : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t) <span class="constructor">Sequence</span>.<span class="constructor">TypeClass</span>.iterable<br>
|
||||
<span class="keyword">val</span> monoid : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="constructor">Sequence</span>.<span class="constructor">TypeClass</span>.monoid<br>
|
||||
<span class="keyword">val</span> of_iterable :<br>
|
||||
(<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.<span class="constructor">TypeClass</span>.iterable <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> to_addable :<br>
|
||||
(<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.<span class="constructor">TypeClass</span>.addable <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">module</span> <span class="constructor">Infix</span> :<br>
|
||||
<span class="keyword">sig</span><br>
|
||||
<span class="keyword">val</span> ( -- ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">val</span> ( |> ) : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b<br>
|
||||
<span class="keyword">val</span> ( @@ ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t<br>
|
||||
<span class="keyword">end</span><br>
|
||||
<span class="keyword">val</span> pp_seq :<br>
|
||||
?sep:string <span class="keywordsign">-></span><br>
|
||||
(<span class="constructor">Format</span>.formatter <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span><br>
|
||||
<span class="constructor">Format</span>.formatter <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit<br>
|
||||
<code class="code"><span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a t = (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a sequence = <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">type</span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) t2 = (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> from_iter : ((<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> from_fun : (unit <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> singleton : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> doubleton : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> cons : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> snoc : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> return : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> pure : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> repeat : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> iterate : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> forever : (unit <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> cycle : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> iter : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> iteri : (int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> foldi : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> mapi : (int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> map_by_2 : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> for_all : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : ?eq:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> find : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option
|
||||
<span class="keyword">val</span> length : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> append : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> concat : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> flatten : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> flat_map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> flat_map_l : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b list) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> filter_map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> intersperse : <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> persistent : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> persistent_lazy : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> sort : ?cmp:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> sort_uniq : ?cmp:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> group_succ_by :
|
||||
?eq:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> group_by :
|
||||
?hash:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span>
|
||||
?eq:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> uniq : ?eq:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> product : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> product2 : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> join :
|
||||
join_row:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span>
|
||||
<span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> unfoldr : (<span class="keywordsign">'</span>b <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> scan : (<span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> max : ?lt:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option
|
||||
<span class="keyword">val</span> min : ?lt:(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option
|
||||
<span class="keyword">val</span> head : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option
|
||||
<span class="keyword">val</span> head_exn : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> take : int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> take_while : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> fold_while :
|
||||
(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a * [ <span class="keywordsign">`</span><span class="constructor">Continue</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Stop</span> ]) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> drop : int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> drop_while : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> rev : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> empty2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> is_empty2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> length2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> zip : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> unzip : (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> zip_i : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (int, <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> fold2 : (<span class="keywordsign">'</span>c <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c) <span class="keywordsign">-></span> <span class="keywordsign">'</span>c <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> <span class="keywordsign">'</span>c
|
||||
<span class="keyword">val</span> iter2 : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> map2 : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c) <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> <span class="keywordsign">'</span>c <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> map2_2 :
|
||||
(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>c) <span class="keywordsign">-></span>
|
||||
(<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>d) <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> (<span class="keywordsign">'</span>c, <span class="keywordsign">'</span>d) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list
|
||||
<span class="keyword">val</span> to_rev_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list
|
||||
<span class="keyword">val</span> of_list : <span class="keywordsign">'</span>a list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> on_list : (<span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a list <span class="keywordsign">-></span> <span class="keywordsign">'</span>b list
|
||||
<span class="keyword">val</span> to_opt : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option
|
||||
<span class="keyword">val</span> to_array : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a array
|
||||
<span class="keyword">val</span> of_array : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_array_i : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> (int * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_array2 : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> (int, <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> array_slice : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_opt : <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_stream : <span class="keywordsign">'</span>a <span class="constructor">Stream</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_stream : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Stream</span>.t
|
||||
<span class="keyword">val</span> to_stack : <span class="keywordsign">'</span>a <span class="constructor">Stack</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> of_stack : <span class="keywordsign">'</span>a <span class="constructor">Stack</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_queue : <span class="keywordsign">'</span>a <span class="constructor">Queue</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> of_queue : <span class="keywordsign">'</span>a <span class="constructor">Queue</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> hashtbl_add : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> hashtbl_replace : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> to_hashtbl : (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t
|
||||
<span class="keyword">val</span> to_hashtbl2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2 <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t
|
||||
<span class="keyword">val</span> of_hashtbl : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a * <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_hashtbl2 : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t2
|
||||
<span class="keyword">val</span> hashtbl_keys : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> hashtbl_values : (<span class="keywordsign">'</span>a, <span class="keywordsign">'</span>b) <span class="constructor">Hashtbl</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_str : string <span class="keywordsign">-></span> char <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_str : char <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> string
|
||||
<span class="keyword">val</span> concat_str : string <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> string
|
||||
<span class="keyword">exception</span> <span class="constructor">OneShotSequence</span>
|
||||
<span class="keyword">val</span> of_in_channel : <span class="constructor">Pervasives</span>.in_channel <span class="keywordsign">-></span> char <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_buffer : char <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="constructor">Buffer</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> int_range : start:int <span class="keywordsign">-></span> stop:int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> int_range_dec : start:int <span class="keywordsign">-></span> stop:int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> int_range_by : step:int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> bools : bool <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> of_set :
|
||||
(<span class="keyword">module</span> <span class="constructor">Set</span>.<span class="constructor">S</span> <span class="keyword">with</span> <span class="keyword">type</span> elt = <span class="keywordsign">'</span>a <span class="keyword">and</span> <span class="keyword">type</span> t = <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_set :
|
||||
(<span class="keyword">module</span> <span class="constructor">Set</span>.<span class="constructor">S</span> <span class="keyword">with</span> <span class="keyword">type</span> elt = <span class="keywordsign">'</span>a <span class="keyword">and</span> <span class="keyword">type</span> t = <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a gen = unit <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a klist = unit <span class="keywordsign">-></span> [ <span class="keywordsign">`</span><span class="constructor">Cons</span> <span class="keyword">of</span> <span class="keywordsign">'</span>a * <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.klist <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Nil</span> ]
|
||||
<span class="keyword">val</span> of_gen : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.gen <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_gen : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.gen
|
||||
<span class="keyword">val</span> of_klist : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.klist <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_klist : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.klist
|
||||
<span class="keyword">module</span> <span class="constructor">Set</span> :
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt
|
||||
<span class="keyword">type</span> t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt <span class="constructor">Sequence</span>.sequence <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> to_seq : <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> elt <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> to_list : <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.elt
|
||||
<span class="keyword">type</span> t = <span class="constructor">X</span>.t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt sequence <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> to_seq : t <span class="keywordsign">-></span> elt sequence
|
||||
<span class="keyword">val</span> to_list : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">X</span> : <span class="constructor">Set</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> elt = <span class="constructor">X</span>.t
|
||||
<span class="keyword">type</span> t
|
||||
<span class="keyword">val</span> empty : t
|
||||
<span class="keyword">val</span> is_empty : t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> singleton : elt <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> remove : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> union : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> inter : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> diff : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> subset : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (elt <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (elt <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> for_all : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> partition : (elt <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * t
|
||||
<span class="keyword">val</span> cardinal : t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> elements : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> min_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> max_elt : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> choose : t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> split : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t * bool * t
|
||||
<span class="keyword">val</span> find : elt <span class="keywordsign">-></span> t <span class="keywordsign">-></span> elt
|
||||
<span class="keyword">val</span> of_seq : elt sequence <span class="keywordsign">-></span> t
|
||||
<span class="keyword">val</span> to_seq : t <span class="keywordsign">-></span> elt sequence
|
||||
<span class="keyword">val</span> to_list : t <span class="keywordsign">-></span> elt list
|
||||
<span class="keyword">val</span> of_list : elt list <span class="keywordsign">-></span> t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Map</span> :
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span>
|
||||
<span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) <span class="constructor">Sequence</span>.sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> key <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Adapt</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">M</span> : <span class="constructor">Map</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key = <span class="constructor">M</span>.key
|
||||
<span class="keyword">type</span> <span class="keywordsign">'</span>a t = <span class="keywordsign">'</span>a <span class="constructor">M</span>.t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span>
|
||||
<span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">module</span> <span class="constructor">Make</span> :
|
||||
<span class="keyword">functor</span> (<span class="constructor">V</span> : <span class="constructor">Map</span>.<span class="constructor">OrderedType</span>) <span class="keywordsign">-></span>
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">type</span> key = <span class="constructor">V</span>.t
|
||||
<span class="keyword">type</span> +<span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> empty : <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> is_empty : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> mem : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> add : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> singleton : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> remove : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> merge :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option <span class="keywordsign">-></span> <span class="keywordsign">'</span>b option <span class="keywordsign">-></span> <span class="keywordsign">'</span>c option) <span class="keywordsign">-></span>
|
||||
<span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t <span class="keywordsign">-></span> <span class="keywordsign">'</span>c t
|
||||
<span class="keyword">val</span> union :
|
||||
(key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a option) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> compare : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> int) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> equal : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> iter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> fold : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="keywordsign">-></span> <span class="keywordsign">'</span>b
|
||||
<span class="keyword">val</span> for_all : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> exists : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> bool
|
||||
<span class="keyword">val</span> filter : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> partition : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> bool) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> cardinal : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> int
|
||||
<span class="keyword">val</span> bindings : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> min_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> max_binding : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> choose : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key * <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> split : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t * <span class="keywordsign">'</span>a option * <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> find : key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a
|
||||
<span class="keyword">val</span> map : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> mapi : (key <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> to_seq : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) sequence
|
||||
<span class="keyword">val</span> of_seq : (key * <span class="keywordsign">'</span>a) sequence <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> keys : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> key sequence
|
||||
<span class="keyword">val</span> values : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a sequence
|
||||
<span class="keyword">val</span> to_list : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (key * <span class="keywordsign">'</span>a) list
|
||||
<span class="keyword">val</span> of_list : (key * <span class="keywordsign">'</span>a) list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">val</span> random_int : int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> random_bool : bool <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> random_float : float <span class="keywordsign">-></span> float <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> random_array : <span class="keywordsign">'</span>a array <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> random_list : <span class="keywordsign">'</span>a list <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> shuffle : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> shuffle_buffer : int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> sample : int <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a array
|
||||
<span class="keyword">module</span> <span class="constructor">Infix</span> :
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">val</span> ( -- ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( --^ ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( >>= ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( >|= ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( <*> ) : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> ( <+> ) : <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">val</span> ( -- ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int t
|
||||
<span class="keyword">val</span> ( --^ ) : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int t
|
||||
<span class="keyword">val</span> ( >>= ) : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> ( >|= ) : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> ( <*> ) : (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>b) t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>b t
|
||||
<span class="keyword">val</span> ( <+> ) : <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a t
|
||||
<span class="keyword">val</span> pp_seq :
|
||||
?sep:string <span class="keywordsign">-></span>
|
||||
(<span class="constructor">Format</span>.formatter <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span>
|
||||
<span class="constructor">Format</span>.formatter <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> pp_buf :
|
||||
?sep:string <span class="keywordsign">-></span>
|
||||
(<span class="constructor">Buffer</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> unit) <span class="keywordsign">-></span> <span class="constructor">Buffer</span>.t <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> to_string : ?sep:string <span class="keywordsign">-></span> (<span class="keywordsign">'</span>a <span class="keywordsign">-></span> string) <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> string
|
||||
<span class="keyword">module</span> <span class="constructor">IO</span> :
|
||||
<span class="keyword">sig</span>
|
||||
<span class="keyword">val</span> lines_of :
|
||||
?mode:int <span class="keywordsign">-></span>
|
||||
?flags:<span class="constructor">Pervasives</span>.open_flag list <span class="keywordsign">-></span> string <span class="keywordsign">-></span> string <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> chunks_of :
|
||||
?mode:int <span class="keywordsign">-></span>
|
||||
?flags:<span class="constructor">Pervasives</span>.open_flag list <span class="keywordsign">-></span>
|
||||
?size:int <span class="keywordsign">-></span> string <span class="keywordsign">-></span> string <span class="constructor">Sequence</span>.t
|
||||
<span class="keyword">val</span> write_to :
|
||||
?mode:int <span class="keywordsign">-></span>
|
||||
?flags:<span class="constructor">Pervasives</span>.open_flag list <span class="keywordsign">-></span>
|
||||
string <span class="keywordsign">-></span> string <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> write_bytes_to :
|
||||
?mode:int <span class="keywordsign">-></span>
|
||||
?flags:<span class="constructor">Pervasives</span>.open_flag list <span class="keywordsign">-></span>
|
||||
string <span class="keywordsign">-></span> <span class="constructor">Bytes</span>.t <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> write_lines :
|
||||
?mode:int <span class="keywordsign">-></span>
|
||||
?flags:<span class="constructor">Pervasives</span>.open_flag list <span class="keywordsign">-></span>
|
||||
string <span class="keywordsign">-></span> string <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">val</span> write_bytes_lines :
|
||||
?mode:int <span class="keywordsign">-></span>
|
||||
?flags:<span class="constructor">Pervasives</span>.open_flag list <span class="keywordsign">-></span>
|
||||
string <span class="keywordsign">-></span> <span class="constructor">Bytes</span>.t <span class="constructor">Sequence</span>.t <span class="keywordsign">-></span> unit
|
||||
<span class="keyword">end</span>
|
||||
<span class="keyword">end</span></code></body></html>
|
||||
Loading…
Add table
Reference in a new issue