Observable.defer and Java 8 type-inference

[benjchristensen]

I'm having issues with Observable.defer and Java 8 and am not sure if there's anything we can do about it.

package io.reactivex.lab.edge;

import rx.Observable;

public class TestDefer {

    public static void main(String[] args) {
        Observable.defer(() -> {
           return Observable.from(1); 
        }).toBlockingObservable().single();
    }

}

When trying to run this from Eclipse I get this:

Exception in thread "main" java.lang.BootstrapMethodError: call site initialization exception
    at java.lang.invoke.CallSite.makeSite(CallSite.java:328)
    at java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:296)
    at io.reactivex.lab.edge.TestDefer.main(TestDefer.java:8)
Caused by: java.lang.ClassFormatError: Duplicate method name&signature in class file io/reactivex/lab/edge/TestDefer$$Lambda$1
    at sun.misc.Unsafe.defineAnonymousClass(Native Method)
    at java.lang.invoke.InnerClassLambdaMetafactory.spinInnerClass(InnerClassLambdaMetafactory.java:324)
    at java.lang.invoke.InnerClassLambdaMetafactory.buildCallSite(InnerClassLambdaMetafactory.java:194)
    at java.lang.invoke.LambdaMetafactory.altMetafactory(LambdaMetafactory.java:473)
    at java.lang.invoke.CallSite.makeSite(CallSite.java:301)
    ... 2 more

and trying to compile with JDK I get:

TestDefer.java:8: error: method defer in class Observable<T#2> cannot be applied to given types;
        Observable.defer(() -> {
                  ^
  required: Func0<? extends Observable<? extends T#1>>
  found: ()->{ retu[...]1); }
  reason: no instance(s) of type variable(s) T#3 exist so that Observable<T#3> conforms to ? extends Observable<? extends T#1>
  where T#1,T#2,T#3 are type-variables:
    T#1 extends Object declared in method <T#1>defer(Func0<? extends Observable<? extends T#1>>)
    T#2 extends Object declared in class Observable
    T#3 extends Object declared in method <T#3>from(T#3)
1 error

Java version:

java version "1.8.0_05"
Java(TM) SE Runtime Environment (build 1.8.0_05-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.5-b02, mixed mode)

[benjchristensen]

It looks like changing the generics can get it to compile.

This compiles:

    public static void main(String[] args) {
        deferB(() -> {
           return Observable.from(1); 
        }).toBlockingObservable().single();
    }

    public final static <T> Observable<T> deferB(Func0<Observable<T>> observableFactory) {
        return Observable.create(new OperatorDefer<T>(observableFactory));
    }

but this does not:

    public static void main(String[] args) {
        deferA(() -> {
           return Observable.from(1); 
        }).toBlockingObservable().single();
    }

    public final static <T> Observable<T> deferA(Func0<? extends Observable<? extends T>> observableFactory) {
        return Observable.create(new OperatorDefer<T>(observableFactory));
    }

[akarnokd]

This compiles, but isn't as slick as a one-liner.

Func0<Observable<Integer>> f = () -> Observable.from(1);
Observable.defer(f);

I can't remember if a similar question was asked on lambda-dev so you could ask about this issue there. Based on similar questions there, I guess this is one of the many limitation of the new type inference algorithm: it can't propagate types anywhere around lambdas.

[benjchristensen]

Yeah that's not okay :-)

I don't understand the co/contra-variance on the current defer implementation, especially since it doesn't seem to work.

This doesn't compile (inside CovarianceTest.java):

    @Test
    public void testDeferCovariance() {
        Observable.defer(new Func0<Observable<Movie>>() {

            @Override
            public Observable<Movie> call() {
                if(true) {
                    return Observable.from(new HorrorMovie());
                }else {
                    return Observable.from(new ActionMovie());
                }
            }

        });
    }

Right now the signature is this:

public final static <T> Observable<T> defer(Func0<? extends Observable<T>> observableFactory);

it seems to work with lambdas when changed to this:

public final static <T> Observable<T> defer(Func0<Observable<? extends T>> observableFactory);

and definitely works with this:

public final static <T> Observable<T> defer(Func0<Observable<T>> observableFactory);

Since type T is just passing through I don't understand what the ? extends is getting for us, especially since the Movie example doesn't work.

Can you help me understand why co/contra-covariance is buying us on this method? If it is not giving us anything then let's remove it so it works with lambdas. If it actually does serve some value, then let's create a new method (no idea what to call it) without co/contra-variance that works with lambdas for the far more common case.

[akarnokd]

I can't explain this, but googling around indicates this to be a javac and JLS problem. We can remove the ? extends after the Func0<. We have this pattern on several operators so might worth checking them as well.

[benjchristensen]

Thanks for the feedback. I'm going to change it to:

public final static <T> Observable<T> defer(Func0<Observable<? extends T>> observableFactory)

[benjchristensen]

I also confirmed this code works as of Eclipse Luna 4.4M7. It does not work in the Kepler version where it compiles but never actually invokes the Observable inside defer.

[benjchristensen]

Apparently that's not happy everywhere.

I need to change it to this:

Observable<T> defer(Func0<Observable<T>> observableFactory)

or leave it like this:

Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory)

