Id

Provide utilities to create identified comparators or hashes for data structures used below.

It create a unique identifier per module of functions so that different data structures with slightly different comparison functions won't mix.

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);