having:

class C[T](x: T*)

and
def foo(xs : C[C[T forSome {type T;}]]) = { }

foo(new C(new C(“foo”), new C(1)));

compiles correctly

whereas

having:

def foo[T](xs : C[C[T]]) = { }

does not compile.

so you’re right the two declarations are not the same (just beautiful) but still I’m not clear why the Array’s example does not compile. Arrays apply method is parameterized like [A <: Any] but obviously a type T is ultimately an Any.

having

val t: Array[Array[T forSome {type T}]] = Array(Array(“foo”), Array(“1″))

yields the same compiler error whereas:

val t: Array[Array[T forSome {type T < : String}]] = Array(Array(“foo”), Array(“1″))

is a correct declaration.

… so far I could not use existential types to abstract different types. Am I doing something wrong?

P.S. – there is atypoe above I declared foo but invoked foo1. Just ignore this

def foo(xss : Array[Array[T forSome { type T; }]]) = for(xs < - xss) {
xs(0) = xs(1);
}

attempting to call it like:
foo1(Array(Array(“foo”), Array(3)));

yields the following compiler error :

“inferred type arguments [T forSome { type T }] do not conform to method apply’s type parameter bounds [A < : AnyRef]“

similarly:

val t: Array[Array[T forSome { type T; }]] = Array(Array(“foo”), Array(1))

is not a valid declaration.

(I’m using Scala 2.6.1)

Any thoughts?

Array(Array(“foo”), Array(1)) is a perfectly valid Array[Array[T forSome { type T; }]], but it isn’t an Array[Array[T]] for any given T. The point is that T can assume different values for different members of the outer array.

def foo[T](xss : Array[Array[T]]) = for(xs < - xss) {
xs(0) = xs(1);
}

seems to be equivalent to your example. So why using an existential type in your example?

In Java one can capture the wildcard with a T.

P.S.
I also like Scala very much and I’d like to have a better understanding of existential types although so far it seems to me that their usefulness is related with packing types without using inference of the polymorphic method