Hashtbl.Make(3)

📦
version 5.5.0 · 19 versions
, in arch rolling

🌸 Hashtbl.Make(3) — the OCaml library glow-up 🦋

okay so this little icon is from the OCaml library manual, page Hashtbl.Make(3) — and bestie, it's literally the functor that builds you a whole hashtable implementation. no cap, it's giving "build-a-bear but for data structures" 🎀

✨ NAME ✨

Hashtbl.Make — a functor that builds an implementation of the hashtable structure. that's it, that's the vibe 💅

🧚 Module 🧚

Module Hashtbl.Make

💜 Documentation 💜

Module Make
 : (H : HashedType) -> sig end

okay so here's the tea 🔥 — Hashtbl.Make is a functor building an implementation of the hashtable structure.

The way that it works: the functor Hashtbl.Make returns a structure containing:

  • a type key of keys 🔑
  • 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 — and this is the main character detail — they use the hashing and equality functions specified in the functor argument H instead of generic equality and hashing. iykyk 🌈

ngl, one important thing: since the hash function is not seeded, the create operation of the result structure always returns non-randomized hash tables. no randomization, no surprises, just consistency ✨

Parameters:

  • "H" — which is a Hashtbl.HashedType 💖

👑 Types 👑

  • type key — the key type, slaying as always 🔑
  • type !'a t — the hash table type itself, with that ! variance marker doing its thing (yes, we stan a constructor that's not covariant) 💅

⭐ The functions ⭐

  • val create : int -> 'a t — makes you a fresh table, you give it an int and it gives you the 'a t 🎀
  • val clear : 'a t -> unit — empties the table out. bye bestie 👋
  • val reset : 'a t -> unit — resets it. Since 4.00 🦋
  • val copy : 'a t -> 'a t — a whole duplicate, no sharing of your original's drama 💖
  • val add : 'a t -> key -> 'a -> unit — put a key + value in there 🍓
  • val remove : 'a t -> key -> unit — take a key out 🌸
  • val find_and_remove : 'a t -> key -> 'a option — finds it and removes it in one go, handing you back an 'a option. Since 5.5 🔥
  • val find : 'a t -> key -> 'a — find the value for a key, straight up 💜
  • val find_opt : 'a t -> key -> 'a option — same energy but safe, gives you an 'a option. Since 4.05 ✨
  • val find_all : 'a t -> key -> 'a list — all the values for that key, in a list 🎀
  • val replace : 'a t -> key -> 'a -> unit — swap out the value 🧚
  • val find_and_replace : 'a t -> key -> 'a -> 'a option — swap it and give you the old value back as an 'a option. Since 5.5 🌟
  • val mem : 'a t -> key -> bool — is this key even in here?? bool says yes/no 💅
  • val iter : (key -> 'a -> unit) -> 'a t -> unit — run your function over everything, nobody left out 🫶
  • val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit — filters and maps in place, option deciding who stays. Since 4.03 🌈
  • val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc — fold it all down into one accumulated 'acc ⭐
  • val length : 'a t -> int — how many things are in there, as an int 💀
  • val stats : 'a t -> Hashtbl.statistics — the numbers on your table, all packaged as Hashtbl.statistics. Since 4.00 📊
  • val to_seq : 'a t -> (key * 'a) Seq.t — turn it into a sequence of (key * 'a) pairs. Since 4.07 🦋
  • val to_seq_keys : 'a t -> key Seq.t — just the keys, as a key Seq.t. Since 4.07 🔑
  • val to_seq_values : 'a t -> 'a Seq.t — just the values, as an 'a Seq.t. Since 4.07 💖
  • val add_seq : 'a t -> (key * 'a) Seq.t -> unit — pour a (key * 'a) Seq.t straight into your table. Since 4.07 🍓
  • val replace_seq : 'a t -> (key * 'a) Seq.t -> unit — same but replacing as it goes. Since 4.07 🌸
  • val of_seq : (key * 'a) Seq.t -> 'a t — build a whole fresh table out of a sequence. Since 4.07 🎀
fr fr that's every single val, every signature, every Since note — nothing skipped, nothing merged, we keep the facts and only change the vibe 💅

okay bestie that's the whole page 🫶 this was rendered by OCamldoc, dated 2026-06-22, and it's the Hashtbl.Make(3) page from the OCaml library — periodt. go build your hashtable, you're gonna eat 💖✨🎀

📦 where this page comes from