# Functor Ephemeron.GenHashTable.MakeSeeded

    module MakeSeeded: functor (H : sig

    type t

keys

    type 'a container

contains keys and the associated data

    val hash : int -> t -> int

same as `Hashtbl.SeededHashedType`

    val equal : 'a container ->
           t -> Ephemeron.GenHashTable.equal

equality predicate used to compare a key with the one in a container. Can return `EDead` if the keys in the container are dead

    val create : t ->
           'a -> 'a container

`create key data` creates a container from some initials keys and one data

    val get_key : 'a container ->
           t option

`get_key cont` returns the keys if they are all alive

    val get_data : 'a container -> 'a option

`get_data cont` returns the data if it is alive

    val set_key_data : 'a container ->
           t -> 'a -> unit

`set_key_data cont` modifies the key and data

    val check_key : 'a container -> bool

`check_key cont` checks if all the keys contained in the data are alive

    end) -> Ephemeron.SeededS  with type key = H.t

Functor building an implementation of an hash table that use the container for keeping the information given

Parameters: |
`H` | : | `sig type t (** keys *) type 'a container (** contains keys and the associated data *) val hash: int -> t -> int (** same as {!Hashtbl.SeededHashedType} *) val equal: 'a container -> t -> equal (** equality predicate used to compare a key with the one in a container. Can return [EDead] if the keys in the container are dead *) val create: t -> 'a -> 'a container (** [create key data] creates a container from some initials keys and one data *) val get_key: 'a container -> t option (** [get_key cont] returns the keys if they are all alive *) val get_data: 'a container -> 'a option (** [get_data cont] returns the data if it is alive *) val set_key_data: 'a container -> t -> 'a -> unit (** [set_key_data cont] modifies the key and data *) val check_key: 'a container -> bool (** [check_key cont] checks if all the keys contained in the data are alive *) end`

    type key

    type 'a t

    val create : ?random:bool -> int -> 'a t

    val clear : 'a t -> unit

    val reset : 'a t -> unit

    val copy : 'a t -> 'a t

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

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

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

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

    val find_all : 'a t -> key -> 'a list

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

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

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

    val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit

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

    val length : 'a t -> int

    val stats : 'a t -> Hashtbl.statistics

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

    val to_seq_keys : 'a t -> key Seq.t

    val to_seq_values : 'a t -> 'a Seq.t

    val add_seq : 'a t -> (key * 'a) Seq.t -> unit

    val replace_seq : 'a t -> (key * 'a) Seq.t -> unit

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

    val clean : 'a t -> unit

remove all dead bindings. Done automatically during automatic resizing.

    val stats_alive : 'a t -> Hashtbl.statistics

same as `Hashtbl.SeededS.stats` but only count the alive bindings