I have installed the last JDK 8 ea b114 to test the new language features. However the inference in chained calls seems not to work yet.
If I write:
Iterator<String> it = new ArrayList<>().iterator();
the compiler give me an error.
However inference in argument position works well.
Maybe inference in chained calls will not be inserted?
Type inference is a Java compiler's ability to look at each method invocation and corresponding declaration to determine the type argument (or arguments) that make the invocation applicable.
Java SE 7 supports limited type inference for generic instance creation; you can only use type inference if the parameterized type of the constructor is obvious from the context.
The Target-Type of an expression is the data type that the Java Compiler expects depending on where the expression appears. Java 8 supports inference using Target-Type in a method context.
Type inference represents the Java compiler's ability to look at a method invocation and its corresponding declaration to check and determine the type argument(s). The inference algorithm checks the types of the arguments and, if available, assigned type is returned.
As @Holger said, Java 8 improved contextual inference so that this works_
public static <T> Iterator<T> iter(Iterable<T> i)
{
return i.iterator();
}
public static void main(String[] args)
{
Iterator<String> it = iter( new ArrayList<>() );
\____________________________/
}
It didn't work in Java 7 — the inference on new ArrayList<>()
could not depend on context.
It'll be a huge change to the language to do what you want in the question. John Rose started a similar discussion, see http://mail.openjdk.java.net/pipermail/lambda-dev/2013-July/010531.html
Too much inference and too much contextual dependency can be a bad thing. It's not so much that the compiler cannot handle the complexity - it can. It's about whether human programmers can handle it. I am sensing that Java 8 is already at a dangerous level that the codes will be difficult for humans to parse.
The latest specification (Public Review) is available at jcp.org. There is a paragraph in part D which discusses this point.
The receiver in a method invocation, field access, etc. (exp.foo()) is not a poly expression because the target type is unknown—it would be impossible to enumerate every type that has a particular member (foo, in this case). There has been some interest in allowing inference to "chain": in a().b(), passing type information from the invocation of b to the invocation of a. This adds another dimension to the complexity of the inference algorithm, as partial information has to pass in both directions; it only works when the erasure of the return type of a() is fixed for all instantiations (e.g. List). This feature would not fit very well into the poly expression model, since the target type cannot be easily derived.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With