为什么Scala中的类型参数列表中的所有不变泛型类位置都不变？

Question

I'm a bit perplexed by the strictness of the typechecker below — it seems that the invariant T position of Inv[T] is also invariant within Variantish 's parameter list:

scala> class Inv[T]
defined class Inv

scala> class Variantish[+T, +TVar <: Inv[T]]
<console>:12: error: covariant type T occurs in invariant position in type  <: Inv[T] of type TVar
       class Variantish[+T, +TVar <: Inv[T]]
                             ^

Variant types can normally occur in what look like invariant argument-list positions legally, eg with object-protected visibility:

class Variantish[+T](protected[this] var v: Inv[T])

and it seems that the following would be just as typesafe:

class Variantish[+T, +TVar <: Inv[T]](protected[this] var v: TVar)

Need that check mentioned above be so strict?

Answer 1

From the language specification (emphasis mine), about conformance (ie T' is a super-type of T ):

Type constructors T and T′ follow a similar discipline. We characterize T and T′ by their type parameter clauses [a1,…,an] and [a′1,…,a′n] , where an ai or a′i may include a variance annotation, a higher-order type parameter clause, and bounds. Then, T conforms to T′ if any list [t1,…,tn] -- with declared variances, bounds and higher-order type parameter clauses -- of valid type arguments for T′ is also a valid list of type arguments for T and T[t1,…,tn]<:T′[t1,…,tn] .

This is really difficult to understand (IMHO), but I believe it means that for Variantish to be covariant in T , you would have to be able to write

Variantish[Dog, TVar] <: Variantish[Animal, TVar]

for any TVar for which Variantish[Animal, TVar] makes sense. But this doesn't even make sense (let alone have any truth value) for some of those TVar , such as Inv[Animal] . That's why it is forbidden in that place.

Answer 2

I didn't quite understand @cyrille-corpet's answer so I expanded it with some examples.

class Inv[T]
class Variantish[+T, +TVar <: Inv[T]]

trait Animal
class Dog extends Animal

class AnimalInv extends Inv[Animal]
class DogInv extends Inv[Dog]

val a: Variantish[Animal, Inv[Animal]] = new Variantish[Animal, AnimalInv]
val b: Variantish[Animal, Inv[Animal]] = new Variantish[Animal, DogInv]
val c: Variantish[Animal, Inv[Animal]] = new Variantish[Dog, AnimalInv]
val d: Variantish[Animal, Inv[Animal]] = new Variantish[Dog, DogInv]

a is valid since Animal <: Animal and AnimalInv <: AnimalInv are both true.

b is invalid since DogInv <: AnimalInv is false.

c is valid since Dog <: Animal and AnimalInv <: AnimalInv are both true.

d is invalid since DogInv <: AnimalInv is false.

So as these show TVar cannot be covariant.

Even in the case of d where the dynamic type is valid, it is not a subtype of the static type.

I suspect if we looked at all the places where we may be using TVar in Variantish then it doesn't need to be a type parameter. As @concat pointed out any variance errors you may encounted can be solved by using the object-protected access modifier.