Id

type hash('a, 'id);

Its runtime represenation is a hash function, but signed with a type parameter, so that different hash functions type mismatch.

type eq('a, 'id);

Its runtime represenation is an eq function, but signed with a type parameter, so that different hash functions type mismatch.

type cmp('a, 'id);

Its runtime representation is a cmp function, but signed with a type parameter, so that different hash functions type mismatch.

module type Comparable {
  type identity;

  type t;

  let cmp: BeltId.cmp(t, identity);
}

type ('key,'id) comparable = (module BeltId.Comparable with type identity = 'id and type t = 'key)

is a module of functions, here it only includes cmp.

Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).

It can be created using function Belt_Id.comparableU or Belt_Id.comparable.

The idea of a unique identity when created is that it makes sure two sets would type mismatch if they use different comparison function

module MakeComparableU: (M: {type t; let cmp: [@bs] ((t, t) => int);}) => Comparable with type t = M.t;

module MakeComparable: (M: {type t; let cmp: (t, t) => int;}) => Comparable with type t = M.t;

let comparableU: (~cmp: [@bs] (('a, 'a) => int)) => (module BeltId.Comparable with type t = 'a);

type ('key, 'id) comparable = (module BeltId.Comparable with type identity = 'id and type t = 'key)

module type Hashable = {
  type identity;

  type t;

  let hash: BeltId.hash(t, identity);

  let eq: BeltId.eq(t, identity);
}

type hashable('key, 'id) = (module BeltId.Hashable with type identity = 'id and type t = 'key);

is a module of functions, here it only includes hash, eq.

Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).

It can be created using function Belt_Id.hashableU or Belt_Id.hashable.

The idea of a unique identity when created is that it makes sure two hash sets would type mismatch if they use different comparison function.

module MakeHashableU: (M: {type t; let hash: [@bs] (t => int); let eq: [@bs] ((t, t) => bool);}) => Hashable with type t = M.t;

module MakeHashable: (M: {type t; let hash: t => int; let eq: (t, t) => bool;}) => Hashable with type t = M.t;

let hashableU: (~hash: [@bs] ('a => int), ~eq: [@bs] (('a, 'a) => bool)) => (module BeltId.Hashable with type t = 'a);

let hashable: (~hash: 'a => int, ~eq: ('a, 'a) => bool) => (module BeltId.Hashable with type t = 'a);