module E:sig..end
Consult their semantics.
type'at ='a React.event
'a.val never : 'a React.eventnever]t = None.val create : unit -> 'a React.event * (?step:React.step -> 'a -> unit)create () is a primitive event e and a send function. The
function send is such that:
send v generates an occurrence v of e at the time it is called
and triggers an update step.send ~step v generates an occurence v of e on the step step
when step is executed.send ~step v raises Invalid_argument if it was previously
called with a step and this step has not executed yet or if
the given step was already executed.
Warning. send must not be executed inside an update step.
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 : ?strong:bool -> 'a React.event -> unitstop e stops e from occuring. It conceptually becomes
React.E.never and cannot be restarted. Allows to
disable effectful events.
The strong argument should only be used on platforms
where weak arrays have a strong semantics (i.e. JavaScript).
See details.
Note. If executed in an update step
the event may still occur in the step.
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 on : bool React.signal -> 'a React.event -> 'a React.eventon c e is the occurrences of e when c is true.
on c e]t = Some v
if [c]t = true and [e]t = Some v.on c e]t = None otherwise.val when_ : bool React.signal -> 'a React.event -> 'a React.event
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).
Lifting combinators. For a given n the semantics is:
ln f e1 ... en]t = Some (f v1 ... vn) if for all
i : [ei]t = Some vi.ln f e1 ... en]t = None otherwise.val l1 : ('a -> 'b) -> 'a React.event -> 'b React.event
val l2 : ('a -> 'b -> 'c) -> 'a React.event -> 'b React.event -> 'c React.event
val l3 : ('a -> 'b -> 'c -> 'd) ->
'a React.event -> 'b React.event -> 'c React.event -> 'd React.event
val l4 : ('a -> 'b -> 'c -> 'd -> 'e) ->
'a React.event ->
'b React.event -> 'c React.event -> 'd React.event -> 'e React.event
val l5 : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a React.event ->
'b React.event ->
'c React.event -> 'd React.event -> 'e React.event -> 'f React.event
val l6 : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) ->
'a React.event ->
'b React.event ->
'c React.event ->
'd React.event -> 'e React.event -> 'f React.event -> 'g React.eventmodule Option:sig..end