Index of values

c >>= f is an alternative notation for bind c f.

b >>= f is an alternative notation for bind b f.

bind c f behaves as f applied to the value of c.

bind b f behaves as f applied to the value of b.

blift c ?eq f is equivalent to bind c (fun v -> return ?eq (f v)), but is slightly more efficient.

blift b ?eq f is equivalent to bind b (fun v -> return ?eq (f v)), but is slightly more efficient.

Cancels a listener registration using the given handle.

catch cf f behaves the same as cf() if cf() succeeds.

catch bf f behaves the same as bf() if bf() succeeds.

catch_lift cf ?eq f is equivalent to catch cf (fun e -> return ?eq (f e)), but is slightly more efficient.

catch_lift bf ?eq f is equivalent to catch bf (fun e -> return ?eq (f e)), but is slightly more efficient.

changeable v is a changeable with initial value v.

changes b occurs with the value of b whenever b changes.

cleanup f attaches f to the enclosing dynamic scope, so it is called when the scope is cleaned up.

collect f b e is an event that maintains an internal state s (initialized to b); whenever e fires v, s' becomes f s v, the event fires s', and s' becomes the new internal state.

count e takes on the number of times e has occurred (since count was called).

fail e is a constant changeable that fails with the exception e.

fail e is a constant behavior that fails with the exception e.

filter p e is an event that fires v whenever e fires v and p v is true.

fix_b bf returns bf b' where b' behaves like bf b', but delayed one update cycle.

fix_e ef returns ef e' where e' is an event that occurs whenever ef e' occurs, but in the next update cycle.

A hash function for changeables,

A hash function for behaviors.

A hash function for events.

hold v e takes on the last value which occurred on e, or v if e has not yet occurred (since hold was called).

Same as hold but initialized with a result.

Initialize the library; can be called again to reinitialize.

Initialize the library; can be called again to reinitialize.

join_b b behaves as whichever behavior is currently the value of b.

join_e ee occurs whenever the event which last occurred on ee occurs.

lift ?eq f c is equivalent to blift c ?eq f; it can be partially applied to lift a function to the monad without yet binding it to a changeable.

lift ?eq f b is equivalent to blift b ?eq f; it can be partially applied to lift a function to the monad without yet binding it to a behavior.

make_cell v returns a behavior (with initial value v) and a setter function which changes the behavior's value.

Makes a new event taking values of type 'a.

map f e fires f v whenever e fires v.

map2 f e1 e2 fires f v1 v2 whenever e1 and e2 fire v1 and v2 simultaneously.

memo f creates a memo function f' from f.

memo f creates a memo function f' from f.

merge es occurs whenever any of the events in es occurs.

An event which never occurs.

next e passes on only the next occurence of e; subsequent occurrences are dropped.

Dummy cancel.

notify_b b f adds f as a listener for b, which is called whenever b changes.

Same as notify_b, and returns a cancel handle (the notification is still cancelled when the enclosing dynamic scope is cleaned up).

notify_e e f adds f as a listener for e, which is called with v whenever e occurs with value v.

Same as notify_e, and returns a cancel handle (the notification is still cancelled when the enclosing dynamic scope is cleaned up).

Same as notify_b but the listener is called with a result when the value changes or when the behavior fails.

Same as notify_result_b, and returns a cancel handle (the notification is still cancelled when the enclosing dynamic scope is cleaned up).

Same as notify_e but the listener is called with a result when a value or a failure is sent.

Same as notify_result_e, and returns a cancel handle (the notification is still cancelled when the enclosing dynamic scope is cleaned up).

Process any outstanding changes so all changeables are consistent.

read c returns the value of c, or raises an exception if c fails.

return v is a constant changeable with value v.

return v is a constant behavior with value v.

sample b returns the current value of b, or raises b's exception if it is failed.

Same as sample but returns a result.

send s v sends the value v to the associated event e, so e occurs with value v.

send_deferred s v enqueues a call to send s v for a future update cycle.

send_exn s x sends the failure x to the associated event e, so e occurs with failure x.

send_exn_deferred s x enqueues a call to send_exn s x for a future update cycle.

send_result s r sends the result r to the associated event e, so e occurs with result r.

send_result_deferred s r enqueues a call to send_result s r for a future update cycle.

Set a function for showing library debugging.

Set a function for showing library debugging.

Set an exception handler which is called on exceptions from listeners.

switch b e behaves as b until e occurs, then behaves as the last value of e.

try_bind cf f g behaves as bind (cf()) f if cf() succeeds.

try_bind bf f g behaves as bind (bf()) f if bf() succeeds.

try_bind_lift cf ?eq f g is equivalent to try_bind cf (fun v -> return ?eq (f v)) (fun e -> return ?eq (g e)), but is slightly more efficient.

try_bind_lift bf ?eq f g is equivalent to try_bind bf (fun v -> return ?eq (f v)) (fun e -> return ?eq (g e)), but is slightly more efficient.

until b e behaves as b until e occurs with value b', then behaves as b'.

when_true b fires whenever b becomes true.

write w v updates the value of the associated changeable c.

write_exn w e updates the associated changeable c to fail with exception e.