reactiveData
type 'a p =
Patch operation on lists. All operations are of linear complexity.
type 'a patch = 'a p list
A patch is a list of patch operations. The operations are applied in the order they appear in the list.
The indices correspond to list contents after the operations that appear earlier in the list have been applied, not to the contents before the whole patch operation.
A patch comprised of I
, R
, and U
steps with increasing indices can be applied in time O(m + n), where m is the patch length and n is the current size of the list. (Arbitrary patches are slower, requiring O(m * n).)
include S with type 'a data = 'a list and type 'a patch := 'a patch
type 'a msg =
 Patch of 'a patch  (*

 Set of 'a data  (* With 
Message format
val empty : 'a t
Empty data structure
Build a container from initial contents. The handle can be used for performing reactive updates.
from_event d e
is a container whose initial value is d
, and which gets updated for every occurrence of e
Convert a React signal into a ReactiveData container.
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.
set h d
sets the contents of the container corresponding to h
, disregarding previous contents
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 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 pseudomessage Set l
, accounting for the contents l
of c
at the time when accumulation starts.
val cons : 'a > 'a handle > unit
Add element to the beginning
val snoc : 'a > 'a handle > unit
Add element to the end
val insert : 'a > int > 'a handle > unit
insert v i h
adds v
as the i
th position in the container corresponding to h
. The indices of the subsequent elements change.
val remove : int > 'a handle > unit
remove i h
removes the i
th position from the container corresponding to h
. The indices of the subsequent elements change.
val update : 'a > int > 'a handle > unit
update v i h
substitutes the i
th element of the container corresponding to h
with v
val move : int > int > 'a handle > unit
move i j h
moves the i
th element of the container corresponding to h
to the j
th position, modifying the indices of other elements
val singleton : 'a > 'a t
Produce container list containing a single, constant element
Produce reactive list containing a single element that gets updated based on a signal
concat a b
is the concatenation of a
and b
, and it gets updated whenever a
and b
change