Contravariance

Contravariance is a concept in type systems describing how subtyping interacts with type constructors in contravariant positions, most notably function parameter types. It contrasts with covariance, where subtyping is preserved, and with invariance, where no substitution is allowed. In practical terms, contravariance governs how the type of a value used as a function argument relates to subtyping.

A common way to illustrate contravariance is with function types. If A is a subtype of B (A <: B), then the function type B -> R is a subtype of A -> R. For example, if Cat <: Animal, then Animal -> Void is a subtype of Cat -> Void. This means a function that can accept any Animal can be used in a place that expects a function that accepts only Cats, because it is safe to pass a Cat to a function that accepts Animals.

Contravariance is particularly visible in the typing of callbacks, delegates, and consumer-like abstractions where the type parameter appears in input positions. In contrast, return types are typically covariant. Many languages implement contravariance for certain generic parameters or function types, enabling flexible and type-safe substitution of components such as event handlers and consumers. Common examples include C# with in-variance for some generic interfaces and Kotlin/Scala function and consumer types that treat parameter positions contravariantly.

In summary, contravariance reverses the usual subtyping direction for types in input positions, ensuring that more general input types can stand in for more specific ones without sacrificing type safety.