Have trouble reading Jotai code. Any help woud be appreciated.

[pencil-user]

I am decent with JavaScript and also (I thought) good enough with TypeScript. But I have no idea what is happening here:

// read-only derived atom
export function atom<Value>(read: Read<Value>): Atom<Value>

// invalid function in the first argument
export function atom(invalidFunction: (...args: any) => any, write?: any): never

https://github.com/pmndrs/jotai/blob/main/src/core/atom.ts

You seem to be creating several functions with the same name and with no body. What is that for? Any links to typeScript where this is explained? I didn't think typeScript supports this.

What I am essentially trying is to create reactive write atom. Basically a write atom that has both reactive and non-reactive get. I need it to eventually create Effect atom, which is something I want to experiment with. That's why I am trying to understand the code.

[dai-shi]

It's function overload. I'm not 100% sure if : never works nicely though.

If you need non-reactive get, you might want to try unstable_createStore and/or jotai-game.

[pencil-user]

First of all, thanks for telling me about function overloads. Had no idea typeScript supports it!

If you need non-reactive get, you might want to try #922 and/or jotai-game.

By non-reactive I don't mean writing to atoms outside react. What I mean is that function is not called again when any of the atoms is updated. This is now behavior for write atom. Derived atom has reactive get but can only edit itself. I want write atom that gets called after some of the primitive atoms are changed, but not others (hence both reactive and non-reactive get). This can be used as a basis for some interesting atoms.

What I ultimately would like is AtomEffect atom that works something like this:

const atomLoginEffect = AtomEffect(
  (previous, // previous value of all atoms in dependency object
   current,  // current value of all atoms in dependency object
   get, // non-reactive get (if we need values of additional objects we don't track
   set  // sets any primitive atom we want 
  ) => {
    if(previous.userAtom.username !== null && current.userAtom.username === null) {  // we have just logged out
      // clean up atoms containing data that only logged in users need
    } else if(previous.userAtom.username === null && current.userAtom.username !== null) { // we have just logged in
      // populate atoms with data that logged in users need
    }
  },
  {userAtom} // dependency object (used instead of dependency array so everything is named, you can only put atoms in it, uses reactive get under the hood)
)

[dai-shi]

I want write atom that gets called after some of the primitive atoms are changed, but not others

That is not possible. The closest I can think of is to write all atoms with custom write. In other words, only with non-reactive get. You have full control, but I don't think it's what you really want.

[pencil-user]

Thanks for telling me. It seems limiting that there is no way to do it, especially since Jotai encourages splicing atoms to get various effects otherwise. It seems strange that derived atoms can only reactively change themselves (even if this does allow for chaining!)

Part of the reason why I am asking this is because I am trying to create a fetching and caching library in Jotai (so, similar to React Query and RTK Query) because I like some properties of Jotai, but I am also running into limitations. I did manage to get pretty far via write atoms but I found such solutions to be a bit inelegant. Pattern above might be helpful in certain ways.

[dai-shi]

Jotai comes with lots of limitations, thus simple in another aspect. Could you explain your use case with a minimal example? There would be another solution.

Caching is not the job of jotai core, and if you need custom caching, it's probably done outside atom logic. We still can use an atom to place caches. jotai/query (with RQ) does that.