val filter_mapi : ?data_equal:('v1 ‑> 'v1 ‑> bool) ‑> ('k, 'v1, 'cmp) Core_kernel.Map.t Incr.t ‑> f:(key:'k ‑> data:'v1 ‑> 'v2 option) ‑> ('k, 'v2, 'cmp) Core_kernel.Map.t Incr.tval mapi : ?data_equal:('v1 ‑> 'v1 ‑> bool) ‑> ('k, 'v1, 'cmp) Core_kernel.Map.t Incr.t ‑> f:(key:'k ‑> data:'v1 ‑> 'v2) ‑> ('k, 'v2, 'cmp) Core_kernel.Map.t Incr.tval filter_mapi' : ?cutoff:'v1 Incr.Cutoff.t ‑> ?data_equal:('v1 ‑> 'v1 ‑> bool) ‑> ('k, 'v1, 'cmp) Core_kernel.Map.t Incr.t ‑> f:(key:'k ‑> data:'v1 Incr.t ‑> 'v2 option Incr.t) ‑> ('k, 'v2, 'cmp) Core_kernel.Map.t Incr.tval mapi' : ?cutoff:'v1 Incr.Cutoff.t ‑> ?data_equal:('v1 ‑> 'v1 ‑> bool) ‑> ('k, 'v1, 'cmp) Core_kernel.Map.t Incr.t ‑> f:(key:'k ‑> data:'v1 Incr.t ‑> 'v2 Incr.t) ‑> ('k, 'v2, 'cmp) Core_kernel.Map.t Incr.tval unordered_fold : ?data_equal:('v ‑> 'v ‑> bool) ‑> ?update:(key:'k ‑> old_data:'v ‑> new_data:'v ‑> 'acc ‑> 'acc) ‑> ('k, 'v, 'cmp) Core_kernel.Map.t Incr.t ‑> init:'acc ‑> add:(key:'k ‑> data:'v ‑> 'acc ‑> 'acc) ‑> remove:(key:'k ‑> data:'v ‑> 'acc ‑> 'acc) ‑> 'acc Incr.tunordered_fold i ~init ~add ~remove constructs a more incremental version of:
let%map m = i in
Map.fold m ~init ~f:addassuming that remove is the inverse of add, and that the operations for
different keys can be performed in any order. Note that data_equal defaults
to phys_equal, but a more precise equality can be provided instead.
When the data for a key updates, by default remove is called on the old data
and then add is called on the new data.
update provides an alternative single function to call each time a key's data
updates, and can be used to improve efficiency.
val merge : ?data_equal_left:('v1 ‑> 'v1 ‑> bool) ‑> ?data_equal_right:('v2 ‑> 'v2 ‑> bool) ‑> ('k, 'v1, 'cmp) Core_kernel.Map.t Incr.t ‑> ('k, 'v2, 'cmp) Core_kernel.Map.t Incr.t ‑> f:(key:'k ‑> [ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ‑> 'v3 option) ‑> ('k, 'v3, 'cmp) Core_kernel.Map.t Incr.tLike merge in Base.Map.merge. Note that f is called at most once per key in
any given stabilization.
val flatten : ('k, 'v Incr.t, 'cmp) Core_kernel.Map.t ‑> ('k, 'v, 'cmp) Core_kernel.Map.t Incr.tThis is the "easy" version of map_join
val join : ('k, 'v Incr.t, 'cmp) Core_kernel.Map.t Incr.t ‑> ('k, 'v, 'cmp) Core_kernel.Map.t Incr.tThe non-incremental semantics of this function is the identity function. Its purpose is to collapse the extra level of incrementality at the level of the data of the map.
val subrange : ?data_equal:('v ‑> 'v ‑> bool) ‑> ('k, 'v, 'cmp) Core_kernel.Map.t Incr.t ‑> ('k * 'k) option Incr.t ‑> ('k, 'v, 'cmp) Core_kernel.Map.t Incr.tsubrange map (min, max) constructs an incremental submap that includes all of the
keys and data from map between min and max, inclusive, and none of the keys
outside the range.
subrange map None is the empty map. range being None means no elements are
chosen.
Note that incremental changes have a runtime of O((k + m) log n) where k is the size of the changes to the underlying map and m is the size of the changes to the elements contained by the range. The complexity of the initial computation is the same as the incremental computation, with some simplification. k = 0 because we have not made any changes to the underlying map yet, and m equals the size of the range, because the initial range is empty.
module Lookup : sig ... end('k, 'v) Lookup.t provides a way to lookup keys in a map which uses symmetric
diffs to trigger updates of the lookups.