Question: How to get latest value from snapshot.getPromise() when update state very fast

Hi, I have found that if I use useRecoilCallBack to update the state very fast, the snapshot.getPromise always seems to mess up the first transaction.

The example is in https://codesandbox.io/s/objective-williams-9gn7k?file=/src/App.js

export const countState = atom({
  key: "count_key",
  default: 1
});

const Test = () => {
  const handleIncrease = async () => {
    let i = 0;
    while (i < 10) {
      await increase();
      i++;
    }
  };

  const increase = useRecoilCallback(
    ({ set, snapshot, gotoSnapshot }) => async () => {
      const currentPromise = await snapshot.getPromise(countState);
      console.log("Snapshot Value: ", currentPromise);
      set(countState, value => {
        console.log("inside set", value);
        return value + 1;
      });
    }
  );

  return (
    <p>
      <button onClick={handleIncrease}>Increase Counter</button>
    </p>
  );
};

I’m not sure how to avoid this.

[drarmstr]

The snapshot for useRecoilCallback() is from the currently committed state when the the callback was initiated, while the updaters provide the current state that is pending for the next batch. This state may change as subsequent sets or updates are performed before the batch is committed. We should avoid assumptions about when React batches are run. So, use either approach depending on what consistency guarantees you need, either with the latest pending updates or with the latest committed batch.

[salvoravida]

As the name implies, the “snapshot” is a static immutable snapshot of what the committed atom state was when the callback was initiated. If you want the latest state for an atom or selector, particularly during or after async calls, then you should use the updater form of the setter to get the most-up-to-date state that includes queued pending state changes. This is particularly important as we start working with React’s new Concurrent Mode.

i @drarmstr why not expose get on useRecolCallback? function get(recoilState) { return getRecoilValueAsLoadable(storeRef.current, recoilState); }

This example gets a Loadable, not the value itself. getLoadable() is exposed in the Snapshot API. One reason the snapshot provides the snapshot values at the time the callback was initiated vs the current value is to avoid problems with tearing which can lead to hard-to-debug user bugs.

yes i understand. but please consider advanced users. i try to explain better here https://github.com/facebookexperimental/Recoil/issues/829