Id (melange.Belt.Id)

type hash('a, 'id);

('a, 'id) hash

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

type eq('a, 'id);

('a, 'id) eq

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

type cmp('a, 'id);

('a,'id) cmp

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

module type Comparable = { ... };

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

('key, 'id) cmparable 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 comparableU or 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: { ... }) => Comparable with type t = M.t;

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

let comparableU: 
  cmp:Js.Fn.arity2(('a => 'a => int)) =>
  (module Comparable
  with type t = 'a);

let comparable: cmp:('a => 'a => int) => (module Comparable with type t = 'a);

module C = (
  val Belt.Id.comparable ~cmp:(compare : int -> int -> int)
)
let m = Belt.Set.make(module C)

Note that the name of C can not be ignored

module type Hashable = { ... };

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

('key, 'id) hashable 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 hashableU or 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: { ... }) => Hashable with type t = M.t;

module MakeHashable: (M: { ... }) => Hashable with type t = M.t;

let hashableU: 
  hash:Js.Fn.arity1(('a => int)) =>
  eq:Js.Fn.arity2(('a => 'a => bool)) =>
  (module Hashable
  with type t = 'a);

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