Index of values

f $ v is app f v.

s0 && s1 is l2 ( && ) s1 s2.

s0 || s1 is l2 ( || ) s1 s2.

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

accum i e accumulates a value, starting with i, using e's functional occurrences.

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

app f v is the observation that result from applying the changes of f to the ones of v.

bind ~eq s f is map ~eq (fun v -> Option.bind v f) s.

bind s f is the signal that results from applying f to s, [bind s f]_t = [f[s]_t]_t.

bind e f is map (fun v -> Option.bind v f) 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.

changes s occurs with the value of s whenever it changes.

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

const v never changes and always observes v.

create v is a primitive signal set to the value v and a set function.

create () is a primitive event e and a send function.

create ~now o is a logger that observes changes to o.

create () is a new update step.

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 l destroys log l this ensure that l's does not observe any change again.

edge s is changes s.

eq f derives an equality function on options using f for testing Some _.

eq s is s's equality function.

execute step executes the update step step.

fall s is E.filter_map (function true -> None | None -> Some b) (edge s)

false' is const false.

filter p e are the occurences of e that satisfy p.

filter_map fm e are e's occurrences filtered and mapped by fm.

In fix sf, sf is called with a signal s that represents

fix ef allows to refer to the value an event had an infinitesimal amount of time before.

flip ~init e is a signal whose boolean value flips each time e occurs.

force l observes l even if nothing changed.

fst s is map fst s.

fst e is map fst e.

get s is map ~eq Option.get s.

get e is map get e.

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 l holds logger l to ensure it does not get garbage collected.

hold_value i s is the last Some _ value of s or i if there was no such value: [hold_some i s]_t = i if [s]_<t = None, [hold_some i s]_t = v if [s]_<=t = Some v Uses s's equality on Some _.

is_none s is map Option.is_none s.

is_none e is map is_none e.

is_some s is map Option.is_some s.

is_some e is map is_some e.

join ~eq oos is map ~eq Option.join oos.

join ss is bind ss (fun s -> s).

join e is map Option.join e.

join ee is bind ee (fun e -> e).

log ?now s f is Logr.(create ~now (const f $ obs s)).

log ?now e f is Some (Logr.(create ?now (const f $ obs e))) if e is not Note.E.never and None otherwise.

map ~eq f s is map ~eq Option.map s.

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

map f e is map Option.map e.

map f e applies f to e's occurrences.

may_hold l holds logger Some l to ensure it does not get garbage collected.

never is a never occuring event, [never]_t = None.

none is const None.

not s is map not s.

obs s is an observation for s.

obs e is an observation for e's occurences.

on_some e is e when Some _ occurs: [on_some e]_t = Some v if [e]_t = Some (Some v), [on_some e]_t = None otherwise.

rise s is E.filter_map (function true -> Some b | false -> None) (edge s).

rough_value s is the current value of s, but in contrast to Note.S.value it might not be exactly [s]_t.

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

sample_filter s on f is E.Option.on_some (sample s ~on f).

select el is the occurences of every event in el.

snapshot ~on s is sample (fun v _ -> v) ~on s.

snd e is map snd e.

snd e is map snd e.

some s is map (fun v -> Some v) s and uses s's equality function to derive the obvious one on options.

some e is map (fun v -> Some v) e.

stamp e v is map e (fun _ -> v)

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 es is the current event of es, [swap es]_t = [[es]_t]_t.

true' is const true.

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

until ~limit ~init ~next s is s until next occurs, after which the value s had just before (limit is false, default) or whenever next occurs (limit is true) is kept forever.

until ~limit ~next e is e's occurences until next occurs.

v s0 s1 is l2 (fun x y -> (x, y) s0 s1.

v e0 e1 pair simultaneous occurences of e0 and e1: [v e0 e1]_t = Some (v0, v1) if [e0]_t = Some v0 and [e1]_t = Some v1, [v e0 e1]_t = None otherwise.

value s ~default is default when s is None: [value s ~default]_t = v if [s]_t = Some v, [value s ~default]_t = [default]_t if [s]_t = None default's equality function is used for the resulting signal.

value s is the current value of s, [s]_t

value e default is default when e occurs with None: [value e ~default]_t = None if [e]_t = None, [value e ~default]_t = Some v if [e]_t = Some (Some v), [value e ~default]_t = [default]_t if [e]_t = Some None

value e is the value of event e at call time.

with_eq eq s is s with equality function eq.