Module React.S

The type for signals of type 'a.

const v is always v, [const v]_t = v.

create i is a primitive signal s set to i and a set function. The function set is such that:

• set v sets the signal's value to v at the time it is called and triggers an update step.
• set ~step v sets the signal's value to v at the time it is called and updates it dependencies when step is executed
• set ~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. set must not be executed inside an update step.

value s is s's current value.

Warning. If executed in an update step may return a non up-to-date value or raise Failure if the signal is not yet initialized.

retain s c keeps a reference to the closure c in s and returns the previously retained value. c will never be invoked.

Raises. Invalid_argument on constant signals.

stop s, stops updating s. It conceptually becomes const with the signal's last value and cannot be restarted. Allows to disable effectful signals.

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 signal may still update in the step.

equal s s' is true iff s and s' are equal. If both signals are constant eq is used between their value (defauts to structural equality). If both signals are not constant, physical equality is used.

trace iff tr s is s except tr is invoked with s's current value and on s changes when iff is true (defaults to S.const true). For all t where [s]_t = v and (t = 0 or ([s]_t-dt= v' and eq v v' = false)) and [iff]_t = true, tr is invoked with v.

hold i e has the value of e's last occurrence or i if there wasn't any.

• [hold i e]_t = i if [e]_<=t = None
• [hold i e]_t = v if [e]_<=t = Some v

app sf s holds the value of sf applied to the value of s, [app sf s]_t = [sf]_t [s]_t.

map f s is s transformed by f, [map f s]_t = f [s]_t.

filter f i s is s's values that satisfy p. If a value does not satisfy p it holds the last value that was satisfied or i if there is none.

• [filter p s]_t = [s]_t if p [s]_t = true.
• [filter p s]_t = [s]_t' if p [s]_t = false and t' is the greatest t' < t with p [s]_t' = true.
• [filter p e]_t = i otherwise.

fmap fm i s is s filtered and mapped by fm.

• [fmap fm i s]_t = v if fm [s]_t = Some v.
• [fmap fm i s]_t = [fmap fm i s]_t' if fm [s]_t = None and t' is the greatest t' < t with fm [s]_t' <> None.
• [fmap fm i s]_t = i otherwise.

diff f s is an event with occurrences whenever s changes from v' to v and eq v v' is false (eq is the signal's equality function). The value of the occurrence is f v v'.

• [diff f s]_t = Some d if [s]_t = v and [s]_t-dt = v' and eq v v' = false and f v v' = d.
• [diff f s]_t = None otherwise.

changes s is diff (fun v _ -> v) s.

sample f e s samples s at e's occurrences.

• [sample f e s]_t = Some (f ev sv) if [e]_t = Some ev and [s]_t = sv.
• [sample e s]_t = None otherwise.

on c i s is the signal s whenever c is true. When c is false it holds the last value s had when c was the last time true or i if it never was.

• [on c i s]_t = [s]_t if [c]_t = true
• [on c i s]_t = [s]_t' if [c]_t = false where t' is the greatest t' < t with [c]_t' = true.
• [on c i s]_t = i otherwise.

deprecated

Use on.

dismiss c i s is the signal s except changes when c occurs are ignored. If c occurs initially i is used.

• [dismiss c i s]_t = [s]_t' where t' is the greatest t' <= t with [c]_t' = None and [s]_t'-dt <> [s]_t'
• [dismiss_ c i s]₀ = v where v = i if [c]₀ = Some _ and v = [s]₀ otherwise.

accum e i is S.hold i (E:accum e i).

fold f i e is S.hold i (E.fold f i e).

merge f a sl merges the value of every signal in sl using f and the accumulator a.

[merge f a sl]_t = List.fold_left f a (List.map []_t sl).

switch ss is the inner signal of ss.

• [switch ss]_t = [[ss]_t]_t.

bind s sf is switch (map ~eq:( == ) sf s).

fix i sf allow to refer to the value a signal had an infinitesimal amount of time before.

In fix sf, sf is called with a signal s that represents the signal returned by sf delayed by an infinitesimal amount time. If s', r = sf s then r is returned by fix and s is such that :

• [s]_t = i for t = 0.
• [s]_t = [s']_t-dt otherwise.

eq is the equality used by s.

Raises. Invalid_argument if s' is directly a delayed signal (i.e. a signal given to a fixing function).

Note. Regarding values depending on the result r of s', r = sf s the following two cases need to be distinguished :

• After sf s is applied, s' does not depend on a value that is in a step and s has no dependents in a step (e.g in the simple case where fix is applied outside a step).

  In that case if the initial value of s' differs from i, s and its dependents need to be updated and a special update step will be triggered for this. Values depending on the result r will be created only after this special update step has finished (e.g. they won't see the i of s if r = s).

• Otherwise, values depending on r will be created in the same step as s and s' (e.g. they will see the i of s if r = s).

Input signature of Make

Output signature of Make

Functor specializing the combinators for the given signal value type

Specialization for booleans, integers and floats.