Контравариантность в Kotlin обозначается ключевым словом in и применяется к параметрам типа в дженериках, которые используются только для приёма значений (входные параметры). Это означает, что если у вас есть класс Consumer<in T>, то Consumer<SuperType> может быть присвоен переменной типа Consumer<SubType>, то есть направление подстановки типов идёт в обратную сторону по отношению к наследованию.

Это помогает обеспечить типовую безопасность, позволяя использовать более общий тип там, где ожидается более конкретный, но при этом запрещая операции, которые могут привести к ошибкам времени выполнения.

Пример:

interface Consumer<in T> {
    fun consume(item: T)
}

open class Animal
class Cat : Animal()

fun feedCat(consumer: Consumer<Cat>) {
    consumer.consume(Cat())
}

val animalConsumer: Consumer<Animal> = object : Consumer<Animal> {
    override fun consume(item: Animal) {
        println("Покормить животное")
    }
}

// Благодаря контравариантности можно передать Consumer<Animal> туда, где ожидается Consumer<Cat>
feedCat(animalConsumer)

Здесь Consumer<Animal> можно использовать как Consumer<Cat>, потому что Consumer контравариантен по типу T. Это предотвращает ошибки, связанные с неправильным использованием типов, и позволяет гибко работать с обобщёнными типами.

Можете объяснить концепцию контравариантности в дженериках Kotlin и как она влияет на типовую безопасность?