Kotlin’s type system offers robust features for managing generics, including the concepts of covariance and contravariance. A common question among developers is how constructor parameters influence variance in Kotlin. Let’s explore this topic in a straightforward and approachable manner.

Generics and Variance in Kotlin

Before diving into the Role of Constructor Parameters in Kotlin Variance, it’s essential to grasp the basics of generics and variance:

Generics allow classes and functions to operate on different data types while maintaining type safety.

Variance defines how subtyping between more complex types relates to subtyping between their component types. In Kotlin, this is managed using the in and out modifiers.

• The out modifier indicates that a type parameter is covariant, meaning the class can produce values of that type but not consume them.
• The in modifier denotes contravariance, where the class can consume values of that type but not produce them.

The Role of Constructor Parameters

In Kotlin, constructor parameters are not considered to be in the “in” or “out” position when it comes to variance. This means that even if a type parameter is declared as “out,” you can still use it in a constructor parameter declaration without any restrictions.

For example:

class Herd<out T: Animal>(vararg animals: T) { ... }

The type parameter T is declared as “out,” but it can still be used in the constructor parameter vararg animals: T without any issues. The variance protection is not applicable to the constructor because it is not a method that can be called later, so there are no potentially dangerous method calls that need to be restricted.

However, if you use the val or var keyword with a constructor parameter, it declares a property with a getter and setter (if the property is mutable). In this case, the type parameter T is used in the “out” position for a read-only property and in both “out” and “in” positions for a mutable property.

For example:

class Herd<T: Animal>(var leadAnimal: T, vararg animals: T) { ... }

Here, the type parameter T cannot be marked as “out” because the class contains a setter for the leadAnimal property, which uses T in the “in” position. The presence of a setter makes it necessary to consider both “out” and “in” positions for the type parameter.

It’s important to note that the position rules for variance in Kotlin only apply to the externally visible API of a class, such as public, protected, and internal members. Parameters of private methods are not subject to the “in” or “out” position rules. The variance rules are in place to protect a class from misuse by external clients and do not affect the implementation of the class itself.

For instance:

class Herd<out T: Animal>(private var leadAnimal: T, vararg animals: T) { ... }

In this case, the Herd class can safely be made covariant on T because the leadAnimal property has been made private. The private visibility means that the property is not accessible from external clients, so the variance rules for the public API do not apply.

Conclusion

In Kotlin, constructor parameters are neutral regarding variance. This neutrality ensures that you can use generic types in constructors without affecting the covariant or contravariant nature of your classes. Understanding this aspect of Kotlin’s type system enables you to write more robust and flexible generic classes.

By keeping constructor parameters and variance separate, Kotlin provides a type-safe environment that supports both flexibility and clarity in generic programming.