Discourage usage of atomFamily with areEqual parameter

[tien]

I know there's already been a few discussions on removing the atomFamily function and making it into a recipe.

But I think it should be discouraged or at least there should be some warning about the performance cost of atomFamily with areEqual.

Since right now it's doing a for loop over every atom in the atom family, for n atom reads, it will have a performance cost of O(n²).

i.e. if you render a screen that has around 500 atoms, from an atom family that has 500 items, the areEqual function, at worst, will be called up to 250,000 times.

I know it seems obvious, but it did caught me by surprise :p

[dmaskasky]

@dai-shi is it time to mark atomFamily as deprecated?

[dai-shi]

I think it's a different story.
We will just move it, meaning the issue/concern is still relevant.

[dai-shi]

But I think it should be discouraged or at least there should be some warning about the performance cost of atomFamily with areEqual.

Didn't we write something about discouraging areEqual?
areEqual should be lightweight, but there are some use cases.
Especially when params are coming from outside.

[tien]

Doesn't seems to be the case here, there's only notice on memory leak.

[tien]

Yes it should be light weight, hence should be mentioned in the docs I think. It's one of those thing that seems obvious, but can definitely caught people off guard :))

Plus most of the time, since params are often serializable, most people would be better off with a custom atomFamily implementation that does key serialization.

[dai-shi]

Good point. Would you like to open a PR to improve docs?

since params are often serializable

I'm not sure how that helps.

[tien]

Cool, I'll come up with some text that make sense 👌

since params are often serializable

Meaning in most cases, this custom atomFamily would be better since it perform significantly better

function atomFamily<TParam, TAtomType extends Atom<unknown>>(
  initializeAtom: (param: TParam) => TAtomType,
  getKey: (param: TParam) => unknown = (param) => param,
) {
  // ...
}

const primitiveAtom = atomFamily((param: string) => atom(param));

// O(1) instead of O(n^2)
const objectAtom = atomFamily(
  (param: { string: string; number: number }) => atom(param),
  (param) => [param.string, param.number].map(JSON.stringify).join("-"),
);

[dai-shi]

I see. It's to a have a string key. Yeah, that feels like a territory for jotai-family.

[dmaskasky]

We should be able to do better than O(n^2). Let's just fix it.