package incr_map

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

package incr_map

incr_map
- Incr_map
  - For_testing
  - Instrumentation
  - Lookup
    
    For_debug
    
    M
    
    K
  - Make
    
    For_testing
    
    Incr
    
    Before_or_after
    
    Clock
    
    Cutoff
    
    Expert
    
    Dependency
    
    Node
    
    Step_result
    
    Infix
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    Node_value
    
    Observer
    
    Update
    
    Packed
    
    Scope
    
    State
    
    Stats
    
    Unordered_array_fold_update
    
    Update
    
    Var
    
    Instrumentation
    
    Lookup
    
    For_debug
    
    M
    
    K
  - S
    
    For_testing
    
    Incr
    
    Cutoff
    
    Instrumentation
    
    Lookup
    
    For_debug
    
    M
    
    K
  - S_gen
    
    For_testing
    
    Incr
    
    Cutoff
    
    Instrumentation
    
    Lookup
    
    For_debug
    
    M
    
    K
incr_map.collate
- Incr_map_collate
  - Collate
    
    Fields
    
    Direct
    
    Which_range
  - Collated
    
    Concrete
    
    Intermediate
    
    Part
    
    Key
    
    Update
    
    Diff
    
    Value
    
    For_testing
    
    Make_concrete
    
    Intermediate
    
    Part
    
    Key
    
    Update
    
    Diff
    
    Value
    
    Private
  - Compare
  - Fold
  - With_caching
    
    Range_memoize_bucket
    
    Map
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
incr_map.erase_key
- Incr_map_erase_key
  - For_testing
  - Key
    
    Map
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
    
    Stable
    
    V1

Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

module Incr : Incremental.S

Signature

include S_gen
  with type 'a Incr.t = ('a, Incr.state_witness) Incremental.t
   and type 'a Incr.Cutoff.t = 'a Incremental.Cutoff.t
   and type ('k, 'v, 'cmp) Lookup.t =
         ('k, 'v, 'cmp, Incr.state_witness) Lookup.t
  with module Incr := Incr

module Instrumentation : sig ... end

All Incr_map functions take an optional instrumentation parameter that has type Instrumentation.t. A value of this type is a record containing a function which is polymorphic over a universally-quantified type 'a. This function is passed a unit -> 'a function, which must be immediately executed, and the result of which must be returned.

val of_set : 
  ?instrumentation:Instrumentation.t ->
  ('k, 'cmp) Core.Set.t Incr.t ->
  ('k, unit, 'cmp) Core.Map.t Incr.t

val filter_mapi : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v1 -> 'v2 option) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val mapi : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v1 -> 'v2) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val filter_map : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:('v1 -> 'v2 option) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val map : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:('v1 -> 'v2) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val filter_mapi' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:'v1 Incr.Cutoff.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v1 Incr.t -> 'v2 option Incr.t) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val mapi' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:'v1 Incr.Cutoff.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v1 Incr.t -> 'v2 Incr.t) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val filter_map' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:'v1 Incr.Cutoff.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:('v1 Incr.t -> 'v2 option Incr.t) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val map' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:'v1 Incr.Cutoff.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:('v1 Incr.t -> 'v2 Incr.t) ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t

val partition_mapi : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v1 -> ('v2, 'v3) Core.Either.t) ->
  (('k, 'v2, 'cmp) Core.Map.t * ('k, 'v3, 'cmp) Core.Map.t) Incr.t

val partition_mapi' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:'v1 Incr.Cutoff.t ->
  ?data_equal:('v1 -> 'v1 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v1 Incr.t -> ('v2, 'v3) Core.Either.t Incr.t) ->
  (('k, 'v2, 'cmp) Core.Map.t * ('k, 'v3, 'cmp) Core.Map.t) Incr.t

