Variance of function

Question

sealed trait Sum[+A, +B] {
  def flatMap[A, C](f: B => Sum[A, C]): Sum[A, C] =
    this match {
      case Failure(v) => Failure(v)
      case Success(v) => f(v)
    }
} 

Isn't it said that function parameters are contra-variant and the results co-variant? Why does the compiler say that A is in a contra-variant position? I am expecting compiler to complain that B is in a contra-variant position instead.

Can someone explain to me why this is so ? Feeling confused.

Answer 1

I assume you actually meant to write:

sealed trait Sum[+A, +B] {
  def flatMap[C](f: B => Sum[A, C]): Sum[A, C] = // No shadowing of A
    this match {
      case Failure(v) => Failure(v)
      case Success(v) => f(v)
    }
}

Take a look at flatMap again:

def flatMap[C](f: B => Sum[A, C]): Sum[A, C]

Let's rewrite it a bit:

def flatMap[C]: (B => Sum[A, C]) => Sum[A, C]

Let's build up the type from the inside out.

Sum[A, C]

A is a parameter to Sum, which is normally a covariant position.

B => Sum[A, C]

Sum[A, C] is the result of a function, which is normally a covariant position. These two combine, and you have A in a covariant position still.

(B => Sum[A, C]) => Sum[A, C]

B => Sum[A, C] is also the parameter of a function, so the entire thing is in contravariant position. Since A was in a covariant position before, the variances combine and A is now in a contravariant position.

Looking at B:

B => Sum[A, C]

Parameter of a function, which is normally a contravariant position.

(B => Sum[A, C]) => Sum[B, C]

The entire function is also the parameter to another function, so the contravariances cancel out and B is sitting in a covariant position.

You can also draw a nifty analogy. Look at the definition of a covariant and contravariant type parameter:

trait Co[+A]; trait Con[-A]

They look like positive and negative numbers, just a bit. Now, remember the rules for multiplication and signs you learned in elementary:

• (+) * (+) = (+)
• (+) * (-) = (-)
• (-) * (+) = (-)
• (-) * (-) = (+)

This is analogous to (if you squint a bit)

• Co[Co[A]] => A is in a covariant position
• Co[Con[A]] => A is in a contravariant position
• Con[Co[A]] => A is in a contravariant position
• Con[Con[A]] => A is in a covariant position.