Java 8 - Inferring generic return type with lambdas

Question

I am trying to preserve the Generic type information from the return type of a lambda expression across some higher-order-functions in Java 8. I have simplified my actual code down to this test case. The problem is not what I expect the code to do exactly, but rather than I expect the generic type(s) R to be inferred as java.lang.String and carried through the function calls.

import java.util.function.Function;

public class AdamTest {

    public final static void main(final String args[]) {
        final AdamTest adamTest = new AdamTest();

        final String s = adamTest.thing2(7).apply(i -> i.toString());
        System.out.println(s);
    }


    private <R> R fn1(final Function<Integer, R> op) {
        return op.apply(10);
    }

    private <R> Function<Function<Integer, R>, R> thing2(final Integer val) {
        return fn1(i -> new Function<Function<Integer, R>, R>() {
                @Override
                public R apply(Function<Integer, R> op) {
                    return op.apply(val * i);
                }
            }
        );
    }
}

At the moment this code does not compile because of this line final String s = adamTest.thing2(7).apply(i -> i.toString());. I think I have something subtly wrong with my type bounds, as the compiler does not seem to be able to infer the return type of thing2(7).apply and reports Object rather than String which I was hoping for.

How do I get the generic type bounds correct so that the correct return type i.e. java.lang.String is inferred by the compiler?

Answer 1

As already said, those statements are evaluated from left to right.

To force the compiler to use the correct type, you can simply write it as

final String s = adamTest.<String>thing2(7).apply(String::valueOf);

EDIT: As per the comments, the lambda expression can be substituted by a method reference (looks cleaner).

Answer 2

I don't think that it can be fixed without casts (maybe someone knows better). An alternative is to split your statements in two lines:

Function<Function<Integer, String>, String> thing2 = adamTest.thing2(7);
final String s = thing2.apply(i -> i.toString());

Also note that thing2 can be simplified:

private <R> Function<Function<Integer, R>, R> thing2(final Integer val) {
  return fn1(i -> (op -> op.apply(val * i)));
}