Index of values


( * ) [React.S.Int]
( ** ) [React.S.Float]
( *. ) [React.S.Float]
(!=) [React.S.Compare]
(&&) [React.S.Bool]
(+) [React.S.Int]
(+.) [React.S.Float]
(-) [React.S.Int]
(-.) [React.S.Float]
(/.) [React.S.Float]
(<) [React.S.Compare]
(<=) [React.S.Compare]
(<>) [React.S.Compare]
(=) [React.S.Compare]
(==) [React.S.Compare]
(>) [React.S.Compare]
(>=) [React.S.Compare]
(asr) [React.S.Int]
(land) [React.S.Int]
(lor) [React.S.Int]
(lsl) [React.S.Int]
(lsr) [React.S.Int]
(lxor) [React.S.Int]
(mod) [React.S.Int]
(||) [React.S.Bool]
(~-) [React.S.Int]
(~-.) [React.S.Float]

A
abs [React.S.Int]
abs_float [React.S.Float]
accum [React.S.S]
accum [React.S]
accum e i is S.hold i (React.E.accum e i).
accum [React.E]
accum ef i accumulates a value, starting with i, using e's functional occurrences.
acos [React.S.Float]
app [React.S.S]
app [React.S]
app sf s holds the value of sf applied to the value of s, [app sf s]t = [sf]t [s]t.
app [React.E]
app ef e occurs when both ef and e occur simultaneously.
asin [React.S.Float]
atan [React.S.Float]
atan2 [React.S.Float]

B
bind [React.S.S]
bind [React.S]
bind s sf is switch (map ~eq:( == ) sf s).

C
ceil [React.S.Float]
changes [React.S]
changes s is diff (fun v _ -> v) s.
changes [React.E]
changes eq e is e's occurrences with occurences equal to the previous one dropped.
classify_float [React.S.Float]
compare [React.S.Compare]
const [React.S]
const v is always v, [const v]t = v.
cos [React.S.Float]
cosh [React.S.Float]
create [React.Step]
create () is a new update step.
create [React.S.S]
create [React.S]
create i is a primitive signal s set to i and a set function.
create [React.E]
create () is a primitive event e and a send function.

D
diff [React.S]
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).
diff [React.E]
diff f e occurs whenever e occurs except on the next occurence.
dismiss [React.S.S]
dismiss [React.S]
dismiss c i s is the signal s except changes when c occurs are ignored.
dismiss [React.E]
dismiss c e is the occurences of e except the ones when c occurs.
drop_once [React.E]
drop_once e is e without its next occurrence.

E
edge [React.S.Bool]
edge s is changes s.
epsilon_float [React.S.Float]
equal [React.S.EqType]
equal [React.S.S]
equal [React.S]
equal s s' is true iff s and s' are equal.
equal [React.E]
equal e e' is true iff e and e' are equal.
execute [React.Step]
execute step executes the update step.
exp [React.S.Float]

F
fall [React.S.Bool]
fall s is E.fmap (fun b -> if b then None else Some ()) (edge s).
filter [React.S.S]
filter [React.S]
filter f i s is s's values that satisfy p.
filter [React.E]
filter p e are e's occurrences that satisfy p.
fix [React.S.S]
fix [React.S]
fix i sf allow to refer to the value a signal had an infinitesimal amount of time before.
fix [React.E]
fix ef allows to refer to the value an event had an infinitesimal amount of time before.
flip [React.S.Bool]
flip b e is a signal whose boolean value flips each time e occurs.
float [React.S.Float]
float_of_int [React.S.Float]
floor [React.S.Float]
fmap [React.S.S]
fmap [React.S]
fmap fm i s is s filtered and mapped by fm.
fmap [React.E]
fmap fm e are e's occurrences filtered and mapped by fm.
fold [React.S.S]
fold [React.S]
fold f i e is S.hold i (React.E.fold f i e).
fold [React.E]
fold f i e accumulates e's occurrences with f starting with i.
frexp [React.S.Float]
fst [React.S.Pair]

H
hold [React.S.S]
hold [React.S]
hold i e has the value of e's last occurrence or i if there wasn't any.

I
infinity [React.S.Float]
int_of_float [React.S.Float]

L
l1 [React.S.S]
l1 [React.S]
l1 [React.E]
l2 [React.S.S]
l2 [React.S]
l2 [React.E]
l3 [React.S.S]
l3 [React.S]
l3 [React.E]
l4 [React.S.S]
l4 [React.S]
l4 [React.E]
l5 [React.S.S]
l5 [React.S]
l5 [React.E]
l6 [React.S.S]
l6 [React.S]
l6 [React.E]
ldexp [React.S.Float]
lnot [React.S.Int]
log [React.S.Float]
log10 [React.S.Float]

M
map [React.S.S]
map [React.S]
map f s is s transformed by f, [map f s]t = f [s]t.
map [React.E]
map f e applies f to e's occurrences.
max_float [React.S.Float]
max_int [React.S.Int]
merge [React.S.S]
merge [React.S]
merge f a sl merges the value of every signal in sl using f and the accumulator a.
merge [React.E]
merge f a el merges the simultaneous occurrences of every event in el using f and the accumulator a.
min_float [React.S.Float]
min_int [React.S.Int]
minus_one [React.S.Float]
minus_one [React.S.Int]
mod_float [React.S.Float]
modf [React.S.Float]

N
nan [React.S.Float]
neg_infinity [React.S.Float]
never [React.E]
A never occuring event.
none [React.S.Option]
none is S.const None.
not [React.S.Bool]

O
on [React.S]
on c i s is the signal s whenever c is true.
on [React.E]
on c e is the occurrences of e when c is true.
once [React.E]
once e is e with only its next occurence.
one [React.S.Float]
one [React.S.Int]
one [React.S.Bool]

P
pair [React.S.Pair]
pred [React.S.Int]

R
retain [React.S]
retain s c keeps a reference to the closure c in s and returns the previously retained value.
retain [React.E]
retain e c keeps a reference to the closure c in e and returns the previously retained value.
rise [React.S.Bool]
rise s is E.fmap (fun b -> if b then Some () else None) (edge s).

S
sample [React.S]
sample f e s samples s at e's occurrences.
select [React.E]
select el is the occurrences of every event in el.
sin [React.S.Float]
sinh [React.S.Float]
snd [React.S.Pair]
some [React.S.Option]
some s is S.map ~eq (fun v -> Some v) None, where eq uses s's equality function to test the Some v's equalities.
some [React.E.Option]
some e is map (fun v -> Some v) e.
sqrt [React.S.Float]
stamp [React.E]
stamp e v is map (fun _ -> v) e.
stop [React.S]
stop s, stops updating s.
stop [React.E]
stop e stops e from occuring.
succ [React.S.Int]
switch [React.S.S]
switch [React.S]
switch ss is the inner signal of ss.
switch [React.E]
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..

T
tan [React.S.Float]
tanh [React.S.Float]
trace [React.S]
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).
trace [React.E]
trace iff tr e is e except tr is invoked with e's occurence when iff is true (defaults to S.const true).
truncate [React.S.Float]

U
until [React.E]
until c e is e's occurences until c occurs.

V
value [React.S.Option]
value default s is s with only its Some v values.
value [React.S]
value s is s's current value.
value [React.E.Option]
value default e either silences None occurences if default is unspecified or replaces them by the value of default at the occurence time.

W
when_ [React.S.S]
when_ [React.S]
when_ [React.E]

Z
zero [React.S.Float]
zero [React.S.Int]
zero [React.S.Bool]