Id

hash

type hash<'a, 'id>

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

eq

type eq<'a, 'id>

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

cmp

type cmp<'a, 'id>

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

Comparable

RES
module type Comparable = {
  type identity

  type t

  let cmp: Belt.Id.cmp<t, identity>
}

comparable

type comparable<'key,'id> =
  module(Belt.Id.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

MakeComparableU

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

MakeComparable

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

comparableU

let comparableU: (~cmp: (. 'a, 'a) => int) =>
  module(Belt.Id.Comparable with type t = 'a)

comparable

type comparable<'key, 'id> =
  module(Belt.Id.Comparable with type identity = 'id and type t = 'key)

Hashable

RES
module type Hashable = {
  type identity

  type t

  let hash: Belt.Id.hash<t, identity>

  let eq: Belt.Id.eq<t, identity>
}

hashable

type hashable<'key, 'id> =
  module(Belt.Id.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.

MakeHashableU

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

MakeHashable

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

hashableU

let hashableU: (~hash: (. 'a) => int, ~eq: (. 'a, 'a) => bool) =>
  module(Belt.Id.Hashable with type t = 'a)

hashable

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