Equality and Comparison
ReScript has shallow equality ===
, deep equality ==
, and comparison operators >
, >=
, <
, and <=
.
Shallow equality
The shallow equality operator ===
compares two values and either compiles to ===
or a bool
if the equality is known to the compiler.
It behaves the same as the strict equality operator ===
in JavaScript.
Using ===
will never add a runtime cost.
Deep equality
ReScript has the deep equality operator ==
to check deep equality of two items, which is very different from the loose equality operator like ==
in JavaScript.
When using ==
in ReScript it will never compile to ==
in JavaScript,
it will either compile to ===
, a runtime call to an internal function that deeply compares the equality, or a bool
if the equality is known to the compiler.
==
will compile to ===
(or a bool
if the compiler can determine equality) when:
Comparing
string
,char
,int
,float
,bool
, orunit
Comparing variants or polymorphic variants that do not have constructor values
==
will compile to a runtime check for deep equality when:
Comparing
array
,tuple
,list
,object
,record
, or regular expressionRe.t
Comparing variants or polymorphic variants that have constructor values
When using
==
pay close attention to the JavaScript output if you're not sure what==
will compile to.
Comparison
ReScript has operators for comparing values that compile to the the same operator in JS, a runtime check using an internal function, or a bool
if the equality is known to the compiler,
operator | comparison |
---|---|
> | greater than |
>= | greater than or equal |
< | less than |
<= | less than or equal |
Comparison can be done on any type.
An operator will compile to the same operator (or a bool
if the compiler can determine equality) when:
Comparing
int
,float
,string
,char
,bool
An operator will compile to a runtime check for deep equality when:
Comparing
array
,tuple
,list
,object
,record
, or regular expression (Re.t
)Comparing variants or polymorphic variants
Performance of runtime equality checks
The runtime equality check ReScript uses is quite fast and should be adequate for almost all use cases.
For small objects it can be 2x times faster than alternative deep compare functions such as Lodash's _.isEqual
.
For larger objects instead of using ==
you could manually use a faster alternative such as fast-deep-compare, or write a custom comparator function.
This repo has benchmarks comparing results of different libraries compared to ReScript's built-in equality function.