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.

let t1 = 1 === 1 // true
let t2 = "foo" === "foo" // true
let t3 = { "foo": "bar" } === { "foo": "bar"} // false

let doStringsMatch = (s1: string, s2: string) => s1 === s2

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.

let t1 = 1 == 1 // true
let t2 = "foo" == "foo" // true
let t3 = { "foo": "bar" } == { "foo": "bar"} // true

let doStringsMatch = (s1: string, s2: string) => s1 == s2

== will compile to === (or a bool if the compiler can determine equality) when:

• Comparing string, char, int, float, bool, or unit

• 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 expression Re.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,

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

let compareInt = (a: int, b: int) => a > b
let t1 = 1 > 10
let compareArray = (a: array<int>, b: array<int>) => a > b
let compareOptions = (a: option<float>, b: option<float>) => a < b

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.