Passing current value and previous value in store.sub

[Qrysto]

Currently store.sub function is defined as follow, where the listener doesn't receive any parameter:

sub: (atom: AnyAtom, listener: () => void) => () => void;

If I want to get the atom value inside the listener, I have to call store.get(thatAtom). It could be simplified by just passing the current atom value to the listener.

Another common need is to access the atom's previous value before the change happened, which is currently not possible unless I manually cache the atom value elsewhere, such as with another atom. I think it would make sense to pass the previous value as the second parameter (after the current value) to the listener, so you can ignore it if you don't need it.

So the suggested definition would be as follow:

sub: <Value>(atom: Atom<Value>, listener: (value: Value, previousValue: Value) => void) => () => void;

Is this feasible? Any shortcoming that I haven't been aware of? I can create a PR if it makes sense.

[dai-shi]

Please call store.get. You can create your own helper if you want. We might reconsider it in the far future.

For previous value, you need to store it on your end. This minimal API design is a kind of philosophy and it's the same in Valtio. (Zustand doesn't follow for a historical reason.)

[dmaskasky]

You could do

import { atom } from 'jotai'
import { withHistory } from 'jotai-history'

const countAtom = atom(0)
// 2 is the number of current and past values to retain
const countWithPrevious = withHistory(countAtom, 2)
store.sub(countAtom, () => {
  const [count, prevCount] = store.get(countWithOrevious)
})

[Qrysto]

While I agree with the minimalist approach, I think we need to keep in mind what the purposes of minimalism are and consider if a change would compromise its benefits. In this case I think the answer is no. Let's look at some of the aspects where it might be affected:

• Code base: I haven't really implemented this yet but we probably just need to add about 1-2 lines of code and a few more characters to some existing lines - registerBatchAtom should accept ...args to pass on to listeners, and we take a snapshot of the atom's previous value before setting the new value. This hardly increases the bundle size or the complexity of the code base.
• Runtime performance: getting one or two existing values and passing on to a function has effectively zero impact on performance.
• Public API complexity & ease of use: for those who don't need these values, nothing would change at all. They could just pass a listener that doesn't take any parameter, no changes needed. For those who do, this would help clean up their code a little bit, less extra boilerplate if you need these value very often. IMO this change wouldn't make the API harder to use or more complex to learn at all.

So I think this change would still fit well in a minimalist API design.

Moreover, I think semantically it'd just be natural and helpful if the store tell you this
"This atom value has changed from this value to this value"
instead of
"This atom value has changed, but I won't tell you from which to which although I already know it. Go figure it out yourself!".

[dai-shi]

We are very conservative about adding features as removing them is very hard. The Store API is designed for React hook use case, and the current API works fine as of now.

We may reconsider this in the far future. Please bear with this for now.

const subscribe = (store, atom, callback) => store.sub(atom, () => callback(store.get(atom)));