• covariant if it preserves the ordering, ≤, of types, which orders types from more specific to more generic;
• contravariant if it reverses this ordering;
• invariant if neither of these applies.

Variance where it comes:

• Reference Assignment

  
  val animal: Animal = new Cat
  ((animal: Animal) => {}) apply new Cat
  

• Method Overriding

  
  class Cat extends Animal {
    override def eat(food: Animal): Animal = food
  }
  

Variance where it comes:

• Reference Assignment

  
  val animal: Animal = new Cat
  ((animal: Animal) => {}) apply new Cat
  

• Method Overriding

Invariant (mutable) Array

final class Array[T] extends ...

ArrayStoreException: Integer

public class Unsafe{
  public static void main(String[] args){
    String[] a = new String[1];
    Object[] b = a;
    b[0] = 1; // HERE!
    System.out.println(b[0]);
  }
}

Covariant (immutable) List

sealed abstract class List[+A] extends ...

val animals: List[Animal] = List(new Cat)

Covariant (immutable) List

sealed abstract class List[+A] extends ...

Nonsense:

val what: List[Any] = 1 :: "hey" :: List()
val cats: List[Cat] = List(new Cat)
cats.contains(1) // false

Covariant (immutable) List

sealed abstract class List[+A] extends ...

Arguments can't be covariant

  def contains(elem: Any): Boolean

Null is a subclass of everything

val cat: Cat = null
val cats: List[Cat] = List(null)

null.isInstanceOf[Cat] // false

Variance where it comes:

• Reference Assignment

• Method Overriding

  
  class Cat extends Animal {
    override def eat(food: Animal): Animal = food
  }
  

Covariant Return Type

Contravariant Argument Type

Given base class and self:

class Animal              {
  def self: Animal = this }

class Cat extends Animal  {
  override
  def self:    Cat = this }

It is safe as you can see...

val a1: Animal = new Cat
val a2: Animal = a1.self

val c1:    Cat = new Cat
val c2:    Cat = c1.self

Covariant Return Type

Contravariant Argument Type

This is not allowed in Scala and most languages:

class Animal                       {
  def eat(food: Animal): Unit = () }

class Cat extends Animal           {
  override // Error: override nothing
  def eat(food: Object): Unit = () }

Shall be safe as we ask less tho.

(new Cat).eat(new Object)

Back for Function1:

• Reference Assignment

  
  val f: Function1[Cat, Animal] =
     (a: Animal) => new Cat
  

• Method Overriding

Mnemonic:

Return more when asked;
Take less when given.

Or...

Example:

val f: Function1[Cat, Animal] =
   (a: Animal) => new Cat

f :: Cat -> Animal
f = (\animal -> Cat) :: Animal -> Cat

That is,

(Cat -> Ani) < (Ani -> Cat)

Given:

trait Function1[-T, +R] extends AnyRef

If T1 > T2 (-), and R1 < R2 (+)

(T1 -> R1) < (T2 -> R2)

(Cat -> Ani) < (Ani -> Cat)

Example:

trait Function2[-T1, -T2, +R] extends AnyRef

It's the same thing

Example:

trait Function1[-T1, Function1[-T2, +R]]

It's the same thing

Example:

val f: Function1[Function1[Animal, Cat], Animal] =
             (g: Function1[Cat, Animal]) => new Cat

                            +  ->  -  ->  +

References:

• Covariance and contravariance (computer science)
• Is proper variance compatible with objects/classes?
• scala type system (1) covariance and contravariance
• +'a and -'a