in order for this code to compile:

        Observable<String> deferred = Observable.defer(new Func0<Observable<String>>() {

            @Override
            public Observable<String> call() {
                return null;
            }

        });

Have I mentioned before that I don't like dealing with ? extends/? super generics?!

I want to make it like this:

Observable<T> defer(Func0<Observable<T>> observableFactory)

[benjchristensen]

I really dislike generics.

The only way to keep these 3 compiling is to leave the code as is:

        Observable<Movie> d = Observable.defer(new Func0<Observable<? extends Movie>>() {

            @Override
            public Observable<? extends Movie> call() {
                if (true) {
                    return Observable.from(new ActionMovie());
                } else {
                    return Observable.from(new HorrorMovie());
                }
            }

        });

        Observable<String> deferred = Observable.defer(new Func0<Observable<? extends String>>() {

            @Override
            public Observable<? extends String> call() {
                return null;
            }
        });

        Observable<String> deferred2 = Observable.defer(new Func0<Observable<String>>() {

            @Override
            public Observable<String> call() {
                return null;
            }
        });

But this doesn't work with Java 8 lambdas.

The only thing I can think of doing is having a different operator without ? extends for the simple cases and supported by lambdas ... and leaving defer for the complicated ones using anonymous inner classes.

defer(Func0<? extends Observable<? extends T>> observableFactory)

someOtherName(Func0<Observable<T>> observableFactory)

Then comes the naming challenge ...

• there is no other overload of from that takes a Func so we could use that

from(Func0<Observable<T>> observableFactory)

• or it could be a factory:

factory(Func0<Observable<T>> observableFactory)
... or ...
fromFactory(Func0<Observable<T>> observableFactory)

The type of code this is trying to cater to is like this: https://github.com/benjchristensen/ReactiveLab/blob/master/reactive-lab-edge/src/main/java/io/reactivex/lab/edge/EdgeServer.java#L46

@headinthebox What do you think the right solution is for this?

[akarnokd]

The issue might be with the Java 8 compiler. There are some changes coming up in 8u20 which might affect this for the better. Also, it might be worth posting a question on lambda-dev.

[akarnokd]

This works in Eclipse 4.4M7 for me with RxJava 0.18.3:

public class Test1 {
    public static void main(String[] args) {
        System.out.println(defer(() -> (() -> 1)).get());

        Observable.defer(() -> Observable.from(1)).subscribe(System.out::println);
    }
    @SuppressWarnings("unchecked")
    public static <T> Supplier<T> defer(Supplier<? extends Supplier<? extends T>> func) {
        return (Supplier<T>)func.get();
    }
}

[benjchristensen]

Try compiling that code from Java 8:

lgml-bechristensen:tmp benjchristensen$ /Library/Java/JavaVirtualMachines/jdk1.8.0/Contents/Home/bin/javac -cp rxjava-core-0.18.3.jar TestDefer.java 
TestDefer.java:9: error: method defer in class Observable<T#2> cannot be applied to given types;
        Observable.defer(() -> Observable.from(1)).subscribe(System.out::println);
                  ^
  required: Func0<? extends Observable<? extends T#1>>
  found: ()->Observ[...]om(1)
  reason: no instance(s) of type variable(s) T#3 exist so that Observable<T#3> conforms to ? extends Observable<? extends T#1>
  where T#1,T#2,T#3 are type-variables:
    T#1 extends Object declared in method <T#1>defer(Func0<? extends Observable<? extends T#1>>)
    T#2 extends Object declared in class Observable
    T#3 extends Object declared in method <T#3>from(T#3)
1 error

This is with javac 1.8.0_05