You are viewing docs for an older version of Rescript.
Go to latest version.

Id

Belt.Id

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

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

hash

RESCRIPT

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

eq

RESCRIPT

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

cmp

RESCRIPT

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

comparable

RESCRIPT

type comparable<'key, 'id> = module(Comparable
  with type identity = 'id
  with 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

comparableU

RESCRIPT

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

comparable

RESCRIPT

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

Examples

RESCRIPT
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

hashable

RESCRIPT

type hashable<'key, 'id> = module(Hashable
  with type identity = 'id
  with 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

hashableU

RESCRIPT

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

hashable

RESCRIPT

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

getHashInternal

RESCRIPT

let getHashInternal: hash<'a, 'id> => 'a => int

getEqInternal

RESCRIPT

let getEqInternal: eq<'a, 'id> => ('a, 'a) => bool

getCmpInternal

RESCRIPT

let getCmpInternal: cmp<'a, 'id> => ('a, 'a) => int