# 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] |
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.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
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.
exp [React.S.Float] |
F
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.
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] |
l2 [React.S.S] |
l2 [React.S] |
l3 [React.S.S] |
l3 [React.S] |
l4 [React.S.S] |
l4 [React.S] |
l5 [React.S.S] |
l5 [React.S] |
l6 [React.S.S] |
l6 [React.S] |
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] |
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.
not [React.S.Bool] |
O
once [React.E] | `once e` is `e` with only its next occurence.
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.
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] |
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 s es` is `s` until there is an occurrence `s'` on `es`, `s'` is then used until there is a new occurrence on `es`, etc..
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] | `value s` is `s`'s current value.
W
when_ [React.S.S] |
when_ [React.S] | `when_ c i s` is the signal `s` whenever `c` is `true`.
when_ [React.E] | `when_ c e` is the occurrences of `e` when `c` is `true`.