Extra functions over hashtables.
Operations over hashtables.
This module replaces Stdlib's Hashtbl module. All functions and types are provided here.
type ('a, 'b) t = ('a, 'b) Hashtbl.tA Hashtable wth keys of type 'a and values 'b
val create : int -> ('a, 'b) tHashtbl.create n creates a new, empty hash table, with initial size n. For best results, n should be on the order of the expected number of elements that will be in the table. The table grows as needed, so n is just an initial guess.
val length : ('a, 'b) t -> intHashtbl.length tbl returns the number of bindings in tbl. Multiple bindings are counted multiply, so Hashtbl.length gives the number of times Hashtbl.iter calls its first argument.
val is_empty : ('a, 'b) t -> boolHashtbl.is_empty tbl returns true if there are no bindings in tbl, false otherwise.
val add : ('a, 'b) t -> 'a -> 'b -> unitHashtbl.add tbl x y adds a binding of x to y in table tbl. Previous bindings for x are not removed, but simply hidden. That is, after performing Hashtbl.remove tbl x, the previous binding for x, if any, is restored. (Same behavior as with association lists.)
val remove : ('a, 'b) t -> 'a -> unitHashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists. It does nothing if x is not bound in tbl.
val remove_all : ('a, 'b) t -> 'a -> unitRemove all bindings for the given key
val replace : ('a, 'b) t -> 'a -> 'b -> unitHashtbl.replace tbl x y replaces the current binding of x in tbl by a binding of x to y. If x is unbound in tbl, a binding of x to y is added to tbl. This is functionally equivalent to Hashtbl.remove tbl x followed by Hashtbl.add tbl x y.
val modify : 'a -> ('b -> 'b) -> ('a, 'b) t -> unitHashtbl.modify k f tbl replaces the first binding for k in tbl with f applied to that value.
val modify_def : 'b -> 'a -> ('b -> 'b) -> ('a, 'b) t -> unitHashtbl.modify_def v k f tbl does the same as Hashtbl.modify k f tbl but f v is inserted in tbl if k was unbound.
val modify_opt : 'a -> ('b option -> 'b option) -> ('a, 'b) t -> unitHashtbl.modify_opt k f tbl allows to remove, modify or add a binding for k in tbl. f will be called with None if k was unbound. first previous binding of k in tbl will be deleted if f returns None. Otherwise, the previous binding is replaced by the value produced by f.
val clear : ('a, 'b) t -> unitEmpty a hash table.
Return an enumeration of all the keys of a hashtable. If the key is in the Hashtable multiple times, all occurrences will be returned.
Return an enumeration of (key,value) pairs of a hashtable.
val of_list : ('a * 'b) list -> ('a, 'b) tCreate a hashtable from a list of (key,value) pairs.
val to_list : ('a, 'b) t -> ('a * 'b) listReturn the list of (key,value) pairs.
val bindings : ('a, 'b) t -> ('a * 'b) listAlias for to_list.
val find : ('a, 'b) t -> 'a -> 'bHashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
val find_all : ('a, 'b) t -> 'a -> 'b listHashtbl.find_all tbl x returns the list of all data associated with x in tbl. The current binding is returned first, then the previous bindings, in reverse order of introduction in the table.
val find_default : ('a, 'b) t -> 'a -> 'b -> 'bFind a binding for the key, and return a default value if not found
val find_option : ('a, 'b) Hashtbl.t -> 'a -> 'b optionFind a binding for the key, or return None if no value is found
val mem : ('a, 'b) t -> 'a -> boolHashtbl.mem tbl x checks if x is bound in tbl.
A number of higher-order functions are provided to allow purely functional traversal or transformation of hashtables. These functions are similar to their counterparts in module BatEnum.
Whenever you wish to traverse or transfor a hashtable, you have the choice between using the more general functions of BatEnum, with keys, values, enum and of_enum, or the more optimized functions of this section.
If you are new to OCaml or unsure about data structure, using the functions of BatEnum is a safe bet. Should you wish to improve performance at the cost of generality, you will always be able to rewrite your code to make use of the functions of this section.
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unitHashtbl.iter f tbl applies f to all bindings in table tbl. f receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to f. The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'cHashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 (f k0 d0 init))...), where k0,k1..kN are the keys of all bindings in tbl, and d0,d1..dN are the associated values. Each binding is presented exactly once to f. The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.
map f x creates a new hashtable with the same keys as x, but with the function f applied to all the values
val map_inplace : ('a -> 'b -> 'b) -> ('a, 'b) t -> unitmap_inplace f x replace all values currently bound in x by f applied to each value.
filter f m returns a new hashtable where only the values a of m such that f a = true remain.
val filter_inplace : ('a -> bool) -> ('key, 'a) t -> unitfilter_inplace f m removes from m all bindings that does not satisfy the predicate f.
filter f m returns a hashtbl where only the key, values pairs key, a of m such that f key a = true remain.
val filteri_inplace : ('key -> 'a -> bool) -> ('key, 'a) t -> unitfilteri_inplace f m performs as filter_inplace but f receive the value in additiuon to the key.
filter_map f m combines the features of filteri and map. It calls f key0 a0, f key1 a1, f keyn an where a0,a1..an are the elements of m and key0..keyn the corresponding keys. It returns a hashtbl with associations keyi,bi where f keyi ai =
Some bi. When f returns None, the corresponding element of m is discarded.
val filter_map_inplace : ('key -> 'a -> 'a option) -> ('key, 'a) t -> unitfilter_map_inplace f m performs like filter_map but modify m inplace instead of creating a new Hashtbl.
Hashtbl.hash x associates a positive integer to any value of any type. It is guaranteed that if x = y or Pervasives.compare x y = 0, then hash x = hash y. Moreover, hash always terminates, even on cyclic structures.
Hashtbl.hash_param n m x computes a hash value for x, with the same properties as for hash. The two extra parameters n and m give more precise control over hashing. Hashing performs a depth-first, right-to-left traversal of the structure x, stopping after n meaningful nodes were encountered, or m nodes, meaningful or not, were encountered. Meaningful nodes are: integers; floating-point numbers; strings; characters; booleans; and constant constructors. Larger values of m and n means that more nodes are taken into account to compute the final hash value, and therefore collisions are less likely to happen. However, hashing takes longer. The parameters m and n govern the tradeoff between accuracy and speed.
val print :
?first:string ->
?last:string ->
?sep:string ->
?kvsep:string ->
('a BatInnerIO.output -> 'b -> unit) ->
('a BatInnerIO.output -> 'c -> unit) ->
'a BatInnerIO.output ->
('b, 'c) t ->
unitThe following modules replace functions defined in Hashtbl with functions behaving slightly differently but having the same name. This is by design: the functions meant to override the corresponding functions of Hashtbl.
module Exceptionless : sig ... endOperations on Hashtbl without exceptions.
module Infix : sig ... endInfix operators over a BatHashtbl
module type HashedType = sig ... endmodule type S = sig ... endThe output signature of the functor Hashtbl.Make.
Functor building an implementation of the hashtable structure. The functor Hashtbl.Make returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the hashing and equality functions specified in the functor argument H instead of generic equality and hashing.
module Cap : sig ... endCapabilities for hashtables.