Interaction between variance markers and recursive generic types

Answer

The compiler first checks whether the variance marker (covariant out / +, contravariant in / -, or invariant) is satisfied by the positions in which the type parameter appears. A recursive use of the same generic type is just another occurrence of that parameter, so it must appear only in positions matching the variance:

• For a covariant parameter (out T), the recursive type may appear only in covariant positions – e.g., as a return type or in a read‑only field.
• For a contravariant parameter (in T), the recursive type may appear only in contravariant positions – e.g., as a method parameter type.
• If the parameter appears in both covariant and contravariant positions (including a mix caused by recursion), the variance annotation is illegal and the compiler rejects the declaration.

Variance markers are erased at runtime; they do not influence type erasure. The erasure step treats the generic type as if the parameter were invariant, inserting the appropriate bridge methods or casts to preserve the compile‑time subtyping rules.

Language‑specific notes

In Java, declaration‑site variance does not exist; use‑site wildcards (? extends T, ? super T) never change the class’s own variance, so a recursive class like class Node<T> { Node<T> next; } remains invariant regardless of wildcards.

In C# (and similar languages with declaration‑site variance), the rules above apply directly. For example:

// Valid covariant recursive interface
interface INode {
    T Value { get; }
    INode Next; // T appears only in covariant position (return type)
}

// Invalid – recursive use in a contravariant position
interface IBad {
    void Set(T item);
    IBad Next; // T appears in covariant position → error
}

To give a concrete recommendation, please specify the target language and its version (e.g., Java 17, C# 10, Scala 2.13).