Sun to Add Variance to Java in 1.5?

Ahe writes "I have been working on a joint project between Sun Microsystems, The University of Aarhus, and The Alexandra Institute. As you might know, Sun has for long been commited to adding generics to Java. Our project was to extend this with variance annotations for more flexible typing of parameterized classes and arrays. Recently Sun has released the project result as a new prototype with variance. If you like variance, please vote for this bug."

Comments

What is variance?

[DeadSea]

I've done some googling and I've come up with some quick answers. It seems it makes Java generics act more like C++ Collections in some cases.

From http://forum.java.sun.com/thread.jsp?forum=316&thr ead=389987&start=15&range=15&tstart=0&trange=1 5:

> I can't quite get my head round what combination of
> VM, compiler and/or language changes would iron out
> the following incompability between arrays and
> generics:
>
> Cat[] cats = new Cat[10];
> Animal[] animals = cats; // legal
>
> List cats = new List(10);
> List animals = cats; // illegal
> according to JSR-14

This problem is addressed in the "variance" extension to
the generic type system, which will be included in the
imminent JSR14 prototype 2.0. Details are enclosed in
the prototype.

Also a link to a MIT research paper on variance from that thread.

Re:Somebody understood something ?

[be-fan]

En anglias:

Convariance means that, you can add a Derived to a list of Base without casting.
Contravariance means that you can unpack a Derived from a list of Base without casting.
Invariance is what you have in C++, where a list of Derived and a list of Base are two different things.

Short description of variance

[Ahe]

The term variance covers co-variance, contra-variance, and bi-variance. In the 1.5 prototype you can use variance annotations on parameterized types.

+ means co-variant (think read-only).
- means contra-variant (think write-only).
* mean bi-variant (niether read nor write).

You are familiar with co-variance from arrays in Java.

When an array of Integer is a subtype of array of Number, arrays are said to be covariant in their element type. Consider:

Number[] ns = new Integer[10];

With generics, you can have a list of Numbers:

List<Number> nl = new List<Number>();

However, since generics are added without changing the JVM, nl can only refer to lists of exactly Number, e.g., this is wrong:

List<Number> nl = new List<Integer>();

So why is this wrong, consider arrays:

Number[] ns = new Integer[10];
ns[0] = new Double(0.0); // run-time error

Since ns refers to an array of Integer, we cannot put Double in to it. The mechanism that catches this is called store-check.

Since the JVM is not modified, we cannot implement a store-check for generic classes. Variance annotations allows us more flexibility, however.

Consider this method:

void copy(Collection<+Number> src, Collection<-Number> dst) {
for (Number n : src) { dst.add(n); }
}

Here we use variance annotations to state that we will only read from src and only write to dst. In this way we are allow to make a call like this:

List<Integer> il = new List<Integer>();
List<Object> ol = new List<Object>();
copy(il, ol);

Sometimes we are not interested in reading or writing elements, so we can say:

List<*> list_of_unknown_type = ...;

Then we can only use methods like size() on list_of_unknown_type.