module E:Event combinators.sig..end
Consult their semantics.
type'at ='a React.event
'a.val never : 'a React.eventnever]t = None.val create : unit -> 'a React.event * ('a -> unit)create () is a primitive event e and a send function.
send v generates an occurrence v of e at the time it is called
and triggers an update cycle.
Warning. send must not be executed inside an update cycle.
val retain : 'a React.event -> (unit -> unit) -> [ `R of unit -> unit ]retain e c keeps a reference to the closure c in e and
returns the previously retained value. c will never be
invoked.
Raises. Invalid_argument on React.E.never.
val stop : 'a React.event -> unitstop e stops e from occuring. It conceptually becomes
React.E.never and cannot be restarted. Allows to
disable effectful events.
Note. If executed in an update cycle
the event may still occur in the cycle.
val equal : 'a React.event -> 'a React.event -> boolequal e e' is true iff e and e' are equal. If both events are
different from React.E.never, physical equality is used.val trace : ?iff:bool React.signal -> ('a -> unit) -> 'a React.event -> 'a React.eventtrace iff tr e is e except tr is invoked with e's
occurence when iff is true (defaults to S.const true).
For all t where [e]t = Some v and [iff]t =
true, tr is invoked with v.val once : 'a React.event -> 'a React.eventonce e is e with only its next occurence.
once e]t = Some v if [e]t = Some v and
[e]<t = None.once e]t = None otherwise.val drop_once : 'a React.event -> 'a React.eventdrop_once e is e without its next occurrence.
drop_once e]t = Some v if [e]t = Some v and
[e]<t = Some _.drop_once e]t = None otherwise.val app : ('a -> 'b) React.event -> 'a React.event -> 'b React.eventapp ef e occurs when both ef and e occur
simultaneously.
The value is ef's occurence applied to e's one.
app ef e]t = Some v' if [ef]t = Some f and
[e]t = Some v and f v = v'.app ef e]t = None otherwise.val map : ('a -> 'b) -> 'a React.event -> 'b React.eventmap f e applies f to e's occurrences.
map f e]t = Some (f v) if [e]t = Some v.map f e]t = None otherwise.val stamp : 'b React.event -> 'a -> 'a React.eventstamp e v is map (fun _ -> v) e.val filter : ('a -> bool) -> 'a React.event -> 'a React.eventfilter p e are e's occurrences that satisfy p.
filter p e]t = Some v if [e]t = Some v and
p v = truefilter p e]t = None otherwise.val fmap : ('a -> 'b option) -> 'a React.event -> 'b React.eventfmap fm e are e's occurrences filtered and mapped by fm.
fmap fm e]t = Some v if fm [e]t = Some vfmap fm e]t = None otherwise.val diff : ('a -> 'a -> 'b) -> 'a React.event -> 'b React.eventdiff f e occurs whenever e occurs except on the next occurence.
Occurences are f v v' where v is e's current
occurrence and v' the previous one.
diff f e]t = Some r if [e]t = Some v,
[e]<t = Some v' and f v v' = r.diff f e]t = None otherwise.val changes : ?eq:('a -> 'a -> bool) -> 'a React.event -> 'a React.eventchanges eq e is e's occurrences with occurences equal to
the previous one dropped. Equality is tested with eq (defaults to
structural equality).
changes eq e]t = Some v if [e]t = Some v
and either [e]<t = None or [e]<t = Some v' and
eq v v' = false.changes eq e]t = None otherwise.val when_ : bool React.signal -> 'a React.event -> 'a React.eventwhen_ c e is the occurrences of e when c is true.
when_ c e]t = Some v
if [c]t = true and [e]t = Some v.when_ c e]t = None otherwise.val dismiss : 'b React.event -> 'a React.event -> 'a React.eventdismiss c e is the occurences of e except the ones when c occurs.
dimiss c e]t = Some v
if [c]t = None and [e]t = Some v.dimiss c e]t = None otherwise.val until : 'a React.event -> 'b React.event -> 'b React.eventuntil c e is e's occurences until c occurs.
until c e]t = Some v if [e]t = Some v and
[c]<=t = Noneuntil c e]t = None otherwise.val accum : ('a -> 'a) React.event -> 'a -> 'a React.eventaccum ef i accumulates a value, starting with i, using e's
functional occurrences.
accum ef i]t = Some (f i) if [ef]t = Some f
and [ef]<t = None.
accum ef i]t = Some (f acc) if [ef]t = Some f
and [accum ef i]<t = Some acc.accum ef i] = None otherwise.val fold : ('a -> 'b -> 'a) -> 'a -> 'b React.event -> 'a React.eventfold f i e accumulates e's occurrences with f starting with i.
fold f i e]t = Some (f i v) if
[e]t = Some v and [e]<t = None.fold f i e]t = Some (f acc v) if
[e]t = Some v and [fold f i e]<t = Some acc.fold f i e]t = None otherwise.val select : 'a React.event list -> 'a React.eventselect el is the occurrences of every event in el.
If more than one event occurs simultaneously
the leftmost is taken and the others are lost.
select el]t = [List.find (fun e -> [e]t
<> None) el]tselect el]t = None otherwise.val merge : ('a -> 'b -> 'a) -> 'a -> 'b React.event list -> 'a React.eventmerge f a el merges the simultaneous
occurrences of every event in el using f and the accumulator a.
[merge f a el]t
= List.fold_left f a (List.filter (fun o -> o <> None)
(List.map []t el)).
val switch : 'a React.event -> 'a React.event React.event -> 'a React.eventswitch e ee is e's occurrences until there is an
occurrence e' on ee, the occurrences of e' are then used
until there is a new occurrence on ee, etc..
switch e ee]t = [e]t if [ee]<=t = None.switch e ee]t = [e']t if [ee]<=t
= Some e'.val fix : ('a React.event -> 'a React.event * 'b) -> 'bfix ef allows to refer to the value an event had an
infinitesimal amount of time before.
In fix ef, ef is called with an event e that represents
the event returned by ef delayed by an infinitesimal amount of
time. If e', r = ef e then r is returned by fix and e
is such that :
e]t = None if t = 0 e]t = [e']t-dt otherwise
Raises. Invalid_argument if e' is directly a delayed event (i.e.
an event given to a fixing function).