Covariant Return and Contravariant Arguments

Covariant Return and Contravariant Arguments

As we know, to a variable of function type may be assigned a closure with compatible return type and compatible argument types. "Compatible return type" means that the type is either the same as in function type or is a subclass of this type (return types are covariant).

  { => Number } p1 = 
    { => Integer.valueOf(19) };  // Integer is a subclass of Number
  { => Number } p2 = 
    { => Double.valueOf(1.25) };  // Double is a subclass of Number
  

"Compatible argument type" means that the argument type is either the same as in function type or is a superclass of this type (argument types are contravariant).

  { String => void } p = 
    // Object is a superclass of String
    { Object o => System.out.println(o); };
  

We can combine covariant return with contravariant arguments:

  { String => Number } p = { Object o => Integer.valueOf(o.hashCode()) };
  System.out.println(p.invoke("haf"));
  

These rules define hierarchy on function types. So a function type might be a subtype or supertype of another function type. For example, { => Integer } is a subtype of { => Number } and { String => void } is a supertype of { Object => void }. As for class types, to a variable of function type may be assigned an object (closure) of its type or any subtype.

What is meant by covariant and contravariant?
Let S and T be two types (classes or function types) such that S is a subtype of T. If method m of T is overridden in S, then the corresponding types from the m's signature can either preserve the relationship between S and T (i.e. the type used in S is a subtype of the corresponding type in T), reverse this relationship (i.e. the type used in S is a supertype of that in T), or neither preserve nor reverse this relationship. If they preserve the relationship of S and T, we say they are covariant, and if they reverse the relationship of S and T, we say they are contravariant.