Previous  Up  Next

Module type Core_hashtbl_intf.Accessors

module type Accessors = sig .. end
type ('a, 'b) t 
type 'a key 
val sexp_of_key : ('a, 'b) t ->
       'a key -> Sexplib.Sexp.t
val clear : ('a, 'b) t -> unit
val copy : ('a, 'b) t ->
       ('a, 'b) t
val invariant : ('a, 'b) t -> unit
val fold : ('a, 'b) t ->
       init:'c ->
       f:(key:'a key -> data:'b -> 'c -> 'c) -> 'c
val iter : ('a, 'b) t ->
       f:(key:'a key -> data:'b -> unit) -> unit
val existsi : ('a, 'b) t ->
       f:(key:'a key -> data:'b -> bool) -> bool
val exists : ('a, 'b) t -> f:('b -> bool) -> bool
val length : ('a, 'b) t -> int
val is_empty : ('a, 'b) t -> bool
val mem : ('a, 'b) t ->
       'a key -> bool
val remove : ('a, 'b) t ->
       'a key -> unit
val remove_one : ('a, 'b list) t ->
       'a key -> unit
val replace : ('a, 'b) t ->
       key:'a key -> data:'b -> unit
val set : ('a, 'b) t ->
       key:'a key -> data:'b -> unit
val add : ('a, 'b) t ->
       key:'a key -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t ->
       key:'a key -> data:'b -> unit
val change : ('a, 'b) t ->
       'a key -> ('b option -> 'b option) -> unit
change t key f updates the given table by changing the value stored under key according to f, just like Map.change (see that for example).
val add_multi : ('a, 'b list) t ->
       key:'a key -> data:'b -> unit
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.
val remove_multi : ('a, 'b list) t ->
       'a key -> unit
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.
val map : ('a, 'b) t ->
       f:('b -> 'c) -> ('a, 'c) t
map t f returns new table with bound values replaced by f applied to the bound values
val mapi : ('a, 'b) t ->
       f:(key:'a key -> data:'b -> 'c) ->
       ('a, 'c) t
like map, but function takes both key and data as arguments
val filter_map : ('a, 'b) t ->
       f:('b -> 'c option) -> ('a, 'c) t
returns new map with bound values filtered by f applied to the bound values
val filter_mapi : ('a, 'b) t ->
       f:(key:'a key -> data:'b -> 'c option) ->
       ('a, 'c) t
like filter_map, but function takes both key and data as arguments
val filter : ('a, 'b) t ->
       f:('b -> bool) -> ('a, 'b) t
val filteri : ('a, 'b) t ->
       f:(key:'a key -> data:'b -> bool) ->
       ('a, 'b) t
val partition_map : ('a, 'b) t ->
       f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
       ('a, 'c) t *
       ('a, 'd) t
returns new maps with bound values partitioned by f applied to the bound values
val partition_mapi : ('a, 'b) t ->
       f:(key:'a key ->
          data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
       ('a, 'c) t *
       ('a, 'd) t
like partition_map, but function takes both key and data as arguments
val partition_tf : ('a, 'b) t ->
       f:('b -> bool) ->
       ('a, 'b) t *
       ('a, 'b) t
val partitioni_tf : ('a, 'b) t ->
       f:(key:'a key -> data:'b -> bool) ->
       ('a, 'b) t *
       ('a, 'b) t
val find_or_add : ('a, 'b) t ->
       'a key -> default:(unit -> 'b) -> 'b
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.
val find : ('a, 'b) t ->
       'a key -> 'b option
find t k returns Some (the current binding) of k in t, or None if no such binding exists
val find_exn : ('a, 'b) t ->
       'a key -> 'b
find_exn t k returns the current binding of k in t, or raises Not_found if no such binding exists.
val iter_vals : ('a, 'b) t -> f:('b -> unit) -> unit
iter_vals t ~f is like iter, except it only supplies the value to f, not the key.
val merge : ('k, 'a) t ->
       ('k, 'b) t ->
       f:(key:'k key ->
          [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
       ('k, 'c) t
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) =

Each key k is mapped to a single piece of data x, where d(k) = Some x.
val merge_into : f:(key:'a key -> 'b -> 'b option -> 'b option) ->
       src:('a, 'b) t ->
       dst:('a, 'b) t -> unit
Merge one hashtable into another.

After merge_into f src dst, for every key in src, key will be re-mapped in dst to v if f ~key d1 (find dst key) = Some v.

val keys : ('a, 'b) t ->
       'a key list
Returns the list of all keys for given hashtable.

Returns the list of all data for given hashtable.

val data : ('a, 'b) t -> 'b list
filter_inplace t ~f removes all the elements from t that don't satisfy f.
val filter_inplace : ('a, 'b) t -> f:('b -> bool) -> unit
val filteri_inplace : ('a, 'b) t ->
       f:('a key -> 'b -> bool) -> unit
val equal : ('a, 'b) t ->
       ('a, 'b) t -> ('b -> 'b -> bool) -> bool
val to_alist : ('a, 'b) t ->
       ('a key * 'b) list
Returns the list of all (key,data) pairs for given hashtable.
val incr : ?by:int ->
       ('a, int) t ->
       'a key -> unit