• covariant if it preserves the ordering, ≤, of types
  Subtype
  In programming language theory, subtyping or subtype polymorphism is a form of type polymorphism in which a subtype is a datatype that is related to another datatype by some notion of substitutability, meaning that program constructs, typically subroutines or functions, written to operate on...
  
  , which orders types from more specific to more generic;
• contravariant if it reverses this ordering, which orders types from more generic to more specific;
• invariant if neither of these applies.

• The operator which constructs array types
  Array data type
  In computer science, an array type is a data type that is meant to describe a collection of elements , each selected by one or more indices that can be computed at run time by the program. Such a collection is usually called an array variable, array value, or simply array...
  
   from element types is usually covariant on the base type: since String ≤ Object then ArrayOf(String) ≤ ArrayOf(Object). Note that this is only correct (i.e. type safe) if the array is immutable; if insert and remove operators are permitted, then the insert operator is covariant (e.g. one can insert a String into an ArrayOf(Object)) and the remove operator is contravariant (e.g. one can remove an Object from an ArrayOf(String)). Since the mutators have conflicting variance, mutable arrays should be invariant on the base type.
• A call to a function with a parameter of type T (defined as fun f (x : T) : Integer) can be replaced by a call to a function g (defined as fun g (x : S) : Integer) if T ≤ S. In other words, if g cares less about the type of its parameter, then it can replace f anywhere, since both return an Integer. So, in a language accepting function arguments, g ≤ f and the type of the parameter to f is said to be contravariant.
• In the general case, the type of the result is covariant.

Origin of the terms

Need for covariant argument types?

Avoiding the need for covariant argument types

Overview of covariance/contravariance in some programming languages

C++

Arrays in C# and Java

C#

D

interface IFactory {

    Object Create;

}



class X { }



class XFactory : IFactory {

    // This method implements IFactory.Create

    X Create {

        return new X;

    }

}

Java

List