module E: sig .. end

type 'a t = 'a React.event 

The type for events with occurrences of type 'a.

val never : 'a React.event

A never occuring event. For all t, [never]_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 -> unit

stop 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 -> bool

equal 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.event

trace 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.event

once 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.event

drop_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.event

app 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.event

map 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.event

stamp e v is map (fun _ -> v) e.

val filter : ('a -> bool) -> 'a React.event -> 'a React.event

filter p e are e's occurrences that satisfy p.

• [filter p e]_t = Some v if [e]_t = Some v and p v = true
• [filter p e]_t = None otherwise.

val fmap : ('a -> 'b option) -> 'a React.event -> 'b React.event

fmap fm e are e's occurrences filtered and mapped by fm.

• [fmap fm e]_t = Some v if fm [e]_t = Some v
• [fmap fm e]_t = None otherwise.

val diff : ('a -> 'a -> 'b) -> 'a React.event -> 'b React.event

diff 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.event

changes 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.event

when_ 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.event

dismiss 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.event

until c e is e's occurences until c occurs.

• [until c e]_t = Some v if [e]_t = Some v and [c]_<=t = None
• [until c e]_t = None otherwise.

val accum : ('a -> 'a) React.event -> 'a -> 'a React.event

accum 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.event

fold 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.event

select 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]_t
• [select el]_t = None otherwise.

val merge : ('a -> 'b -> 'a) -> 'a -> 'b React.event list -> 'a React.event

merge 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.event

switch 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) -> 'b

fix 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).