| ( * ) [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 [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] | |
| 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 [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] |