When should use covariance and contravariance when designing a class with generic type - scala

Question

I'm learning functional programming and I'm trying to understand covariance and contravariance concept. My problem now is: I don't really know when should apply covariance and contravariance to a generic type. In specific example, yes, I can determine. But in general case, I don't know which general rule.
For example here is some rules that I have studied:
if generic type acts as parameter: using contravariance. (1)
if generic type acts as retrun value: using covariance. (2)
In some languages that I known while stuyding this concept also use those convention. For example: in keyword for covariance(In Scala is +) and out keyword for contravariance (in Scala is -). Point (1) is easy to understand. But at point (2), I see exception:
methodA(Iterator<A>) A should be covariance
methodA(Comparator<A>) A should be contravariance.
So the exception here is: although both 2 cases using generic type as input but one should be covariance and other should be contravariance. My question is: do we have any general rule to decide covariance/contravariance when designing a class.
Thanks

Answer 1

Covariance and contravariance are like the signs of numbers in arithmetic, and when you nest a position with variance in a another, the composition is different.
Compare:
1] +(+a) = +a
2] -(+a) = -a
3] +(-a) = -a
4] -(-a) = +a
and
trait +[+A] { def make(): A } // Produces an A
trait -[-A] { def break(a: A) } // Consumes an A
1]
// Produces an A after one indirection: x.makeMake().make()
trait ++[+A] { def makeMake(): +[A] }
+[+[A]] = +[A]
2]
// Consumes an A through one indirection: x.breakMake(new +[A] { override def make() = a })
trait -+[-A] { def breakMake(m: +[A]) }
-[+[A]] = -[A]
3]
// Consumes an A after one indirection: x.makeBreak().break(a)
trait +-[-A] { def makeBreak(): -[A] }
+[-[A]] = -[A]
4]
// Produces an A through one indirection
// Slightly harder to see than the others
// x.breakBreak(new -[A] { override def break(a: A) = {
// you have access to an A here, so it's like it produced an A for you
// }})
trait --[+A] { def breakBreak(b: -[A]) }
-[-[A]] = +[A]
So when you have
def method(iter: Iterator[A])
the method parameter as a whole is in a contravariant position, and the A is in a covariant position inside the Iterator, but -[+[A]] = -[A], so A is actually in a contravariant position inside this signature and the class needs to say -A. This makes sense, the outside user is passing in a bunch of As, so it ought to contravariant.
Similarly, in
def method(comp: Comparator[A])
the whole method parameter is in a contravariant position, and A is in a contravariant position inside the Comparator, so you compose them -[-[A]] = +[A] and you see that A is really in a covariant position. This also makes sense. When you pass an A into the Comparator, the outside user has control over what it does, and so it's a little like returning that A to them.