Replace fast-deep-equal with dequal

[rtritto]

dequal is faster than fast-deep-equal: benchmarks

Atom Family

import { atom } from 'jotai'
import { atomFamily } from 'jotai/utils'
-import deepEqual from 'fast-deep-equal'
+import { dequal } from 'dequal/lite'

-const fooFamily = atomFamily((param) => atom(param), deepEqual)
+const fooFamily = atomFamily((param) => atom(param), dequal)

[dai-shi]

It's just an example. I don't think it's very important.
Feel free to use alternative libraries.

[rtritto]

Imo the documentation should advise.

[DavidJFelix]

I tend to agree that examples don't need to be perfect and we shouldn't play games trying to pick favorite third party libraries. I think most importantly: documenting which third party libraries are best is not the focus of the jotai docs. IMO, you're welcome to open a PR and discuss there, but I feel like just swapping libraries is not unimportant churn.

However, in an effort to showcase jotai's flexibility, the documentation may benefit from a call out that says other libraries that work here, listing dequal or others as desired. Personally, I don't have a strong opinion in this matter other than the one stated above, and I think that if this is really important you should feel free to open a PR for the change.

[jessekrubin]

@rtritto how does dequal compare with fast-equals?

[rtritto]

@jessekrubin you can check benchmarks:

The benchmarks can be found in the /bench directory.

[jessekrubin]

@rtritto There is no comparison for fast-equals in the dequal benchmark.

I did however open a pr adding a dequal bench to the fast-equals repo ( planttheidea/fast-equals#122 ) and it appears fast-equals mostly beats dequal.

[rtritto]

Thanks, I created the issue lukeed/dequal#27 for benchmarks in dequal

[rtritto]

@jessekrubin Fastest is with custom deep equal function. Draft:

const customDeepEqual = (obj1: unknown, obj2: unknown) => {
  if (obj1 === obj2)
    return true
  if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null)
    return false

  const keys1 = Object.keys(obj1)
  const keys2 = Object.keys(obj2)

  if (keys1.length !== keys2.length)
    return false

  for (const key of keys1) {
    if (
      keys2.includes(key) === false
      || customDeepEqual((obj1 as Record<string, unknown>)[key], (obj2 as Record<string, unknown>)[key]) === false
    )
      return false
  }

  return true
}

My benchs (https://github.com/rtritto/dequal/tree/benchs):

Load times:
assert: 0.268ms
util: 0.019ms
fast-deep-equal: 0.802ms
fast-equals/deepEqual: 1.401ms
fast-equals/strictDeepEqual: 0.064ms
lodash/isequal: 18.976ms
nano-equal: 0.423ms
dequal: 1.328ms
dequal/lite: 0.409ms
customDeepEqual: 16.538ms

(basic) Validation: 
  ✔ assert.deepStrictEqual
  ✔ util.isDeepStrictEqual
  ✔ fast-deep-equal
  ✔ fast-equals/deepEqual
  ✔ fast-equals/strictDeepEqual
  ✔ lodash.isEqual
  ✔ nano-equal
  ✔ dequal/lite
  ✔ dequal
  ✔ customDeepEqual

(basic) Benchmark:
  assert.deepStrictEqual x 538,327 ops/sec ±0.79% (96 runs sampled)
  util.isDeepStrictEqual x 538,951 ops/sec ±0.85% (99 runs sampled)
  fast-deep-equal x 2,579,055 ops/sec ±0.96% (96 runs sampled)
  fast-equals/deepEqual x 2,892,115 ops/sec ±0.93% (92 runs sampled)
  fast-equals/strictDeepEqual x 277,932 ops/sec ±0.73% (98 runs sampled)
  lodash.isEqual x 532,402 ops/sec ±1.14% (96 runs sampled)
  nano-equal x 1,909,379 ops/sec ±0.70% (96 runs sampled)
  dequal/lite x 2,125,924 ops/sec ±0.84% (95 runs sampled)
  dequal x 2,209,435 ops/sec ±1.07% (91 runs sampled)
  customDeepEqual x 2,050,846 ops/sec ±0.82% (95 runs sampled)

(complex) Validation:
  ✔ assert.deepStrictEqual
  ✔ util.isDeepStrictEqual
  ✔ fast-equals/deepEqual
  ✔ fast-equals/strictDeepEqual
  ✔ lodash.isEqual
  ✔ dequal
  ✔ customDeepEqual

(complex) Benchmark:
  assert.deepStrictEqual x 216,109 ops/sec ±0.87% (91 runs sampled)
  util.isDeepStrictEqual x 214,896 ops/sec ±1.08% (96 runs sampled)
  fast-equals/deepEqual x 806,080 ops/sec ±0.80% (92 runs sampled)
  fast-equals/strictDeepEqual x 137,259 ops/sec ±0.53% (94 runs sampled)
  lodash.isEqual x 95,672 ops/sec ±0.62% (98 runs sampled)
  dequal x 623,815 ops/sec ±0.36% (95 runs sampled)
  customDeepEqual x 1,279,247 ops/sec ±0.54% (95 runs sampled)

There is a way to reduce the load time of customDeepEqual?

FYI @dai-shi

[rtritto]

Can we write a customDeepEqual function specifics to jotai use case?

[dai-shi]

#2649 (reply in thread)

Can we write a customDeepEqual function specifics to jotai use case?

We generally recommend creating custom equality function like (a, b) => a.id === a.id for atomFamily. We strongly discourage of using deep equality function for atomFamily unless it's during migration from Recoil.. It would be nice to add such a note to the docs.