Module Lwt_signal


module Lwt_signal: sig .. end
Signals utilities


Monadic interface

val return : 'a -> 'a React.signal
Same as React.S.const
val bind : 'a React.signal -> ('a -> 'b React.signal) -> 'b React.signal
bind signal f is initially f x where x is the current value of signal. Each time signal changes to a new value y, bind signal f is set to f y, until the next change of signal.

Lwt-specific utilities

val with_finaliser : (unit -> unit) -> 'a React.signal -> 'a React.signal
with_finaliser f signal returns a signal signal' which behave as signal, except that f is called when signal' is garbage collected.
val limit : ?eq:('a -> 'a -> bool) ->
(unit -> unit Lwt.t) -> 'a React.signal -> 'a React.signal
limit f signal limits the rate of signal update with f.

For example, to limit it to 1 per second, you can use: limit (fun () -> Lwt_unix.sleep 1.0) signal.


Threaded versions of React transformation functions


The following functions behave as their React counterpart, except that they takes functions that may yield. Also, since signals must always have a value, several functions takes an extra argument for the initial value.

The _s suffix means that calls are serialized.

val app_s : ?eq:('a -> 'a -> bool) ->
('b -> 'a Lwt.t) React.signal -> 'a -> 'b React.signal -> 'a React.signal
app_s ?eq signal_f initial signal_x
val map_s : ?eq:('a -> 'a -> bool) ->
('b -> 'a Lwt.t) -> 'a -> 'b React.signal -> 'a React.signal
map_s ?eq f initial signal
val filter_s : ?eq:('a -> 'a -> bool) ->
('a -> bool Lwt.t) -> 'a -> 'a React.signal -> 'a React.signal
filter_s ?eq f initial signal
val fmap_s : ?eq:('a -> 'a -> bool) ->
('b -> 'a option Lwt.t) -> 'a -> 'b React.signal -> 'a React.signal
fmap ?eq f initial signal
val diff_s : ('a -> 'a -> 'b Lwt.t) -> 'a React.signal -> 'b React.event
diff_s f signal
val sample_s : ('a -> 'b -> 'c Lwt.t) -> 'a React.event -> 'b React.signal -> 'c React.event
sample f event signal
val accum_s : ?eq:('a -> 'a -> bool) ->
('a -> 'a Lwt.t) React.event -> 'a -> 'a React.signal
accum ?eq event_f initial
val fold_s : ?eq:('a -> 'a -> bool) ->
('a -> 'b -> 'a Lwt.t) -> 'a -> 'b React.event -> 'a React.signal
fold ?eq f initial event
val merge_s : ?eq:('a -> 'a -> bool) ->
('a -> 'b -> 'a Lwt.t) -> 'a -> 'b React.signal list -> 'a React.signal
merge ?eq f initial signals
val l1_s : ?eq:('a -> 'a -> bool) ->
('b -> 'a Lwt.t) -> 'a -> 'b React.signal -> 'a React.signal
val l2_s : ?eq:('a -> 'a -> bool) ->
('b -> 'c -> 'a Lwt.t) ->
'a -> 'b React.signal -> 'c React.signal -> 'a React.signal
val l3_s : ?eq:('a -> 'a -> bool) ->
('b -> 'c -> 'd -> 'a Lwt.t) ->
'a ->
'b React.signal -> 'c React.signal -> 'd React.signal -> 'a React.signal
val l4_s : ?eq:('a -> 'a -> bool) ->
('b -> 'c -> 'd -> 'e -> 'a Lwt.t) ->
'a ->
'b React.signal ->
'c React.signal -> 'd React.signal -> 'e React.signal -> 'a React.signal
val l5_s : ?eq:('a -> 'a -> bool) ->
('b -> 'c -> 'd -> 'e -> 'f -> 'a Lwt.t) ->
'a ->
'b React.signal ->
'c React.signal ->
'd React.signal -> 'e React.signal -> 'f React.signal -> 'a React.signal
val l6_s : ?eq:('a -> 'a -> bool) ->
('b -> 'c -> 'd -> 'e -> 'f -> 'g -> 'a Lwt.t) ->
'a ->
'b React.signal ->
'c React.signal ->
'd React.signal ->
'e React.signal -> 'f React.signal -> 'g React.signal -> 'a React.signal
val run_s : ?eq:('a -> 'a -> bool) -> 'a -> 'a Lwt.t React.signal -> 'a React.signal

Notification

type notifier 
Type of signal notifiers
val disable : notifier -> unit
disable notif stops the corresponding signal to be monitored
val notify : ('a -> unit) -> 'a React.signal -> notifier
notify f s calls f each time the value of s change
val notify_p : ('a -> unit Lwt.t) -> 'a React.signal -> notifier
notify_p f s is the same as notify except that f x is a thread. Calls to f are made in parallel.
val notify_s : ('a -> unit Lwt.t) -> 'a React.signal -> notifier
notify_s f s is the same as notify except that f x is a thread. Calls to f are serialized.
val always_notify : ('a -> unit) -> 'a React.signal -> unit
Same as notify but does not return a notifier
val always_notify_p : ('a -> unit Lwt.t) -> 'a React.signal -> unit
Same as notify_p but does not return a notifier
val always_notify_s : ('a -> unit Lwt.t) -> 'a React.signal -> unit
Same as notify_s but does not return a notifier