retryWhen buggy and retry with delay swallows errors

[voliva]

This discussion has to do with 2 related operators that feel buggy, but I'm not sure if it can be raised as a bug.

1. retryWhen resubscribes to the source when the notifier emits more than once, without cleaning up the previous subscription.

playground https://stackblitz.com/edit/rxjs-hjjycs?file=index.ts

input$
  .pipe(
    retryWhen((error$) => error$.pipe(switchMap(() => interval(1000))))
  )
  .subscribe();

I think what would be expected when there's an error is that it will retry the subscription when the inner observable emits - but just once.

Of course you wouldn't do interval() here, but imagine this is references a stream that emits when the connection get restored - From the point there was an error, every time that the connection is restored, this operator will create a new subscription to input$, without cleaning the previous ones.

IMO it should only resubscribe once per error.

Why am I not sure to raise it as a bug? Because the operator is marked as deprecated, recommending to use retry({ delay }) instead. However:

2. retry({ delay}) swallows errors when passing in an empty observable

This is as per documented https://rxjs.dev/api/index/interface/RetryConfig, so also not a bug. However, intuition says that this variation of the operator is doing too much.

retry(n) never swallows any error. After the amount of retries have failed, the error is propagated.

I would expect that passing in an observable to say when to retry that just completes without emitting means that the error should not be retried, and instead just thrown. If someone wants to capture the error, do something with it or just swallow it, we have catchError( which can be used just after retry.

This one is more to raise for discussion. I don't think it may be worth it changing the behaviour as it would just cause more confussion.