About scala variance position: What is "the enclosing parameter clause"? - scala

Question

Why the type position of a method is marked as negative?
In linked above, n.m. answered:
The variance position of a method parameter is the opposite of the variance position of the enclosing parameter clause.
The variance position of a type parameter is the opposite of the
variance position of the enclosing type parameter clause.
I don't know what the enclosing parameter clause or the enclosing type parameter clause is.
can you give an example to explain it?

Answer 1

I don't know what the enclosing parameter clause or the enclosing type
parameter clause is.
The specification defines one important axiom before stating those lines about variance:
Let the opposite of covariance be contravariance, and the opposite of
invariance be itself. The top-level of the type or template is always
in covariant position. The variance position changes at the following
constructs.
So we begin with the fact that the initial allowed variance for a type parameter is covariant, and now we flip the variance back and forth depending on specific contexts (here is an example, there are more):
Method parameters (from covariant to contravariant),
Type parameter clauses of methods
Low bounds of type parameters
Type parameters of parameterized classes, if the corresponding formal parameter is contravariant.
Now let's look at these statements again:
The variance position of a method parameter is the opposite of the
variance position of the enclosing parameter clause.
This basically means that if we have a generic method parameter, we flip the variance for it:
def m(param: T)
The enclosing parameter clause is everything defined after the method m and inside the parenthesis, which in our case include param: T. T is in a contravariant position because we had to flip it (remember, all top-level type parameters begin in a covariant position), due to the rules (rule 1).
The variance position of a type parameter is the opposite of the
variance position of the enclosing type parameter clause.
Let's define a method with a type parameter:
def m[T >: U]()
The enclosing type parameter clause is referring to the square brackets [T >: U]. Again, the variance flips because of the rules, thus U is now in a contravariant position (rule 2).
You can think about it as a game. You have a starting state (covariant, or positive), and then a set of rules which makes positions switch (covariant -> contravariant, contravariant -> covariant, invariant -> invariant). At the end of the game, you have a selected state (position) which is applied to the type parameter.
This blog post explains things in a way which one can reason about.

Answer 2

I think I know what he meant and will try to illustrate.
Given the following preconditions:
trait A
trait B extends A
trait C extends B
val bs: List[B] = List(new B{}, new B{})
val b2b: B => B = identity
A List[+T] is covariant in its type argument (enclosing type parameter clause), but the type of variable it's assignable to (enclosing type clause) is contravariant:
val as: List[A] = bs // this is valid
val cs: List[C] = bs // ...and this is not
Another example involves functions. a Function1[-T, +R] is contravariant in its arguments and covariant in its return types, but when assigning to variables the situation is reverse:
val c2a: C => A = b2b // this compiles
val a2c: A => C = b2b // ...and this does not