RFE for new array type

Question

I was going to add an RFE for a new parameterized array type but first I wanted to know if anyone knew of an existing RFE for this.
It has occurred to me that the solution to the 'array problem' might be to just create a 'new' array class and implement some operator overloading. The following demostrates the basic idea though the actual implementation could be very different:
class Array<T>
    private final T[] internal;
    public final int length;
    public Array(int length)
        internal = (T[]) new Object[length];
        this.length = length;
    public T get(int element)
        return internal[element];
    public void set(int element, T item)
        internal[element] = item;
}Something else that is interesting (to me) about this is that to some degree, generics makes the array type system obsolete, at least for Object types. There's no need for a different synthetic type for each array type. Generics achieves the same goal and does it better.
The core of the request would be to implement the new array type with the overloading like the original array types such that we can do something like this:
Array<String> a = new Array<String>(10); // or new Array<String>[10];
a[0] = "test";
String s = a[0];Any comments?

Answer 1

OK, we all agree that from a theoretical standpoint
arrays of subtypes should not be assignable to arrays
of supertypes.
But what strikes me is that this knowledge has been
brought to general attention only after the
Generics extension showed us what "variance" and
related stuff really means.
Before Generics, there has not been a
pressing issue of rampant ArrayStoreExceptions in
production code!
Nor were there rampant ClassCastExceptions. The real value of generics is that it's much more expressive.
The reason for this is probably that 90% of all array
accesses are read accesses, where variance
does not pose a problem.
Right on the contrary, being able to treat a
T[] as an Object[] is extremely
convenient!
So I'm playing devil's advocate here in saying that
the initial design decision to make Java arrays
variant was actually a good one!The real issue that this is meant to address is that we cannot create arrays of generic types, only cast to them (with warnings) and the array variance rules allow for raw types to be assigned to generic type array references without warnings. The net effect is that generic array types are destabilizing to generic code. The new typesafe array type would be a work-around for this issue.