Compile error: "'<>' cannot be used with anonymous classes"

Question

I would so much rather like to write this:

Lists.transform(vals,
    new Function<>() {
        public List<ValEntry> apply(Validator<? super T> input) {
            return input.validate(value);
        }
    });

...than this:

Lists.transform(vals,
    new Function<Validator<? super T>, List<ValEntry>>() {
        public List<ValEntry> apply(Validator<? super T> input) {
            return input.validate( value );
        }
    });

But the Java compiler gives me the following error message:

'<>' cannot be used with anonymous classes

Is there a fundamental reason for this? Or did the just skip the feature in JDK 7, maybe they do it in 8?

A [proposal to implement diamond anonymous types](https://bugs.openjdk.java.net/browse/JDK-8062373) is now part of Project Coin. But it seems kind of moot to me now since the introduction of lambda expressions. — Lii, Jun 10 '15 at 07:17

Craig P. Motlin · Accepted Answer · 2015-11-06T17:49:29.570

16

According to the project coin documentation:

Internally, a Java compiler operates over a richer set of types than those that can be written down explicitly in a Java program. The compiler-internal types which cannot be written in a Java program are called non-denotable types. Non-denotable types can occur as the result of the inference used by diamond. Therefore, using diamond with anonymous inner classes is not supported since doing so in general would require extensions to the class file signature attribute to represent non-denotable types, a de facto JVM change. It is feasible that future platform versions could allow use of diamond when creating an anonymous inner class as long as the inferred type was denotable.

EDIT So it's possible in a future version. It's still not possible with Java 8, but now we have lambdas, so there's less of a need.

edited Nov 06 '15 at 17:49

answered Dec 28 '11 at 00:39

Craig P. Motlin

26,452
17
99
126

1

Thanks for the research. The internals of generics and type inference are interesting but complicated things. – Lii Jan 21 '12 at 16:41
4

I still don't get it. Why does adding a class body to a constructor invocation disable the diamond operator from inferring the type parameters? `ArrayList a = new ArrayList<>();` is legal but `ArrayList a = new ArrayList<>() {};` is not. The type parameter is pretty clearly `String`. Why can't the class file for the anonymous type say that? – thejoshwolfe Apr 09 '13 at 06:00
Still not possible with java 8 – gontard Nov 06 '15 at 10:52

score 4 · Answer 2 · answered Apr 15 '16 at 19:29

This is now scheduled to be included in Java 9. From JEP 213: Milling Project Coin:

Allow diamond with anonymous classes if the argument type of the inferred type is denotable. Because the inferred type using diamond with an anonymous class constructor could be outside of the set of types supported by the signature attribute, using diamond with anonymous classes was disallowed in Java SE 7. As noted in the JSR 334 proposed final draft, it would be possible to ease this restriction if the inferred type was denotable.

Compile error: "'<>' cannot be used with anonymous classes"

2 Answers2

Linked