module Lwt_signal:Signals utilitiessig
..end
val return : 'a -> 'a React.signal
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
.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
.
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
type
notifier
val disable : notifier -> unit
disable notif
stops the corresponding signal to be
monitoredval notify : ('a -> unit) -> 'a React.signal -> notifier
notify f s
calls f
each time the value of s
changeval 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
notify
but does not return a notifierval always_notify_p : ('a -> unit Lwt.t) -> 'a React.signal -> unit
notify_p
but does not return a notifierval always_notify_s : ('a -> unit Lwt.t) -> 'a React.signal -> unit
notify_s
but does not return a notifier