<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
<link rel="Start" href="index.html">
<link rel="next" href="React.S.html">
<link rel="Up" href="React.html">
<link title="Index of types" rel=Appendix href="index_types.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="React" rel="Chapter" href="React.html"><link title="Primitive and basics" rel="Section" href="#prim">
<link title="Transforming and filtering" rel="Section" href="#transf">
<link title="Accumulating" rel="Section" href="#accum">
<link title="Combining" rel="Section" href="#combine">
<link title="Lifting" rel="Section" href="#1_Lifting">
<link title="Pervasives support" rel="Section" href="#1_Pervasivessupport">
<title>React.E</title>
</head>
<body>
<div class="navbar"> <a class="up" href="React.html" title="React">Up</a>
<a class="post" href="React.S.html" title="React.S">Next</a>
</div>
<h1>Module <a href="type_React.E.html">React.E</a></h1>
<pre><span class="keyword">module</span> E: <code class="code"><span class="keyword">sig</span></code> <a href="React.E.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info module top">
Event combinators.
<p>
Consult their <a href="React.html#evsem">semantics.</a><br>
</div>
<hr width="100%">
<br>
<h1 id="prim">Primitive and basics</h1><br>
<pre><span id="TYPEt"><span class="keyword">type</span> <code class="type">'a</code> t</span> = <code class="type">'a <a href="React.html#TYPEevent">React.event</a></code> </pre>
<div class="info ">
The type for events with occurrences of type <code class="code"><span class="keywordsign">'</span>a</code>.<br>
</div>
<pre><span id="VALnever"><span class="keyword">val</span> never</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
A never occuring event. For all t, [<code class="code">never</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code>.<br>
</div>
<pre><span id="VALcreate"><span class="keyword">val</span> create</span> : <code class="type">unit -> 'a <a href="React.html#TYPEevent">React.event</a> * (?step:<a href="React.html#TYPEstep">React.step</a> -> 'a -> unit)</code></pre><div class="info ">
<code class="code">create ()</code> is a primitive event <code class="code">e</code> and a <code class="code">send</code> function. The
function <code class="code">send</code> is such that:
<ul>
<li><code class="code">send v</code> generates an occurrence <code class="code">v</code> of <code class="code">e</code> at the time it is called
and triggers an <a href="React.html#steps">update step</a>.</li>
<li><code class="code">send ~step v</code> generates an occurence <code class="code">v</code> of <code class="code">e</code> on the step <code class="code">step</code>
when <code class="code">step</code> is <a href="React.Step.html#VALexecute">executed</a>.</li>
<li><code class="code">send ~step v</code> raises <code class="code"><span class="constructor">Invalid_argument</span></code> if it was previously
called with a step and this step has not executed yet or if
the given <code class="code">step</code> was already executed.</li>
</ul>
<p>
<b>Warning.</b> <code class="code">send</code> must not be executed inside an update step.<br>
</div>
<pre><span id="VALretain"><span class="keyword">val</span> retain</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> -> (unit -> unit) -> [ `R of unit -> unit ]</code></pre><div class="info ">
<code class="code">retain e c</code> keeps a reference to the closure <code class="code">c</code> in <code class="code">e</code> and
returns the previously retained value. <code class="code">c</code> will <em>never</em> be
invoked.
<p>
<b>Raises.</b> <code class="code"><span class="constructor">Invalid_argument</span></code> on <a href="React.E.html#VALnever"><code class="code"><span class="constructor">React</span>.<span class="constructor">E</span>.never</code></a>.<br>
</div>
<pre><span id="VALstop"><span class="keyword">val</span> stop</span> : <code class="type">?strong:bool -> 'a <a href="React.html#TYPEevent">React.event</a> -> unit</code></pre><div class="info ">
<code class="code">stop e</code> stops <code class="code">e</code> from occuring. It conceptually becomes
<a href="React.E.html#VALnever"><code class="code"><span class="constructor">React</span>.<span class="constructor">E</span>.never</code></a> and cannot be restarted. Allows to
disable <a href="React.html#sideeffects">effectful</a> events.
<p>
The <code class="code">strong</code> argument should only be used on platforms
where weak arrays have a strong semantics (i.e. JavaScript).
See <a href="React.html#strongstop">details</a>.
<p>
<b>Note.</b> If executed in an <a href="React.html#steps">update step</a>
the event may still occur in the step.<br>
</div>
<pre><span id="VALequal"><span class="keyword">val</span> equal</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a> -> bool</code></pre><div class="info ">
<code class="code">equal e e'</code> is <code class="code"><span class="keyword">true</span></code> iff <code class="code">e</code> and <code class="code">e'</code> are equal. If both events are
different from <a href="React.E.html#VALnever"><code class="code"><span class="constructor">React</span>.<span class="constructor">E</span>.never</code></a>, physical equality is used.<br>
</div>
<pre><span id="VALtrace"><span class="keyword">val</span> trace</span> : <code class="type">?iff:bool <a href="React.html#TYPEsignal">React.signal</a> -> ('a -> unit) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">trace iff tr e</code> is <code class="code">e</code> except <code class="code">tr</code> is invoked with e's
occurence when <code class="code">iff</code> is <code class="code"><span class="keyword">true</span></code> (defaults to <code class="code"><span class="constructor">S</span>.const <span class="keyword">true</span></code>).
For all t where [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and [<code class="code">iff</code>]<sub class="subscript">t</sub> =
<code class="code"><span class="keyword">true</span></code>, <code class="code">tr</code> is invoked with <code class="code">v</code>.<br>
</div>
<br>
<h1 id="transf">Transforming and filtering</h1><br>
<pre><span id="VALonce"><span class="keyword">val</span> once</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">once e</code> is <code class="code">e</code> with only its next occurence.
<ul>
<li>[<code class="code">once e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and
[<code class="code">e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">None</span></code>.</li>
<li>[<code class="code">once e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALdrop_once"><span class="keyword">val</span> drop_once</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">drop_once e</code> is <code class="code">e</code> without its next occurrence.
<ul>
<li>[<code class="code">drop_once e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and
[<code class="code">e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">Some</span> _</code>.</li>
<li>[<code class="code">drop_once e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALapp"><span class="keyword">val</span> app</span> : <code class="type">('a -> 'b) <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">app ef e</code> occurs when both <code class="code">ef</code> and <code class="code">e</code> occur
<a href="React.html#simultaneity">simultaneously</a>.
The value is <code class="code">ef</code>'s occurence applied to <code class="code">e</code>'s one.
<ul>
<li>[<code class="code">app ef e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v'</code> if [<code class="code">ef</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> f</code> and
[<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and <code class="code">f v = v'</code>.</li>
<li>[<code class="code">app ef e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">('a -> 'b) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">map f e</code> applies <code class="code">f</code> to <code class="code">e</code>'s occurrences.
<ul>
<li>[<code class="code">map f e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> (f v)</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>.</li>
<li>[<code class="code">map f e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALstamp"><span class="keyword">val</span> stamp</span> : <code class="type">'b <a href="React.html#TYPEevent">React.event</a> -> 'a -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">stamp e v</code> is <code class="code">map (<span class="keyword">fun</span> _ <span class="keywordsign">-></span> v) e</code>.<br>
</div>
<pre><span id="VALfilter"><span class="keyword">val</span> filter</span> : <code class="type">('a -> bool) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">filter p e</code> are <code class="code">e</code>'s occurrences that satisfy <code class="code">p</code>.
<ul>
<li>[<code class="code">filter p e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and
<code class="code">p v = <span class="keyword">true</span></code></li>
<li>[<code class="code">filter p e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALfmap"><span class="keyword">val</span> fmap</span> : <code class="type">('a -> 'b option) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">fmap fm e</code> are <code class="code">e</code>'s occurrences filtered and mapped by <code class="code">fm</code>.
<ul>
<li>[<code class="code">fmap fm e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> if <code class="code">fm</code> [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code></li>
<li>[<code class="code">fmap fm e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALdiff"><span class="keyword">val</span> diff</span> : <code class="type">('a -> 'a -> 'b) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">diff f e</code> occurs whenever <code class="code">e</code> occurs except on the next occurence.
Occurences are <code class="code">f v v'</code> where <code class="code">v</code> is <code class="code">e</code>'s current
occurrence and <code class="code">v'</code> the previous one.
<ul>
<li>[<code class="code">diff f e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> r</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>,
[<code class="code">e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">Some</span> v'</code> and <code class="code">f v v' = r</code>.</li>
<li>[<code class="code">diff f e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALchanges"><span class="keyword">val</span> changes</span> : <code class="type">?eq:('a -> 'a -> bool) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">changes eq e</code> is <code class="code">e</code>'s occurrences with occurences equal to
the previous one dropped. Equality is tested with <code class="code">eq</code> (defaults to
structural equality).
<ul>
<li>[<code class="code">changes eq e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>
and either [<code class="code">e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">None</span></code> or [<code class="code">e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">Some</span> v'</code> and
<code class="code">eq v v' = <span class="keyword">false</span></code>.</li>
<li>[<code class="code">changes eq e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALon"><span class="keyword">val</span> on</span> : <code class="type">bool <a href="React.html#TYPEsignal">React.signal</a> -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">on c e</code> is the occurrences of <code class="code">e</code> when <code class="code">c</code> is <code class="code"><span class="keyword">true</span></code>.
<ul>
<li>[<code class="code">on c e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>
if [<code class="code">c</code>]<sub class="subscript">t</sub> <code class="code">= <span class="keyword">true</span></code> and [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>.</li>
<li>[<code class="code">on c e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALwhen_"><span class="keyword">val</span> when_</span> : <code class="type">bool <a href="React.html#TYPEsignal">React.signal</a> -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<span class="warning">Deprecated.</span>Use <a href="React.E.html#VALon"><code class="code"><span class="constructor">React</span>.<span class="constructor">E</span>.on</code></a>.<br>
</div>
<pre><span id="VALdismiss"><span class="keyword">val</span> dismiss</span> : <code class="type">'b <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">dismiss c e</code> is the occurences of <code class="code">e</code> except the ones when <code class="code">c</code> occurs.
<ul>
<li>[<code class="code">dimiss c e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>
if [<code class="code">c</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> and [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code>.</li>
<li>[<code class="code">dimiss c e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALuntil"><span class="keyword">val</span> until</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">until c e</code> is <code class="code">e</code>'s occurences until <code class="code">c</code> occurs.
<ul>
<li>[<code class="code">until c e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> if [<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and
[<code class="code">c</code>]<sub class="subscript"><=t</sub> <code class="code">= <span class="constructor">None</span></code></li>
<li>[<code class="code">until c e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<br>
<h1 id="accum">Accumulating</h1><br>
<pre><span id="VALaccum"><span class="keyword">val</span> accum</span> : <code class="type">('a -> 'a) <a href="React.html#TYPEevent">React.event</a> -> 'a -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">accum ef i</code> accumulates a value, starting with <code class="code">i</code>, using <code class="code">e</code>'s
functional occurrences.
<ul>
<li>[<code class="code">accum ef i</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> (f i)</code> if [<code class="code">ef</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> f</code>
and [<code class="code">ef</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">None</span></code>.
</li>
<li>[<code class="code">accum ef i</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> (f acc)</code> if [<code class="code">ef</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> f</code>
and [<code class="code">accum ef i</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">Some</span> acc</code>.</li>
<li>[<code class="code">accum ef i</code>] <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALfold"><span class="keyword">val</span> fold</span> : <code class="type">('a -> 'b -> 'a) -> 'a -> 'b <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">fold f i e</code> accumulates <code class="code">e</code>'s occurrences with <code class="code">f</code> starting with <code class="code">i</code>.
<ul>
<li>[<code class="code">fold f i e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> (f i v)</code> if
[<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and [<code class="code">e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">None</span></code>.</li>
<li>[<code class="code">fold f i e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> (f acc v)</code> if
[<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> v</code> and [<code class="code">fold f i e</code>]<sub class="subscript"><t</sub> <code class="code">= <span class="constructor">Some</span> acc</code>.</li>
<li>[<code class="code">fold f i e</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<br>
<h1 id="combine">Combining</h1><br>
<pre><span id="VALselect"><span class="keyword">val</span> select</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> list -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">select el</code> is the occurrences of every event in <code class="code">el</code>.
If more than one event occurs <a href="React.html#simultaneity">simultaneously</a>
the leftmost is taken and the others are lost.
<ul>
<li>[<code class="code">select el</code>]<sub class="subscript">t</sub> <code class="code">=</code> [<code class="code"><span class="constructor">List</span>.find (<span class="keyword">fun</span> e <span class="keywordsign">-></span> </code>[<code class="code">e</code>]<sub class="subscript">t</sub>
<code class="code"><> <span class="constructor">None</span>) el</code>]<sub class="subscript">t</sub></li>
<li>[<code class="code">select el</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
</div>
<pre><span id="VALmerge"><span class="keyword">val</span> merge</span> : <code class="type">('a -> 'b -> 'a) -> 'a -> 'b <a href="React.html#TYPEevent">React.event</a> list -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">merge f a el</code> merges the <a href="React.html#simultaneity">simultaneous</a>
occurrences of every event in <code class="code">el</code> using <code class="code">f</code> and the accumulator <code class="code">a</code>.
<p>
[<code class="code">merge f a el</code>]<sub class="subscript">t</sub>
<code class="code">= <span class="constructor">List</span>.fold_left f a (<span class="constructor">List</span>.filter (<span class="keyword">fun</span> o <span class="keywordsign">-></span> o <> <span class="constructor">None</span>)
(<span class="constructor">List</span>.map</code> []<sub class="subscript">t</sub><code class="code"> el))</code>.<br>
</div>
<pre><span id="VALswitch"><span class="keyword">val</span> switch</span> : <code class="type">'a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a> <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a></code></pre><div class="info ">
<code class="code">switch e ee</code> is <code class="code">e</code>'s occurrences until there is an
occurrence <code class="code">e'</code> on <code class="code">ee</code>, the occurrences of <code class="code">e'</code> are then used
until there is a new occurrence on <code class="code">ee</code>, etc..
<ul>
<li>[<code class="code">switch e ee</code>]<sub class="subscript">t</sub> <code class="code">=</code> [<code class="code">e</code>]<sub class="subscript">t</sub> if [<code class="code">ee</code>]<sub class="subscript"><=t</sub> <code class="code">= <span class="constructor">None</span></code>.</li>
<li>[<code class="code">switch e ee</code>]<sub class="subscript">t</sub> <code class="code">=</code> [<code class="code">e'</code>]<sub class="subscript">t</sub> if [<code class="code">ee</code>]<sub class="subscript"><=t</sub>
<code class="code">= <span class="constructor">Some</span> e'</code>.</li>
</ul>
<br>
</div>
<pre><span id="VALfix"><span class="keyword">val</span> fix</span> : <code class="type">('a <a href="React.html#TYPEevent">React.event</a> -> 'a <a href="React.html#TYPEevent">React.event</a> * 'b) -> 'b</code></pre><div class="info ">
<code class="code">fix ef</code> allows to refer to the value an event had an
infinitesimal amount of time before.
<p>
In <code class="code">fix ef</code>, <code class="code">ef</code> is called with an event <code class="code">e</code> that represents
the event returned by <code class="code">ef</code> delayed by an infinitesimal amount of
time. If <code class="code">e', r = ef e</code> then <code class="code">r</code> is returned by <code class="code">fix</code> and <code class="code">e</code>
is such that :
<ul>
<li>[<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">=</code> <code class="code"><span class="constructor">None</span></code> if t = 0 </li>
<li>[<code class="code">e</code>]<sub class="subscript">t</sub> <code class="code">=</code> [<code class="code">e'</code>]<sub class="subscript">t-dt</sub> otherwise</li>
</ul>
<p>
<b>Raises.</b> <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">e'</code> is directly a delayed event (i.e.
an event given to a fixing function).<br>
</div>
<br>
<h1 id="1_Lifting">Lifting</h1>
<p>
Lifting combinators. For a given <code class="code">n</code> the semantics is:
<ul>
<li>[<code class="code">ln f e1 ... en</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> (f v1 ... vn)</code> if for all
i : [<code class="code">ei</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">Some</span> vi</code>.</li>
<li>[<code class="code">ln f e1 ... en</code>]<sub class="subscript">t</sub> <code class="code">= <span class="constructor">None</span></code> otherwise.</li>
</ul>
<br>
<pre><span id="VALl1"><span class="keyword">val</span> l1</span> : <code class="type">('a -> 'b) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a></code></pre>
<pre><span id="VALl2"><span class="keyword">val</span> l2</span> : <code class="type">('a -> 'b -> 'c) -> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a> -> 'c <a href="React.html#TYPEevent">React.event</a></code></pre>
<pre><span id="VALl3"><span class="keyword">val</span> l3</span> : <code class="type">('a -> 'b -> 'c -> 'd) -><br> 'a <a href="React.html#TYPEevent">React.event</a> -> 'b <a href="React.html#TYPEevent">React.event</a> -> 'c <a href="React.html#TYPEevent">React.event</a> -> 'd <a href="React.html#TYPEevent">React.event</a></code></pre>
<pre><span id="VALl4"><span class="keyword">val</span> l4</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e) -><br> 'a <a href="React.html#TYPEevent">React.event</a> -><br> 'b <a href="React.html#TYPEevent">React.event</a> -> 'c <a href="React.html#TYPEevent">React.event</a> -> 'd <a href="React.html#TYPEevent">React.event</a> -> 'e <a href="React.html#TYPEevent">React.event</a></code></pre>
<pre><span id="VALl5"><span class="keyword">val</span> l5</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e -> 'f) -><br> 'a <a href="React.html#TYPEevent">React.event</a> -><br> 'b <a href="React.html#TYPEevent">React.event</a> -><br> 'c <a href="React.html#TYPEevent">React.event</a> -> 'd <a href="React.html#TYPEevent">React.event</a> -> 'e <a href="React.html#TYPEevent">React.event</a> -> 'f <a href="React.html#TYPEevent">React.event</a></code></pre>
<pre><span id="VALl6"><span class="keyword">val</span> l6</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) -><br> 'a <a href="React.html#TYPEevent">React.event</a> -><br> 'b <a href="React.html#TYPEevent">React.event</a> -><br> 'c <a href="React.html#TYPEevent">React.event</a> -><br> 'd <a href="React.html#TYPEevent">React.event</a> -> 'e <a href="React.html#TYPEevent">React.event</a> -> 'f <a href="React.html#TYPEevent">React.event</a> -> 'g <a href="React.html#TYPEevent">React.event</a></code></pre><br>
<h1 id="1_Pervasivessupport">Pervasives support</h1><br>
<pre><span class="keyword">module</span> <a href="React.E.Option.html">Option</a>: <code class="code"><span class="keyword">sig</span></code> <a href="React.E.Option.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info">
Events with option occurences.
</div>
</body></html>
distrib
>
Mageia
>
5
>
x86_64
>
media
>
core-release
>
by-pkgid
>
55ca3e426f1ba810750df60d13ae969f
>
files
>
8
