Index of values


($) [Note.Logr]
f $ v is app f v.
(&&) [Note.S.Bool]
s0 && s1 is l2 ( && ) s1 s2.
(||) [Note.S.Bool]
s0 || s1 is l2 ( || ) s1 s2.

A
accum [Note.S]
accum i e is hold i (E.accum i e).
accum [Note.E]
accum i e accumulates a value, starting with i, using e's functional occurrences.
app [Note.S]
app sf s holds the value of sf applied to the value of s, [app sf s]t = [sf]t [s]t.
app [Note.Logr]
app f v is the observation that result from applying the changes of f to the ones of v.

B
bind [Note.S]
bind s f is the signal that results from applying f to s, [bind s f]t = [f[s]t]t.
bind [Note.E]
bind e f is the event that results from applying f to the last event of e: [bind e f]t = [f v]t if [e]<=t = Some v., [bind e f]t = never if [e]<=t = None.

C
changes [Note.S]
changes s occurs with the value of s whenever it changes.
const [Note.S]
const v is always v, [const v]t = v.
const [Note.Logr]
const v never changes and always observes v.
create [Note.S]
create v is a primitive signal set to the value v and a set function.
create [Note.E]
create () is a primitive event e and a send function.
create [Note.Logr]
create ~now o is a logger that observes changes to o.
create [Note.Step]
create () is a new update step.

D
delay [Note.S]
delay i (lazy s) is the value s had an infinitesimal amount of time before: [delay i (lazy s)]t = i for t = 0. , [delay i (lazy s)]t = [s']t-dt otherwise.
destroy [Note.Logr]
destroy l destroys log l this ensure that l's does not observe any change again.

E
edge [Note.S.Bool]
edge s is changes s.
eq [Note.S]
eq s is s's equality function.
evict [Note.S.Option]
evict ~none s is none when s is None: [evict ~none s]t = v if [s]t = Some v, [evict ~none s]t = [none]t if [s]t = None none's equality function is used for the resulting signal.
evict [Note.E.Option]
evict ~none s is none when s is None: [evict ~none e]t = None if [e]t = None, [evict ~none e]t = v if [e]t = Some (Some v), [evict ~none e]t = [none]t if [s]t = Some None none's equality function is used for the resulting signal.
execute [Note.Step]
execute step executes the update step step.

F
fall [Note.S.Bool]
fall s is E.filter_map (function true -> None | None -> Some b) (edge s)
filter [Note.E]
filter p e are the occurences of e that satisfy p.
filter_map [Note.E]
filter_map fm e are e's occurrences filtered and mapped by fm.
fix [Note.S]
In fix sf, sf is called with a signal s that represents
fix [Note.E]
fix ef allows to refer to the value an event had an infinitesimal amount of time before.
flip [Note.S.Bool]
flip ~init e is a signal whose boolean value flips each time e occurs.
force [Note.Logr]
force l observes l even if nothing changed.

H
hold [Note.S]
hold i e has the value of e's last occurrence or the value of i provides the signal value at creation time if there's no event at that time.
hold [Note.Logr]
hold l holds logger l to ensure it does not get garbage collected.

J
join [Note.S]
join ss is bind ss (fun s -> s).
join [Note.E]
join ee is bind ee (fun e -> e).

L
l1 [Note.S]
l2 [Note.S]
log [Note.S]
log ?now s f is Logr.(create ~now (const f $ obs s)).
log [Note.E]
log ?now e f is Some (Logr.(create ?now (const f $ obs e))) if e is not Note.E.never and None otherwise.

M
map [Note.S]
map f s is s transformed by f, [map f s]t = f [s]t.
map [Note.E]
map f e applies f to e's occurrences.
may_hold [Note.Logr]
may_hold l holds logger Some l to ensure it does not get garbage collected.

N
never [Note.E]
never is a never occuring event, [never]t = None.
no [Note.S.Bool]
no is const false.
none [Note.S.Option]
none is const None.
not [Note.S.Bool]
not s is map not s.

O
obs [Note.S]
obs s is an observation for s.
obs [Note.E]
obs e is an observation for e's occurences.

R
rise [Note.S.Bool]
rise s is E.filter_map (function true -> Some b | false -> None) (edge s).

S
select [Note.E]
select el is the occurences of every event in el.
some [Note.S.Option]
some s is map (fun v -> Some v) s and uses s's equality function to derive the obvious one on options.
some [Note.E.Option]
some e is map (fun v -> Some v) e.
stamp [Note.E]
stamp v e is map (fun _ -> v) e
swap [Note.S]
swap s se is join (hold ~eq:( == ) s se) that is the values of s followed by values of the last signal that occured on se.
swap [Note.E]
swap es is the current event of es, [swap es]t = [[es]t]t.

U
unhold_all [Note.Logr]
unhold_all () destroys and unholds all loggers held via Note.Logr.hold.

V
value [Note.S]
value s is the current value of s.
value [Note.E]
value e is the value of event e at call time.

Y
yes [Note.S.Bool]
yes is const true.