val unordered_fold : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ?update:(key:'k -> old_data:'v -> new_data:'v -> 'acc -> 'acc) ->
  ?specialized_initial:(init:'acc -> ('k, 'v, 'cmp) Core.Map.t -> 'acc) ->
  ?finalize:('acc -> 'acc) ->
  ?revert_to_init_when_empty:bool ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  init:'acc ->
  add:(key:'k -> data:'v -> 'acc -> 'acc) ->
  remove:(key:'k -> data:'v -> 'acc -> 'acc) ->
  'acc Incr.t

val unordered_fold_with_extra : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ?extra_equal:('extra -> 'extra -> bool) ->
  ?update:(key:'k -> old_data:'v -> new_data:'v -> 'acc -> 'extra -> 'acc) ->
  ?specialized_initial:(init:'acc -> ('k, 'v, 'e) Core.Map.t -> 'extra -> 'acc) ->
  ?finalize:('acc -> 'acc) ->
  ?revert_to_init_when_empty:bool ->
  ('k, 'v, 'e) Core.Map.t Incr.t ->
  'extra Incr.t ->
  init:'acc ->
  add:(key:'k -> data:'v -> 'acc -> 'extra -> 'acc) ->
  remove:(key:'k -> data:'v -> 'acc -> 'extra -> 'acc) ->
  extra_changed:
    (old_extra:'extra ->
      new_extra:'extra ->
      input:('k, 'v, 'e) Core.Map.t ->
      'acc ->
      'acc) ->
  'acc Incr.t

val cutoff : 
  ?instrumentation:Instrumentation.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  cutoff:'v Incremental.Cutoff.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t

val mapi_count : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k1, 'v, 'cmp1) Core.Map.t Incr.t ->
  comparator:('k2, 'cmp2) Core.Comparator.Module.t ->
  f:(key:'k1 -> data:'v -> 'k2) ->
  ('k2, int, 'cmp2) Core.Map.t Incr.t

val map_count : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k1, 'v, 'cmp1) Core.Map.t Incr.t ->
  comparator:('k2, 'cmp2) Core.Comparator.Module.t ->
  f:('v -> 'k2) ->
  ('k2, int, 'cmp2) Core.Map.t Incr.t

val mapi_min : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('r, _) Core.Comparator.Module.t ->
  f:(key:'k -> data:'v -> 'r) ->
  'r option Incr.t

val mapi_max : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('r, _) Core.Comparator.Module.t ->
  f:(key:'k -> data:'v -> 'r) ->
  'r option Incr.t

val map_min : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('r, _) Core.Comparator.Module.t ->
  f:('v -> 'r) ->
  'r option Incr.t

val map_max : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('r, _) Core.Comparator.Module.t ->
  f:('v -> 'r) ->
  'r option Incr.t

val min_value : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('v, _) Core.Comparator.Module.t ->
  'v option Incr.t

val max_value : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('v, _) Core.Comparator.Module.t ->
  'v option Incr.t

val mapi_bounds : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('r, _) Core.Comparator.Module.t ->
  f:(key:'k -> data:'v -> 'r) ->
  ('r * 'r) option Incr.t

val map_bounds : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('r, _) Core.Comparator.Module.t ->
  f:('v -> 'r) ->
  ('r * 'r) option Incr.t

val value_bounds : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  comparator:('v, _) Core.Comparator.Module.t ->
  ('v * 'v) option Incr.t

val merge : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal_left:('v1 -> 'v1 -> bool) ->
  ?data_equal_right:('v2 -> 'v2 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> ('v1, 'v2) Core.Map.Merge_element.t -> 'v3 option) ->
  ('k, 'v3, 'cmp) Core.Map.t Incr.t

val merge_both_some : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal_left:('v1 -> 'v1 -> bool) ->
  ?data_equal_right:('v2 -> 'v2 -> bool) ->
  ?out_equal:('v3 -> 'v3 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> 'v1 -> 'v2 -> 'v3) ->
  ('k, 'v3, 'cmp) Core.Map.t Incr.t

val unzip : 
  ?instrumentation:Instrumentation.t ->
  ?left_result_equal:('v1 -> 'v1 -> bool) ->
  ?right_result_equal:('v2 -> 'v2 -> bool) ->
  ('k, 'v1 * 'v2, 'cmp) Core.Map.t Incr.t ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t * ('k, 'v2, 'cmp) Core.Map.t Incr.t

val unzip_mapi : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ?left_result_equal:('v1 -> 'v1 -> bool) ->
  ?right_result_equal:('v2 -> 'v2 -> bool) ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v -> 'v1 * 'v2) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t * ('k, 'v2, 'cmp) Core.Map.t Incr.t

val unzip_mapi' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:'v Incr.Cutoff.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v Incr.t -> 'v1 Incr.t * 'v2 Incr.t) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t * ('k, 'v2, 'cmp) Core.Map.t Incr.t

val merge' : 
  ?instrumentation:Instrumentation.t ->
  ?cutoff:('v1, 'v2) Core.Map.Merge_element.t Incr.Cutoff.t ->
  ?data_equal_left:('v1 -> 'v1 -> bool) ->
  ?data_equal_right:('v2 -> 'v2 -> bool) ->
  ('k, 'v1, 'cmp) Core.Map.t Incr.t ->
  ('k, 'v2, 'cmp) Core.Map.t Incr.t ->
  f:(key:'k -> ('v1, 'v2) Core.Map.Merge_element.t Incr.t -> 'v3 option Incr.t) ->
  ('k, 'v3, 'cmp) Core.Map.t Incr.t

val flatten : 
  ('k, 'v Incr.t, 'cmp) Core.Map.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t

val join : 
  ?instrumentation:Instrumentation.t ->
  ('k, 'v Incr.t, 'cmp) Core.Map.t Incr.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t

val separate : 
  ?instrumentation:Instrumentation.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  data_equal:('v -> 'v -> bool) ->
  ('k, 'v Incr.t, 'cmp) Core.Map.t Incr.t

val keys : 
  ?instrumentation:Instrumentation.t ->
  ('k, 'v, 'c) Core.Map.t Incr.t ->
  ('k, 'c) Core.Set.t Incr.t

val rank : 
  ?instrumentation:Instrumentation.t ->
  ('k, 'v, 'cmp) Base.Map.t Incr.t ->
  'k Incr.t ->
  int option Incr.t

val subrange : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  ('k Core.Maybe_bound.As_lower_bound.t * 'k Core.Maybe_bound.As_upper_bound.t)
    option
    Incr.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t

val subrange_by_rank : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t ->
  (int Core.Maybe_bound.As_lower_bound.t
   * int Core.Maybe_bound.As_upper_bound.t)
    Incr.t ->
  ('k, 'v, 'cmp) Core.Map.t Incr.t

val rekey : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k1, 'v, 'cmp1) Core.Map.t Incr.t ->
  comparator:('k2, 'cmp2) Core.Comparator.Module.t ->
  f:(key:'k1 -> data:'v -> 'k2) ->
  ('k2, 'v, 'cmp2) Core.Map.t Incr.t

val index_byi : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('inner_key, 'v, 'inner_cmp) Core.Map.t Incr.t ->
  comparator:('outer_key, 'outer_cmp) Core.Comparator.Module.t ->
  index:(key:'inner_key -> data:'v -> 'outer_key option) ->
  ('outer_key, ('inner_key, 'v, 'inner_cmp) Core.Map.t, 'outer_cmp) Core.Map.t
    Incr.t

val index_by : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('inner_key, 'v, 'inner_cmp) Core.Map.t Incr.t ->
  comparator:('outer_key, 'outer_cmp) Core.Comparator.Module.t ->
  index:('v -> 'outer_key option) ->
  ('outer_key, ('inner_key, 'v, 'inner_cmp) Core.Map.t, 'outer_cmp) Core.Map.t
    Incr.t

val unordered_fold_nested_maps : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ?revert_to_init_when_empty:bool ->
  ?update:
    (outer_key:'outer_key ->
      inner_key:'inner_key ->
      old_data:'v ->
      new_data:'v ->
      'acc ->
      'acc) ->
  ('outer_key, ('inner_key, 'v, 'inner_cmp) Core.Map.t, 'outer_cmp) Core.Map.t
    Incr.t ->
  init:'acc ->
  add:(outer_key:'outer_key -> inner_key:'inner_key -> data:'v -> 'acc -> 'acc) ->
  remove:
    (outer_key:'outer_key -> inner_key:'inner_key -> data:'v -> 'acc -> 'acc) ->
  'acc Incr.t

val transpose : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k2, 'k2_cmp) Core.Comparator.Module.t ->
  ('k1, ('k2, 'v, 'k2_cmp) Core.Map.t, 'k1_cmp) Core.Map.t Incr.t ->
  ('k2, ('k1, 'v, 'k1_cmp) Core.Map.t, 'k2_cmp) Core.Map.t Incr.t

val collapse : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('outer_key, ('inner_key, 'v, 'inner_cmp) Core.Map.t, 'outer_cmp) Core.Map.t
    Incr.t ->
  comparator:('inner_key, 'inner_cmp) Core.Comparator.Module.t ->
  ('outer_key * 'inner_key,
    'v,
    ('outer_cmp, 'inner_cmp) Core.Tuple2.comparator_witness)
    Core.Map.t
    Incr.t

val collapse_by : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('outer_key, ('inner_key, 'v, 'inner_cmp) Core.Map.t, 'outer_cmp) Core.Map.t
    Incr.t ->
  merge_keys:('outer_key -> 'inner_key -> 'combined_key) ->
  comparator:('combined_key, 'combined_cmp) Core.Comparator.Module.t ->
  ('combined_key, 'v, 'combined_cmp) Core.Map.t Incr.t

val expand : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('outer_key * 'inner_key, 'v, 'tuple_cmp) Core.Map.t Incr.t ->
  outer_comparator:('outer_key, 'outer_cmp) Core.Comparator.Module.t ->
  inner_comparator:('inner_key, 'inner_cmp) Core.Comparator.Module.t ->
  ('outer_key, ('inner_key, 'v, 'inner_cmp) Core.Map.t, 'outer_cmp) Core.Map.t
    Incr.t

val counti : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v -> bool) ->
  int Incr.t

val count : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  (_, 'v, _) Core.Map.t Incr.t ->
  f:('v -> bool) ->
  int Incr.t

val for_alli : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v -> bool) ->
  bool Incr.t

val for_all : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  (_, 'v, _) Core.Map.t Incr.t ->
  f:('v -> bool) ->
  bool Incr.t

val existsi : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  ('k, 'v, _) Core.Map.t Incr.t ->
  f:(key:'k -> data:'v -> bool) ->
  bool Incr.t

val exists : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  (_, 'v, _) Core.Map.t Incr.t ->
  f:('v -> bool) ->
  bool Incr.t

val sum : 
  ?instrumentation:Instrumentation.t ->
  ?data_equal:('v -> 'v -> bool) ->
  (_, 'v, _) Core.Map.t Incr.t ->
  (module Abstract_algebra.Commutative_group.Without_sexp with type t = 'u) ->
  f:('v -> 'u) ->
  'u Incr.t

module Lookup : sig ... end

module For_testing : sig ... end