Question about the guarantees of useMemo

[CarsonMcKinstry]

Hi Folks!

I had a somewhat-quick question about some of the guarantees preact makes about the useMemo hook.

Does this section from the react documentation, still hold true in preact?

You may rely on `useMemo` as a performance optimization, not as a semantic guarantee. 
In the future, React may choose to “forget” some previously memoized values and recalculate 
them on next render, e.g. to free memory for offscreen components. Write your code so that 
it still works without useMemo — and then add it to optimize performance.

--

Why do I ask?

Suppose we have a function that creates a closure over some instantiated variable:

const createClosure = () => {
  const closedOverValue = new ClosedOverValue();
  
  return () => {
      // use closedOverValue in some way
  }
}

We want to use this inside of a component. However, each instance of that component should have distinct instances of closedOverValue. What I've come up with so far is this

const MyComponent = () => {
    const myClosureFunction = useMemo(() => createClosure(), []);
    
    // myClosureFunction should now have a new and unique instance of ClosedOverValue
    return (
        <>
            ...
        </>
    );
}

Based on the react documentation, this would be considered unsafe. Is this the same case in preact? Or can this be done safely, without the same worry the react team creates?

[JoviDeCroock]

It's a guarantee we can bring, we'd have to look at a few of the current things we're doing in Suspense but generally we're not planning to support something as the likes of concurrent mode.

React implements an idea of lanes, a lane can be used to perform work in, this means that if you memoize something in lane 1 but this isn't used that it will have a different reference in a potential other lane. As we are not implementing this assumption voids when porting it to Preact, do note that there could currently be an issue with Suspense when it comes to this exact case 😅 currently we are erasing all hooks state both on initial and subsequent suspense, this is something React doesn't do I think, they do re-run the memo func iirc.

[CarsonMcKinstry]

Okay, cool! I think this means we can move forward with what we're trying to do :)

Thanks for the super quick answer!