Is using a watch an antipattern?

[timofei-iatsenko]

I'm a new to Effector and trying to not make bad decisions in the begining.

Let's look into the simple case.
When an event is dispatched we should do a three other actions (side-effects):

export const startDrivingEvent = driveModeDomain.createEvent<{ tripId: string }>();

const redirectToVisitFx = driveModeDomain.createEffect(async () => /*...*/);
const sendAnalyticsFx = driveModeDomain.createEffect(async () => /*...*/);
const startDrivingRequestFx = driveModeDomain.createEffect(async () => /*...*/)

guard({
  clock: startDrivingEvent,
  filter: $isUserLoggedIn,
  target: startDrivingRequestFx,
});

sample({
  clock: startDrivingEvent,
  source: $lastDrivingVisitId,
  target: redirectToVisitFx,
  fn: (lastDrivingVisitId) => ({ lastDrivingVisitId }),
});

sample({
  clock: startDrivingEvent,
  source: $tripGeneralAnalytics,
  target: sendAnalyticsFx,
  fn: (tripGeneralAnalytics) => ({ analyticsData: tripGeneralAnalytics }),
});

One action is under the guard, other two need an additional data from different stores to perform a side effect. This is quite simplified case, when parameters of startDrivingEvent and startDrivingRequestFx is matching, and you don no need to create an additional sample/guards/attach.

But even in this example i found the code is a bit bloated, and found that with .watch it could be much shorter and readable (because you see all control flow in one place)

export const startDrivingEvent = driveModeDomain.createEvent<{ tripId: string }>();

const redirectToVisitFx = driveModeDomain.createEffect(async () => /*...*/);
const sendAnalyticsFx = driveModeDomain.createEffect(async () => /*...*/);
const startDrivingRequestFx = driveModeDomain.createEffect(async () => /*...*/)

sample({
  clock: startDrivingEvent,
  source: [$lastDrivingVisitId, $isUserLoggedIn, $tripGeneralAnalytics],
  fn: (source, event) => [...source, event] as const,
}).watch(([lastDrivingVisitId, isUserLoggedIn, tripGeneralAnalytics, eventPayload]) => {
  if (isUserLoggedIn) {
    startDrivingRequestFx({ tripId: eventPayload.tripId });
  }
  sendAnalyticsFx({ analyticsData: tripGeneralAnalytics });
  redirectToVisitFx({ lastDrivingVisitId });
});

The difference become more noticable when you have switch cases, together with guards and other control-flow operations.

So the question is there any drawbacks of using .watch in above mentioned cases and when i should use sample/guard/split/etc instead of watch? I'm asking because all examples using declarative approach and it making a perception that i trying to use watch for something that it not designed to use.