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

[akarnokd]

Closing via #5136.

[feinstein]

@akarnokd I tried to use:

.retryWhen(errors -> errors.flatMap(error -> Observable.timer(30, TimeUnit.SECONDS)))

On a Transformer for a Single and I am getting this error:

error: incompatible types: cannot infer type-variable(s) R (argument mismatch; bad return type in lambda expression Observable cannot be converted to Publisher) where R,T are type-variables: R extends Object declared in method flatMap(Function>) T extends Object declared in class Flowable

And the squiggly lines below error -> Observable.timer(30, TimeUnit.SECONDS) say:

no instance(s) of type variable(s) R exist so that Observable conforms to Publisher

What am I doing wrong? Is this bug fixed?

[feinstein]

Using Flowable.timer instead fixes this, is this something only related to Single? Because this tutorial uses Observable.timer with no issues.

[akarnokd]

What am I doing wrong?

Please check the signatures of operators so that you are using the right types: https://github.com/ReactiveX/RxJava#base-class-vs-base-type

Because this tutorial uses Observable.timer with no issues.

That tutorial predates RxJava 2.

is this something only related to Single

retryWhen and repeatWhen use Publisher as the redo signal by design so that we can leverage backpressure to only ask for one such redo signal at a time. With Observable, there is a chance a handler would simply dump a lot of signals at once and the operators may behaved unexpectedly.

[akarnokd]

Also do not cross post questions: https://stackoverflow.com/questions/50325533/type-error-on-retrywhen-with-delay

[feinstein]

I thought about posting here the stackoverflow link, but many people just ignore links, I am glad you aren't one of those. Thank you very much for the explanation!