package base

  1. Overview
  2. Docs
package base
Legend:
Library
Module
Module type
Parameter
Class
Class type
type ('key, 'data) t
type ('fn, 'key, 'data) accessor
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 clear : (_, _) t -> unit

Removes all key/value pairs from the dictionary.

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

A new dictionary containing the same key/value pairs.

val mem : (('key, 'data) 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 find_or_add : (('key, 'data) t -> 'key -> default:(unit -> 'data) -> 'data, 'key, 'data) accessor

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

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

Like find. Adds default key if no value exists.

val find_and_call : (('key, 'data) t -> 'key -> if_found:('data -> 'c) -> if_not_found:('key -> 'c) -> 'c, 'key, 'data) 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) t -> 'key -> if_found:(key:'key -> data:'data -> 'c) -> if_not_found:('key -> 'c) -> 'c, 'key, 'data) accessor

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

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

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

val add : (('key, 'data) t -> key:'key -> data:'data -> [ `Ok | `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 -> unit, 'key, 'data) accessor

Like add. Raises on duplicates.

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

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

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

Removes any value for the given key.

val change : (('key, 'data) t -> 'key -> f:('data option -> 'data option) -> unit, '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) -> unit, 'key, 'data) accessor

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

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

Like update. Returns the new value.

val incr : (?by:int -> ?remove_if_zero:bool -> ('key, int) t -> 'key -> unit, 'key, 'data) 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) t -> 'key -> unit, 'key, 'data) 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) t -> key:'key -> data:'data -> unit, '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, _ list) t -> 'key -> unit, '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 for_all : (_, '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 : (_, '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 : (_, '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 choose : ('key, 'data) t -> ('key * 'data) option

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

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

Like choose. Raises if empty.

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

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

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

Like choose_randomly. 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, 'data) t -> f:('data -> 'c) -> ('key, 'c) t

Transforms every value.

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

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

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

Like map. Modifies the input.

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

Like mapi. Modifies the input.

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_keys_inplace : ('key, _) t -> f:('key -> bool) -> unit

Like filter_keys. Modifies the input.

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

Like filter. Modifies the input.

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

Like filteri. Modifies the input.

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

Produces key/value pairs for which f produces Some.

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

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

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

Like filter_map. Modifies the input.

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

Like filter_mapi. Modifies the input.

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, 'data) t -> f:('data -> ('c, 'd) Either.t) -> ('key, 'c) t * ('key, 'd) t

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

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

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

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, 'data3) 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) t -> dst:('key, 'data2) t -> f:(key:'key -> 'data1 -> 'data2 option -> 'data2 Merge_into_action.t) -> unit, 'key, 'data) 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.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events Blog Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct