retryWhen method signature for with Completable and Single

[jeremy303]

When I attempt to use retryWhen to delay a retry with Completable or Single I receive an incompatible types error, as demonstrated in the following code:

        Completable.error(new RuntimeException())
                .retryWhen(new Function<Flowable<Throwable>, Publisher<Object>>() {
                    @Override
                    public Publisher<Object> apply(@io.reactivex.annotations.NonNull Flowable<Throwable> source) throws Exception {
                        return source.delay(5, TimeUnit.SECONDS); // <- Incompatible type error
                    }
                });
        
        Single.error(new RuntimeException())
                .retryWhen(new Function<Flowable<Throwable>, Publisher<Object>>() {
                    @Override
                    public Publisher<Object> apply(@io.reactivex.annotations.NonNull Flowable<Throwable> source) throws Exception {
                        return source.delay(5, TimeUnit.SECONDS); // <- Incompatible type error
                    }
                });

However, there are no issues with Observable or Flowable:

        Observable.error(new RuntimeException())
                .retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(@io.reactivex.annotations.NonNull Observable<Throwable> source) throws Exception {
                        return source.delay(5, TimeUnit.SECONDS);
                    }
                });
        Flowable.error(new RuntimeException())
                .retryWhen(new Function<Flowable<Throwable>, Publisher<?>>() {
                    @Override
                    public Publisher<?> apply(@io.reactivex.annotations.NonNull Flowable<Throwable> source) throws Exception {
                        return source.delay(5, TimeUnit.SECONDS);
                    }
                });

Looks like there is an issue with the return types for apply?

[jeremy303]

@akarnokd Sorry, I accidentally submitted the issue without my description. Now fixed. This isn't a crosspost, but appears to be a bug.

[akarnokd]

You have the wrong return type argument in the first case. Either change it to ? or Throwable.

[jeremy303]

@akarnokd Aren't the Completable runwith Function argument and return types incompatible?

public final Completable retryWhen(Function<? super Flowable<Throwable>, ? extends Publisher<Object>> handler) 

So the following retryWith lambda:

    Completable.error(new RuntimeException())
            .retryWhen(throwableFlowable -> throwableFlowable.delay(5, TimeUnit.SECONDS); 

produces the error:

Bad return type in lambda expression: Flowable<Throwable> cannot be converted to Publisher<Object>

[akarnokd]

Thanks, I see he issue now. Indeed, the Completable and Single signature for retryWhen is different from the others. repeatWhen is also off. Would you like to submit a PR?

[jeremy303]

Sure, I can do that.

Question: Should the function return type be Publisher<?> or CompletableSource<?> / SingleSource<?> ? Flowable and Observable differ in this regard.

[akarnokd]

I'd like to encourage you to think about that a bit.

[akarnokd]

Two hints:

• you'd want to retry multiple times
• you'd want to avoid ClassCastException on existing operator users