module RMap:functor (
M
:
Map.S
) ->
S
with type 'a data = 'a M.t and type 'a patch = [ `Add of M.key * 'a | `Del of M.key ] list
Parameters: |
|
type 'a
t
type 'a
data
type 'a
patch
type 'a
msg =
| |
Patch of |
(* | Patch p triggers the application of p
on the current contents | *) |
| |
Set of |
(* |
With
Set d , d becomes the new
content | *) |
type 'a
handle
val empty : 'a t
val create : 'a data -> 'a t * 'a handle
val from_event : 'a data ->
'a msg React.E.t -> 'a t
from_event d e
is a container whose initial value is d
, and
which gets updated for every occurrence of e
val from_signal : ?eq:('a -> 'a -> bool) ->
'a data React.S.t -> 'a t
Whenever the signal changes from value v
to value v'
, we
detect the differences between v
and v'
, and perform
downstream computation (e.g., for map
) only on the new and
modified elements.
val const : 'a data -> 'a t
val patch : 'a handle -> 'a patch -> unit
patch h p
applies p
on the container corresponding to h
val set : 'a handle -> 'a data -> unit
set h d
sets the contents of the container corresponding to
h
, disregarding previous contentsval map_msg : ('a -> 'b) -> 'a msg -> 'b msg
val map : ('a -> 'b) -> 'a t -> 'b t
map f c
applies f
on all elements of c
, producing a new
reactive container c'
. Modifying the contents of c
leads to
modifications of c'
. f
is applied only on the new or
modified elements of c
.val value : 'a t -> 'a data
val fold : ('a -> 'b msg -> 'a) ->
'b t -> 'a -> 'a React.signal
fold f c v
accumulates the updates on c
with f
starting
from v
.
The result is a signal of value f m_n (f ... (f m_1 v))
, where
m_1
... m_n
are the messages that have been applied since
the beginning of fold
. m_1
is a pseudo-message Set l
,
accounting for the contents l
of c
at the time when
accumulation starts.
val signal : ?eq:('a -> 'a -> bool) ->
'a t -> 'a data React.S.t
val event : 'a t -> 'a msg React.E.t