Accessors (docs.findlib-1.base.Base.Dictionary

type 'key key

The type of keys. This will be 'key for polymorphic dictionaries, or some fixed type for dictionaries with monomorphic keys.

type ('key, 'data, 'phantom) t

Dictionaries. Their keys have type 'key key. Each key's associated value has type 'data. The dictionary may be distinguished by a 'phantom type.

type ('fn, 'key, 'data, 'phantom) accessor

The type of accessor functions 'fn that operate on ('key, 'data, 'phantom) t. May take extra arguments before 'fn, such as a comparison function.

val is_empty : (_, _, 'phantom) t -> bool

Whether the dictionary is empty.

val length : (_, _, 'phantom) t -> int

How many key/value pairs the dictionary contains.

val to_alist : ('key, 'data, 'phantom) t -> ('key key * 'data) list

All key/value pairs.

val keys : ('key, _, 'phantom) t -> 'key key list

All keys in the dictionary, in the same order as to_alist.

val data : (_, 'data, 'phantom) t -> 'data list

All values in the dictionary, in the same order as to_alist.

val clear : (_, _, 'phantom) t -> unit

Removes all key/value pairs from the dictionary.

val copy : ('key, 'data, 'phantom) t -> ('key, 'data, 'phantom) t

A new dictionary containing the same key/value pairs.

val mem : 
  (('key, 'data, 'phantom) t -> 'key key -> bool, 'key, 'data, 'phantom)
    accessor

Whether key has a value.

val find : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    'data option,
    'key,
    'data,
    'phantom)
    accessor

Produces the current value, or absence thereof, for a given key.

val find_exn : 
  (('key, 'data, 'phantom) t -> 'key key -> 'data, 'key, 'data, 'phantom)
    accessor

Like find. Raises if there is no value for the given key.

val find_or_add : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    default:(unit -> 'data) ->
    'data,
    'key,
    'data,
    'phantom)
    accessor

Like find. Adds the value default () if none exists, then returns it.

val findi_or_add : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    default:('key key -> 'data) ->
    'data,
    'key,
    'data,
    'phantom)
    accessor

Like find. Adds default key if no value exists.

val find_and_call : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    if_found:('data -> 'c) ->
    if_not_found:('key key -> 'c) ->
    'c,
    'key,
    'data,
    'phantom)
    accessor

Like find. Calls if_found data if a value exists, or if_not_found key otherwise. Avoids allocation Some.

val findi_and_call : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    if_found:(key:'key key -> data:'data -> 'c) ->
    if_not_found:('key key -> 'c) ->
    'c,
    'key,
    'data,
    'phantom)
    accessor

Like findi. Calls if_found ~key ~data if a value exists.

val find_and_remove : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    'data option,
    'key,
    'data,
    'phantom)
    accessor

Like find. Removes the value for key, if any, from the dictionary before returning it.

val add : 
  (('key, 'data, 'phantom) t ->
    key:'key key ->
    data:'data ->
    [ `Ok | `Duplicate ],
    'key,
    'data,
    'phantom)
    accessor

Adds a key/value pair for a key the dictionary does not contain, or reports a duplicate.

val add_exn : 
  (('key, 'data, 'phantom) t ->
    key:'key key ->
    data:'data ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Like add. Raises on duplicates.

val set : 
  (('key, 'data, 'phantom) t ->
    key:'key key ->
    data:'data ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Adds or replaces a key/value pair in the dictionary.

val remove : 
  (('key, 'data, 'phantom) t -> 'key key -> unit, 'key, 'data, 'phantom)
    accessor

Removes any value for the given key.

val change : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    f:('data option -> 'data option) ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Adds, replaces, or removes the value for a given key, depending on its current value or lack thereof.

val update : 
  (('key, 'data, 'phantom) t ->
    'key key ->
    f:('data option -> 'data) ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Adds or replaces the value for a given key, depending on its current value or lack thereof.

val update_and_return : 
  ('key, 'data, 'phantom) t ->
  'key key ->
  f:('data option -> 'data) ->
  'data

Like update. Returns the new value.

val incr : 
  (?by:int ->
    ?remove_if_zero:bool ->
    ('key, int, 'phantom) t ->
    'key key ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Adds by to the value for key, default 0 if key is absent. May remove key if the result is 0, depending on remove_if_zero.

val decr : 
  (?by:int ->
    ?remove_if_zero:bool ->
    ('key, int, 'phantom) t ->
    'key key ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Subtracts by from the value for key, default 0 if key is absent. May remove key if the result is 0, depending on remove_if_zero.

val add_multi : 
  (('key, 'data list, 'phantom) t ->
    key:'key key ->
    data:'data ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Adds data to the existing key/value pair for key. Interprets a missing key as having an empty list.

val remove_multi : 
  (('key, _ list, 'phantom) t -> 'key key -> unit, 'key, 'data, 'phantom)
    accessor

Removes one element from the existing key/value pair for key. Removes the key entirely if the new list is empty.

val find_multi : 
  (('key, 'data list, 'phantom) t ->
    'key key ->
    'data list,
    'key,
    'data,
    'phantom)
    accessor

Produces the list associated with the corresponding key. Interprets a missing key as having an empty list.

val fold : 
  ('key, 'data, 'phantom) t ->
  init:'acc ->
  f:(key:'key key -> data:'data -> 'acc -> 'acc) ->
  'acc

Combines every value in the dictionary.

val for_all : (_, 'data, 'phantom) t -> f:('data -> bool) -> bool

Whether every value satisfies f.

val for_alli : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> bool) ->
  bool

Like for_all. The predicate may also depend on the associated key.

val exists : (_, 'data, 'phantom) t -> f:('data -> bool) -> bool

Whether at least one value satisfies f.

val existsi : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> bool) ->
  bool

Like exists. The predicate may also depend on the associated key.

val count : (_, 'data, 'phantom) t -> f:('data -> bool) -> int

How many values satisfy f.

val counti : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> bool) ->
  int

Like count. The predicate may also depend on the associated key.

val choose : ('key, 'data, 'phantom) t -> ('key key * 'data) option

Arbitrary, deterministic key/value pair if non-empty.

val choose_exn : ('key, 'data, 'phantom) t -> 'key key * 'data

Like choose. Raises if empty.

val choose_randomly : 
  ?random_state:Random.State.t ->
  ('key, 'data, 'phantom) t ->
  ('key key * 'data) option

Arbitrary, pseudo-random key/value pair if non-empty.

val choose_randomly_exn : 
  ?random_state:Random.State.t ->
  ('key, 'data, 'phantom) t ->
  'key key * 'data

Like choose_randomly. Raises if empty.

val iter_keys : ('key, _, 'phantom) t -> f:('key key -> unit) -> unit

Calls f for every key.

val iter : (_, 'data, 'phantom) t -> f:('data -> unit) -> unit

Calls f for every value.

val iteri : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> unit) ->
  unit

Calls f for every key/value pair.

val map : 
  ('key, 'data, 'phantom) t ->
  f:('data -> 'c) ->
  ('key, 'c, 'phantom) t

Transforms every value.

val mapi : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> 'c) ->
  ('key, 'c, 'phantom) t

Like map. The transformation may also depend on the associated key.

val map_inplace : (_, 'data, 'phantom) t -> f:('data -> 'data) -> unit

Like map. Modifies the input.

val mapi_inplace : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> 'data) ->
  unit

Like mapi. Modifies the input.

val filter_keys : 
  ('key, 'data, 'phantom) t ->
  f:('key key -> bool) ->
  ('key, 'data, 'phantom) t

Produces only those key/value pairs whose key satisfies f.

val filter : 
  ('key, 'data, 'phantom) t ->
  f:('data -> bool) ->
  ('key, 'data, 'phantom) t

Produces only those key/value pairs whose value satisfies f.

val filteri : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> bool) ->
  ('key, 'data, 'phantom) t

Produces only those key/value pairs which satisfy f.

val filter_keys_inplace : ('key, _, 'phantom) t -> f:('key key -> bool) -> unit

Like filter_keys. Modifies the input.

val filter_inplace : (_, 'data, 'phantom) t -> f:('data -> bool) -> unit

Like filter. Modifies the input.

val filteri_inplace : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> bool) ->
  unit

Like filteri. Modifies the input.

val filter_map : 
  ('key, 'data, 'phantom) t ->
  f:('data -> 'c option) ->
  ('key, 'c, 'phantom) t

Produces key/value pairs for which f produces Some.

val filter_mapi : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> 'c option) ->
  ('key, 'c, 'phantom) t

Like filter_map. The new value may also depend on the associated key.

val filter_map_inplace : 
  (_, 'data, 'phantom) t ->
  f:('data -> 'data option) ->
  unit

Like filter_map. Modifies the input.

val filter_mapi_inplace : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> 'data option) ->
  unit

Like filter_mapi. Modifies the input.

val partition_tf : 
  ('key, 'data, 'phantom) t ->
  f:('data -> bool) ->
  ('key, 'data, 'phantom) t * ('key, 'data, 'phantom) t

Splits one dictionary into two. The first contains key/value pairs for which the value satisfies f. The second contains the remainder.

val partitioni_tf : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> bool) ->
  ('key, 'data, 'phantom) t * ('key, 'data, 'phantom) t

Like partition_tf. The predicate may also depend on the associated key.

val partition_map : 
  ('key, 'data, 'phantom) t ->
  f:('data -> ('c, 'd) Either.t) ->
  ('key, 'c, 'phantom) t * ('key, 'd, 'phantom) t

Splits one dictionary into two, corresponding respectively to First _ and Second _ results from f.

val partition_mapi : 
  ('key, 'data, 'phantom) t ->
  f:(key:'key key -> data:'data -> ('c, 'd) Either.t) ->
  ('key, 'c, 'phantom) t * ('key, 'd, 'phantom) t

Like partition_map. The split may also depend on the associated key.

val merge : 
  (('key, 'data1, 'phantom) t ->
    ('key, 'data2, 'phantom) t ->
    f:
      (key:'key key ->
        [ `Left of 'data1 | `Right of 'data2 | `Both of 'data1 * 'data2 ] ->
        'data3 option) ->
    ('key, 'data3, 'phantom) t,
    'key,
    'data3,
    'phantom)
    accessor

Merges two dictionaries by fully traversing both. Not suitable for efficiently merging lists of dictionaries. See merge_into instead.

val merge_into : 
  (src:('key, 'data1, 'phantom) t ->
    dst:('key, 'data2, 'phantom) t ->
    f:(key:'key key -> 'data1 -> 'data2 option -> 'data2 Merge_into_action.t) ->
    unit,
    'key,
    'data,
    'phantom)
    accessor

Merges two dictionaries by traversing src and adding to dst. Computes the effect on dst of each key/value pair in src using f.