Recursion with AtomEffects

[pengx17]

Resistent To Infinite Loops: atomEffect does not rerun when it changes a value that it is watching.

This is general good for preventing effect running infinitely, but sometimes it may be necessary to rerun it when setting in a async function. Is it possible today that we could force rerun the effect in the effect function?

[dmaskasky]

This is possible, and should be implemented with an abort controller so that you can cancel the current run on cleanup. This is only possible by writing to a writable atom and delaying a microtask inside the writable atom. This effectively bypasses the infinite loop check.

Here is an example of how to do this.
https://codesandbox.io/s/nifty-julien-d3xgsy

Alternatively, you could use a while loop inside atomEffect so that it never completes unless something causes it to rerun. This strategy is more readable because it doesn't need to bypass the infinite loop check. This is because the atomEffect is not listening to the atoms it is changing, so there is no infinite read loop.

Here is an example using a while loop
https://codesandbox.io/s/cold-star-cksmt9

[QWu4xYV]

In my case (From issue #26 ), the while loop wouldn't work, because I intentionally want the effect to be triggered when the atom changes, not at an interval specified by the while loop. Thanks for the first workaround, but something more readable and built-in would definitely be appreciated too!

[dmaskasky]

Should atomEffect prevent async infinite loops?
Currently it does, but I've had several requests to allow infinite loops.
What makes the most sense to you?

atomEffect((get, set) => {
  get(countAtom)
  setTimeout(() => {
    set(countAtom, increment)
  }, 1000)
})

[dmaskasky]

Related Issue: #26

[dmaskasky]

Removing infinite loop prevention for async functions is easy enough. I guess the question is whether it would be beneficial in some cases to leave it in.

Perhaps we can experiment with new api to enable opt-in.

First idea:

import { atomEffect, inf } from 'jotai-effect'

atomEffect((get, set) => {
  get(countAtom)
  setTimeout(() => {
    inf(set(countAtom, increment))
  }, 1000)
})

[QWu4xYV]

tbh I haven't thought about this long enough so maybe there's an obvious answer, but wouldn't there possibly be times where we want "infinite loops" in non-async code, where there's some kind of base case that doesn't call the set? Like a sort of "recursive" algorithm? Obviously my example below is not how you would want to implement a fibonacci number calculator, but just as an illustration:

import { atomEffect, inf } from 'jotai-effect'

atomEffect((get, set) => {
  const fib1 = get(fibonacciAtom1)
  const fib2 = get(fibonacciAtom2)
  const lesserAtom = fib1 < fib2 ? fibonacciAtom1 : fibonacciAtom2
  if (lessertAtom < MAX) {
      inf(set(lesserAtom, fib1 + fib2))
  }
})

[dmaskasky]

I have a PR that introduces a new api to support infinite loops out now: #23

[dmaskasky]

Here is a codesandbox example that uses the new set.recurse api:

• https://codesandbox.io/p/sandbox/nifty-julien-d3xgsy?file=%2Fsrc%2FApp.tsx%3A16%2C7