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

type ('key, 'data) t

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

type ('fn, 'key, 'data) creator

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

Whether the dictionary is empty.

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

How many key/value pairs the dictionary contains.

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

All key/value pairs.

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

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

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

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

val to_sequence : ('key, 'data) t -> ('key * 'data) Sequence.t

Like to_alist. Produces a sequence.

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

Whether key has a value.

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

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

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

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

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

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

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

Like add. Raises on duplicates.

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

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

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

Removes any value for the given key.

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

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

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

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

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

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

val remove_multi : 
  (('key, 'data list) t -> 'key -> ('key, 'data list) t, 'key, 'data) 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) t -> 'key -> 'data list, 'key, 'data) accessor

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

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

Combines every value in the dictionary.

val fold_until : 
  ('key, 'data) t ->
  init:'acc ->
  f:
    (key:'key ->
      data:'data ->
      'acc ->
      ('acc, 'final) Container.Continue_or_stop.t) ->
  finish:('acc -> 'final) ->
  'final

Like fold. May stop before completing the iteration.

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

Whether every value satisfies f.

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

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

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

Whether at least one value satisfies f.

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

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

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

How many values satisfy f.

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

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

val sum : 
  (module Container.Summable with type t = 'a) ->
  ('key, 'data) t ->
  f:('data -> 'a) ->
  'a

Sum up f data for all data in the dictionary.

val sumi : 
  (module Container.Summable with type t = 'a) ->
  ('key, 'data) t ->
  f:(key:'key -> data:'data -> 'a) ->
  'a

Like sum. The function may also depend on the associated key.

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

Produces the key/value pair with the smallest key if non-empty.

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

Like min_elt. Raises if empty.

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

Produces the key/value pair with the largest key if non-empty.

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

Like max_elt. Raises if empty.

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

Calls f for every key.

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

Calls f for every value.

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

Calls f for every key/value pair.

val map : ('key, 'data1) t -> f:('data1 -> 'data2) -> ('key, 'data2) t

Transforms every value.

val mapi : 
  ('key, 'data1) t ->
  f:(key:'key -> data:'data1 -> 'data2) ->
  ('key, 'data2) t

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

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

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

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

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

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

Produces only those key/value pairs which satisfy f.

val filter_map : 
  ('key, 'data1) t ->
  f:('data1 -> 'data2 option) ->
  ('key, 'data2) t

Produces key/value pairs for which f produces Some.

val filter_mapi : 
  ('key, 'data1) t ->
  f:(key:'key -> data:'data1 -> 'data2 option) ->
  ('key, 'data2) t

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

val partition_tf : 
  ('key, 'data) t ->
  f:('data -> bool) ->
  ('key, 'data) t * ('key, 'data) 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) t ->
  f:(key:'key -> data:'data -> bool) ->
  ('key, 'data) t * ('key, 'data) t

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

val partition_map : 
  ('key, 'data1) t ->
  f:('data1 -> ('data2, 'data3) Either.t) ->
  ('key, 'data2) t * ('key, 'data3) t

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

val partition_mapi : 
  ('key, 'data1) t ->
  f:(key:'key -> data:'data1 -> ('data2, 'data3) Either.t) ->
  ('key, 'data2) t * ('key, 'data3) t

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

val combine_errors : 
  (('key, 'data Or_error.t) t -> ('key, 'data) t Or_error.t, 'key, 'data)
    accessor

Produces an error combining all error messages from key/value pairs, or a dictionary of all Ok values if none are Error.

val unzip : ('key, 'data1 * 'data2) t -> ('key, 'data1) t * ('key, 'data2) t

Splits the fst and snd components of values associated with keys into separate dictionaries.

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

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

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

Merges two dictionaries with the same type of data and disjoint sets of keys. Raises if any keys overlap.

val merge_skewed : 
  (('key, 'data) t ->
    ('key, 'data) t ->
    combine:(key:'key -> 'data -> 'data -> 'data) ->
    ('key, 'data) t,
    'key,
    'data)
    accessor

Merges two dictionaries by traversing only the smaller of the two. Adds key/value pairs missing from the larger dictionary, and combines duplicate values.

val symmetric_diff : 
  (('key, 'data) t ->
    ('key, 'data) t ->
    data_equal:('data -> 'data -> bool) ->
    ('key * [ `Left of 'data | `Right of 'data | `Unequal of 'data * 'data ])
      Sequence.t,
    'key,
    'data)
    accessor

Computes a sequence of differences between two dictionaries.

val fold_symmetric_diff : 
  (('key, 'data) t ->
    ('key, 'data) t ->
    data_equal:('data -> 'data -> bool) ->
    init:'acc ->
    f:
      ('acc ->
        ('key
         * [ `Left of 'data | `Right of 'data | `Unequal of 'data * 'data ]) ->
        'acc) ->
    'acc,
    'key,
    'data)
    accessor

Folds over the result of symmetric_diff. May be more performant.

val empty : (('key, 'data) t, 'key, 'data) creator

The empty dictionary.

val singleton : ('key -> 'data -> ('key, 'data) t, 'key, 'data) creator

Dictionary with a single key/value pair.

val of_alist : 
  (('key * 'data) list ->
    [ `Ok of ('key, 'data) t | `Duplicate_key of 'key ],
    'key,
    'data)
    creator

Dictionary containing the given key/value pairs. Fails if there are duplicate keys.

val of_alist_or_error : 
  (('key * 'data) list -> ('key, 'data) t Or_error.t, 'key, 'data) creator

Like of_alist. Returns a Result.t.

val of_alist_exn : 
  (('key * 'data) list -> ('key, 'data) t, 'key, 'data) creator

Like of_alist. Raises on duplicates.

val of_alist_multi : 
  (('key * 'data) list -> ('key, 'data list) t, 'key, 'data) creator

Produces a dictionary mapping each key to a list of associated values.

val of_alist_fold : 
  (('key * 'data) list ->
    init:'acc ->
    f:('acc -> 'data -> 'acc) ->
    ('key, 'acc) t,
    'key,
    'data)
    creator

Produces a dictionary using each key/value pair. Combines all values for a given key with init using f.

val of_alist_reduce : 
  (('key * 'data) list ->
    f:('data -> 'data -> 'data) ->
    ('key, 'data) t,
    'key,
    'data)
    creator

Produces a dictionary using each key/value pair. Combines multiple values for a given key using f.

val of_sequence : 
  (('key * 'data) Sequence.t ->
    [ `Ok of ('key, 'data) t | `Duplicate_key of 'key ],
    'key,
    'data)
    creator

Like of_alist. Consumes a sequence.

val of_sequence_or_error : 
  (('key * 'data) Sequence.t -> ('key, 'data) t Or_error.t, 'key, 'data)
    creator

Like of_alist_or_error. Consumes a sequence.

val of_sequence_exn : 
  (('key * 'data) Sequence.t -> ('key, 'data) t, 'key, 'data) creator

Like of_alist_exn. Consumes a sequence.

val of_sequence_multi : 
  (('key * 'data) Sequence.t -> ('key, 'data list) t, 'key, 'data) creator

Like of_alist_multi. Consumes a sequence.

val of_sequence_fold : 
  (('key * 'data) Sequence.t ->
    init:'c ->
    f:('c -> 'data -> 'c) ->
    ('key, 'c) t,
    'key,
    'data)
    creator

Like of_alist_fold. Consumes a sequence.

val of_sequence_reduce : 
  (('key * 'data) Sequence.t ->
    f:('data -> 'data -> 'data) ->
    ('key, 'data) t,
    'key,
    'data)
    creator

Like of_alist_reduce. Consumes a sequence.

val of_list_with_key : 
  ('data list ->
    get_key:('data -> 'key) ->
    [ `Ok of ('key, 'data) t | `Duplicate_key of 'key ],
    'key,
    'data)
    creator

Like of_alist. Consume values for which keys can be computed.

val of_list_with_key_or_error : 
  ('data list ->
    get_key:('data -> 'key) ->
    ('key, 'data) t Or_error.t,
    'key,
    'data)
    creator

Like of_alist_or_error. Consume values for which keys can be computed.

val of_list_with_key_exn : 
  ('data list -> get_key:('data -> 'key) -> ('key, 'data) t, 'key, 'data)
    creator

Like of_alist_exn. Consume values for which keys can be computed.

val of_list_with_key_multi : 
  ('data list -> get_key:('data -> 'key) -> ('key, 'data list) t, 'key, 'data)
    creator

Like of_alist_multi. Consume values for which keys can be computed.

val of_iteri : 
  (iteri:(f:(key:'key -> data:'data -> unit) -> unit) ->
    [ `Ok of ('key, 'data) t | `Duplicate_key of 'key ],
    'key,
    'data)
    creator

Produces a dictionary of all key/value pairs that iteri passes to ~f. Fails if a duplicate key is found.

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

Like of_iteri. Raises on duplicate key.