runWithOwner / runWithListener support tracking asynchronously

[LiQuidProQuo]

1 reason to support runWithListener is the ability to track dependencies async.

createEffect(async ()=>{
  let l = getListener()
  let result = await somePromise()
  runWithListener(l, ()=> result.someSignal())
})

[ryansolid]

Another way to do this createReaction which doesn't have the weirdness of having the function that re-runs versus the potential ones that don't. It's very clear that track this, run this.

[LiQuidProQuo]

For the curious createReaction can be used to implement createAsyncEffect ( see example below )

createAsyncEffect

https://playground.solidjs.com/anonymous/a48ce634-20d1-4d28-a90f-6cb009a36fd7

function createAsyncEffect(fn) {
  let v = undefined;
  const run = async () => (v = await fn(v, { track }));
  let track = createReaction(run);
  run();
}

and used like

  createAsyncEffect(async (prev, { track }) => {
    console.log("waiting ...");
    await delay(1);
    track(() => count());
    console.log({ current: count(), prev });
    return count();
  });

the runWithListener is a more low level than createReaction, and can technically even be used to implement createReaction in userland.

runWithListener is more powerful, and typically, will not require knowing the implementation details of each tracking primitive
the concern is then, capture the Listener, run with the Listener to track.

can createReaction be used to implement createMemoAsync, or any other primitive that does synced tracking?

comperable code with runWithListener looks like this:

createEffect(async ()=>{
  let l = getListener()
  console.log("waiting ...");
  await delay(1);
  runWithListener(l, () => count())
  console.log({ current: count(), prev });
  return count();
})

[texastoland]

I love your createAsyncEffect 🙏🏼 I was just coming here to say I wish runWithListener worked with a single call instead of 2:

createEffect(async (prev) => {
  console.log("waiting ...")
  return runWithTracking((track) => {
    await delay(1)
    console.log({ current: count(), prev })
    return track(() => count())
  })
})