2.x: compose() generics

[ZacSweers]

Migrating some of our code to RxJava 2, we've run into some issues around transformers due to the following signature change:

// 1
public <R> Observable<R> compose(Transformer<? super T, ? extends R> transformer) {
    
    return ((Transformer<T, R>) transformer).call(this);

}

// 2
public final <R> Observable<R> compose(ObservableTransformer<T, R> composer) {
    
    return wrap(composer.apply(this));

}

Was this intentionally narrowed? If not, open to a PR to add back the ? super semantics?

[akarnokd]

Do you have an example that doesn't compile for you without ? super? We have to be careful with such variance changes because it may break current users.

[ZacSweers]

Whoops just saw your response. I'll put together a sample later tonight

[ZacSweers]

So here's an example where an observable emits A instances down the stream and transforms them into B instances.

interface A<T, R> {}
interface B<T> {}

// RxJava 1
static <T> rx.Observable.Transformer<A<T, ?>, B<T>> oldStyle() {
    return new rx.Observable.Transformer<A<T, ?>, B<T>>() {
        @Override
        public rx.Observable<B<T>> call(rx.Observable<A<T, ?>> a) {
            return rx.Observable.empty();
        }
    };
}

// RxJava 2
static <T> ObservableTransformer<A<T, ?>, B<T>> newStyle() {
    return new ObservableTransformer<A<T, ?>, B<T>>() {
        @Override
        public ObservableSource<B<T>> apply(Observable<A<T, ?>> a) {
            return Observable.empty();
        }
    };
}

void test() {
    
    A<String, Integer> a = new A<String, Integer>() { };

    // RxJava 1
    rx.Observable.just(a)
            .compose(TransformersTest.<String>oldStyle())  // Yay, because Integer is irrelevant here
            .subscribe(new Action1<B<String>>() {
                @Override
                public void call(B<String> stringB) {

                }
            });

    // RxJava 2
    Observable.just(a)
            .compose(TransformersTest.<String>newStyle())   // This doesn't compile
            .subscribe(new Consumer<B<String>>() {
                @Override
                public void accept(B<String> tB) throws Exception {

                }
            });
}

In the RxJava 2 example, the compose() line there doesn't compile because of generics issues.

In order to make it compile, the transformer signature needs to be changed to be like the following:

static <T, R> ObservableTransformer<A<T, R>, B<T>> newStyle() {
    return new ObservableTransformer<A<T, R>, B<T>>() {
        @Override
        public ObservableSource<B<T>> apply(Observable<A<T, R>> a) {
            return Observable.empty();
        }
    };
}

And imposes some boilerplate on the consumer in that they now have to specify the second type even though it's irrelevant.

Observable.just(a)
        .compose(TransformersTest.<String, Integer>newStyle())  // :(
        .subscribe(new Consumer<B<String>>() {
            @Override
            public void accept(B<String> tB) throws Exception {

            }
        });

[akarnokd]

Okay, please verify that with the variance changes it compiles with Java 6, 7 and 8 targets.