Module type CCPersistentHashtbl.S

module type S = sig .. end

type key

type 'a t

val empty : unit -> 'a t

Empty table. The table will be allocated at the first binding

val create : int -> 'a t

Create a new hashtable, with the given initial capacity

val is_empty : 'a t -> bool

Is the table empty?

val find : 'a t -> key -> 'a

Find the value for this key, or fails
Raises Not_found if the key is not present in the table

val get_exn : key -> 'a t -> 'a

Synonym to CCPersistentHashtbl.S.find with flipped arguments

val get : key -> 'a t -> 'a option

Safe version of !

val mem : 'a t -> key -> bool

Is the key bound?

val length : 'a t -> int

Number of bindings

val add : 'a t ->
       key -> 'a -> 'a t

Add the binding to the table, returning a new table. The old binding for this key, if it exists, is shadowed and will be restored upon remove tbl k.
Since 0.14

val replace : 'a t ->
       key -> 'a -> 'a t

Add the binding to the table, returning a new table. This erases the current binding for key, if any.

val update : 'a t ->
       key ->
       ('a option -> 'a option) -> 'a t

update tbl key f calls f None if key doesn't belong in tbl, f (Some v) if key -> v otherwise; If f returns None then key is removed, else it returns Some v' and key -> v' is added.

val remove : 'a t ->
       key -> 'a t

Remove the key

val copy : 'a t -> 'a t

Fresh copy of the table; the underlying structure is not shared anymore, so using both tables alternatively will be efficient

val merge : f:(key ->
          [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
       'a t ->
       'b t -> 'c t

Merge two tables together into a new table. The function's argument correspond to values associated with the key (if present); if the function returns None the key will not appear in the result.

val iter : 'a t ->
       (key -> 'a -> unit) -> unit

Iterate over bindings

val fold : ('b -> key -> 'a -> 'b) ->
       'b -> 'a t -> 'b

Fold over bindings

val map : (key -> 'a -> 'b) ->
       'a t -> 'b t

Map all values

val filter : (key -> 'a -> bool) ->
       'a t -> 'a t

val filter_map : (key -> 'a -> 'b option) ->
       'a t -> 'b t

val for_all : (key -> 'a -> bool) ->
       'a t -> bool

val exists : (key -> 'a -> bool) ->
       'a t -> bool

Conversions

val of_seq : (key * 'a) CCPersistentHashtbl.sequence ->
       'a t

Add (replace) bindings from the sequence to the table

val of_list : (key * 'a) list -> 'a t

val add_seq : 'a t ->
       (key * 'a) CCPersistentHashtbl.sequence ->
       'a t

val add_list : 'a t ->
       (key * 'a) list -> 'a t

val to_seq : 'a t ->
       (key * 'a) CCPersistentHashtbl.sequence

Sequence of the bindings of the table

val to_list : 'a t -> (key * 'a) list

Misc

val equal : 'a CCPersistentHashtbl.equal ->
       'a t CCPersistentHashtbl.equal

val pp : ?sep:string ->
       ?arrow:string ->
       key CCPersistentHashtbl.printer ->
       'a CCPersistentHashtbl.printer ->
       'a t CCPersistentHashtbl.printer

val stats : 'a t -> Hashtbl.statistics

Statistics on the internal table.
Since 0.14