computedFn: Structural Comparer for Parameters?

[lekevin-microsoft]

Hiya folks!

Name's Kevin Lee, I work in Microsoft and MobX is glorious.

I have a question. I've started to find scenarios where I need to use comparer.shallow in computed and it's going great. When it comes to computedFn, is there a similar way to say: "Hey computedFn, please shallow-compare / structural-compare the parameters of the function to get a cache hit"? Or am I misunderstanding and computedFn already does that? (e.g. if the computedFn's parameter list is not simple, and is a structural object, will computedFn work?)

As in, my understanding is: ComputedFn will look at the params (e.g. two numbers) and, if they're the same and the result hasn't been recomputed, they'll return the same cached value. However, I'm wondering about the parameters-being-same-check. Can that ever be shallow/structurally compared, or is it always ref-compared? There's a few scenarios where we pass in some complex properties, wondering if that's possible to be computedFn'd.

Thanks so much,
Kevin Lee

[urugator]

It uses Map to locate the entry, so the comparator is always SameValueZero.
Note it memoizes all passed sets of arguments, not just the last one, so it has to search for the entry.

[lekevin-microsoft]

Thanks so much @urugator for the quick response.

Does that mean that computedFn won't be able to memoize structural parameters? Take for instance the following:

interface Person {
    name: string,
    id: Identification,
}

interface Identification {
    prefix: string,
    internal_id: string,
}

const getPersonPrefixEmpty = computedFn((p: Person): boolean => {
    return p.id.prefix == '';
});

const p1 = { name: 'K', id: { prefix: '', internal_id: '1' } };
const p2 = { name: 'K', id: { prefix: '', internal_id: '1' } };

getPersonPrefixEmpty(p1);
getPersonPrefixEmpty(p2); // Will computedFn notice that p1 == p2 value-wise, or will it think not, because they're not the same ref?

In the example above, would getPersonPrefixEmpty() ever be able to have computedFn return a parameter-cache-hit? Because it's an object that is not shallow (it has two layers, Person > Identification), will this mean that two Person's with the same value will return false if computedFn gets called with it?

If this is the case, is there any way to have computedFn perform a shallow or structural check to determine the parameters-equality? Or is that just not possible / not implemented yet?

Thanks!
Kevin Lee

[urugator]

is there any way to have computedFn perform a shallow or structural check

Imagine you call getPersonPrefixEmpty(pX) for 50 different objects, it memoizes them all.
When you call it with another different person, it would have to perform 50 structural comparisons, just to find out it's a cache miss.
Most of the time, this would be a lot slower then just running the computation again.
More reasonable approach would be the ability to provide a hashing function.

Atm you could do:

const getPersonPrefixEmpty = computedFn((serializedP: string): boolean => {
    const p = JSON.parse(serializedP);
    return p.id.prefix == '';
});

const prefixEmpty = getPersonPrefixEmpty(JSON.strinfigy(p));

Still probably a lot slower than re-running the computation again.

[lekevin-microsoft]

Ah, I see. Thank you for the response, @urugator .

So in summary:

1. computedFn's parameter check is by SameValueZero (as it's a map index checker).
2. The parameter check does not do structural / shallow compare.
3. If you need that functionality (and have tested that it's better than just re-running the computation again), you can use a serializer like JSON.stringify(). However, the stringify-option will innately have perf costs associated with it.
4. "Most of the time, this would be a lot slower than just running the computation again."

Thanks a lot for the help, urugator! I appreciate it.

Best,
Kevin Lee