Module Core_kernel.Int64.Table

create_mapped get_key get_data [x1,...,xn]
         = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]

create_with_key ~get_key [x1,...,xn]
         = of_alist [get_key x1, x1; ...; get_key xn, xn]

Attempting to modify (set, remove, etc.) the hashtable during iteration (fold, iter, iter_keys, iteri) will raise an exception.

add and add_exn leave the table unchanged if the key was already present.

change t key ~f changes t's value for key to be f (find t key).

update t key ~f is change t key ~f:(fun o -> Some (f o)).

map t f returns new table with bound values replaced by f applied to the bound values

like map, but function takes both key and data as arguments

returns new table with bound values filtered by f applied to the bound values

like filter_map, but function takes both key and data as arguments

returns new tables with bound values partitioned by f applied to the bound values

like partition_map, but function takes both key and data as arguments

returns a pair of tables (t1, t2), where t1 contains all the elements of the initial table which satisfy the predicate f, and t2 contains all the elements which do not satisfy f.

like partition_tf, but function takes both key and data as arguments

find_or_add t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.

find t k returns Some (the current binding) of k in t, or None if no such binding exists

find_exn t k returns the current binding of k in t, or raises Not_found if no such binding exists.

find_and_call t k ~if_found ~if_not_found

is equivalent to:

match find t k with Some v -> if_found v | None -> if_not_found k

except that it doesn't allocate the option.

find_and_remove t k returns Some (the current binding) of k in t and removes it, or None is no such binding exists

Merge two hashtables.

The result of merge f h1 h2 has as keys the set of all k in the union of the sets of keys of h1 and h2 for which d(k) is not None, where:

d(k) =

• f ~key:k (Some d1) None if k in h1 is to d1, and h2 does not map k;

• f ~key:k None (Some d2) if k in h2 is to d2, and h1 does not map k;

• f ~key:k (Some d1) (Some d2) otherwise, where k in h1 is to d1 and k in h2 is to d2.

Each key k is mapped to a single piece of data x, where d(k) = Some x.

Returns the list of all keys for given hashtable.

Returns the list of all data for given hashtable.

filter_inplace t ~f removes all the elements from t that don't satisfy f.

map_inplace t ~f applies f to all elements in t, transforming them in place

filter_map_inplace combines the effects of map_inplace and filter_inplace

equal t1 t2 f and similar t1 t2 f both return true iff t1 and t2 have the same keys and for all keys k, f (find_exn t1 k) (find_exn t2 k). equal and similar only differ in their types.

Returns the list of all (key,data) pairs for given hashtable.

remove_if_zero's default is false.

add_multi t ~key ~data if key is present in the table then cons data on the list, otherwise add key with a single element list.

remove_multi t key updates the table, removing the head of the list bound to key. If the list has only one element (or is empty) then the binding is removed.

find_multi t key returns the empty list if key is not present in the table, returns t's values for key otherwise