OCaml library : Ephemeron.K1

# Module Ephemeron.K1

    module K1: sig .. end

Ephemerons with one key.

    type ('k, 'd) t

an ephemeron with one key

    val create : unit -> ('k, 'd) t

`Ephemeron.K1.create ()` creates an ephemeron with one key. The data and the key are empty

    val get_key : ('k, 'd) t -> 'k option

`Ephemeron.K1.get_key eph` returns `None` if the key of `eph` is empty, `Some x` (where `x` is the key) if it is full.

    val get_key_copy : ('k, 'd) t -> 'k option

`Ephemeron.K1.get_key_copy eph` returns `None` if the key of `eph` is empty, `Some x` (where `x` is a (shallow) copy of the key) if it is full. This function has the same GC friendliness as `Weak.get_copy`

If the element is a custom block it is not copied.

    val set_key : ('k, 'd) t -> 'k -> unit

`Ephemeron.K1.set_key eph el` sets the key of `eph` to be a (full) key to `el`

    val unset_key : ('k, 'd) t -> unit

`Ephemeron.K1.unset_key eph el` sets the key of `eph` to be an empty key. Since there is only one key, the ephemeron starts behaving like a reference on the data.

    val check_key : ('k, 'd) t -> bool

`Ephemeron.K1.check_key eph` returns `true` if the key of the `eph` is full, `false` if it is empty. Note that even if `Ephemeron.K1.check_key eph` returns `true`, a subsequent `Ephemeron.K1.get_key` `eph` can return `None`.

    val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit

`Ephemeron.K1.blit_key eph1 eph2` sets the key of `eph2` with the key of `eph1`. Contrary to using `Ephemeron.K1.get_key` followed by `Ephemeron.K1.set_key` or `Ephemeron.K1.unset_key` this function does not prevent the incremental GC from erasing the value in its current cycle.

    val get_data : ('k, 'd) t -> 'd option

`Ephemeron.K1.get_data eph` returns `None` if the data of `eph` is empty, `Some x` (where `x` is the data) if it is full.

    val get_data_copy : ('k, 'd) t -> 'd option

`Ephemeron.K1.get_data_copy eph` returns `None` if the data of `eph` is empty, `Some x` (where `x` is a (shallow) copy of the data) if it is full. This function has the same GC friendliness as `Weak.get_copy`

If the element is a custom block it is not copied.

    val set_data : ('k, 'd) t -> 'd -> unit

`Ephemeron.K1.set_data eph el` sets the data of `eph` to be a (full) data to `el`

    val unset_data : ('k, 'd) t -> unit

`Ephemeron.K1.unset_data eph el` sets the key of `eph` to be an empty key. The ephemeron starts behaving like a weak pointer.

    val check_data : ('k, 'd) t -> bool

`Ephemeron.K1.check_data eph` returns `true` if the data of the `eph` is full, `false` if it is empty. Note that even if `Ephemeron.K1.check_data eph` returns `true`, a subsequent `Ephemeron.K1.get_data` `eph` can return `None`.

    val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit

`Ephemeron.K1.blit_data eph1 eph2` sets the data of `eph2` with the data of `eph1`. Contrary to using `Ephemeron.K1.get_data` followed by `Ephemeron.K1.set_data` or `Ephemeron.K1.unset_data` this function does not prevent the incremental GC from erasing the value in its current cycle.

    val make : 'k -> 'd -> ('k, 'd) t

`Ephemeron.K1.make k d` creates an ephemeron with key `k` and data `d`.

    val query : ('k, 'd) t -> 'k -> 'd option

`Ephemeron.K1.query eph key` returns `Some x` (where `x` is the ephemeron's data) if `key` is physically equal to `eph`'s key, and `None` if `eph` is empty or `key` is not equal to `eph`'s key.

    module Make: functor (H : Hashtbl.HashedType) -> Ephemeron.S  with type key = H.t

Functor building an implementation of a weak hash table

    module MakeSeeded: functor (H : Hashtbl.SeededHashedType) -> Ephemeron.SeededS  with type key = H.t

Functor building an implementation of a weak hash table.

    module Bucket: sig .. end