// generic array creation in java:
class cl1 {}
class cl2 extends cl1 {}

class clgen<A>
{
    void f()
    {
      //A[] x = new A[4]; // won't compile, generic array creation error.
      //var xx = new java.util.ArrayList<cl1>[4]; //SAME ERROR!
      //clgen<cl1>[] R = new clgen<cl1>[5];  // SAME ERROR!

      clgen<cl1> u;
      //u = new clgen<cl2>(); //won't compile and shouldn't

      /* Can't mix invariant classes with covariant arrays at all.

           Suppose above line for R compiled, then since arrays are covariant,

           clgen<cl2>[] R2 = new clgen<cl2>[5]; // should also compile
           R2[0] = new clgen<cl2>();  // R2 is a clgen<cl2> object

           Object[] R3 = R2; // would compile because arrays are covariant

           // this violates the invariance of generics:
           u = (clgen<cl1>)R3[0];  // the type of u is static clgen<cl1>
           // but actual type of object is clgen<cl2>.

           But all this is futile:
      */
      clgen<cl2>[] R2 = (clgen<cl2>[]) new clgen[5]; //compiles with warning
      R2[0] = new clgen<cl2>();  // compiles
      Object[] R3 = R2;   // compiles because arrays are still covariant
      u = (clgen<cl1>)R3[0]; // THIS COMPILES: u is assigned to a
      //  clgen<cl2> object, which again violates the static invariance of
      //  of generic classes.

      // Java's answer is to not use arrays but ArrayList and other generic
      // classes.  You're supposed to use arrays only for very small, isolated
      // purposes.  But the lack of overloaded syntax on arrays make this
      // rather painful...
    }
}//clgen