Help me with motivation to use effects in component-store

[undsoft]

I'm struggling a little bit with finding good reasons to use effects in ngrx component store.
It seems that just having a normal function would be appropriate for a lot of cases and also has some other advantages.

For example I can do:

loadUsers = this.effect((trigger$: Observable<void>) => {
  return trigger$.pipe(
    switchMap(() => {
      this.setLoadingState(true);
      return this.users.loadAll().pipe(
        tapResponse(
          (users) => this.addUsers(users),
          (error) => this.handleError(error),
        ),
      );
    }),
  );
});

or I can do:

loadUsers(): void {
  this.setLoadingState(true);

  this.users.loadAll()
    .pipe(untilDestroyed(this))
    .subscribe(
      (users) => this.addUsers(users),
      (error) => this.handleError(error),
    );
}

The advantages of using an effect are supposed to be:

1. Automatic subscription control.
2. More reactive approach.
3. Being able to use flattening operators.

but points 2 and 3 are often not relevant.
Like in this example, I'm likely calling loadUsers() imperatively once in a component ngOnInit.
Because of this the whole reactivity feels more like something we wanted to make happen, rather than needed to happen.

Big disadvantage of going the effect route is that it's more complicated.
There's more nesting. It's not immediately obvious how a synchronous call to loadUser results in something being pushed to input observable, especially if it's a stream of voids.
On a number of occasions I've seen people being confused about this.
I've seen people write an effect like this, which is incorrect, but ironically works for this case:

loadUsers = this.effect(() => {
  this.setLoadingState(true);
  return this.users.loadAll().pipe(
    tapResponse(
      (users) => this.addUsers(users),
      (error) => this.handleError(error),
    ),
  );
});

Right now I'm trying to decide between doubling down on effects or mixing two approaches.

[Harpush]

You function example loses switchMap which means two calls will run in parallel while the effect will cancel the old one.
You don't have the ability to react to the connection between multiple calls to the function. If you need anything other than parallel execution you are stuck.