You are currently looking at the < v8.2.0 docs (Reason v3.6 syntax edition). You can find the latest API docs here.
(These docs cover all versions between v3 to v8 and are equivalent to the old BuckleScript docs before the rebrand)
Id
Provide utilities to create identified comparators or hashes for data structures used below.
It creates a unique identifier per module of functions so that different data structures with slightly different comparison functions won't mix.
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
module type Comparable {
type identity;
type t;
let cmp: BeltId.cmp(t, identity);
}
comparable
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
MakeComparableU
module MakeComparableU: (M: {type t; let cmp: [@bs] ((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: [@bs] (('a, 'a) => int)) => (module BeltId.Comparable with type t = 'a);
comparable
type ('key, 'id) comparable = (module BeltId.Comparable with type identity = 'id and type t = 'key)
Hashable
module type Hashable = {
type identity;
type t;
let hash: BeltId.hash(t, identity);
let eq: BeltId.eq(t, identity);
}
hashable
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.
MakeHashableU
module MakeHashableU: (M: {type t; let hash: [@bs] (t => int); let eq: [@bs] ((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: [@bs] ('a => int), ~eq: [@bs] (('a, 'a) => bool)) => (module BeltId.Hashable with type t = 'a);
hashable
let hashable: (~hash: 'a => int, ~eq: ('a, 'a) => bool) => (module BeltId.Hashable with type t = 'a);