package eliom

The type for events with occurrences of type 'a.

A never occuring event. For all t, [never]_t = None.

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.

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 E.never.

stop e stops e from occuring. It conceptually becomes 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.

equal e e' is true iff e and e' are equal. If both events are different from never, physical equality is used.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

on 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.

• deprecated

  Use on.

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.

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.

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.

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.

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.

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

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'.

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