Обобщения: in, out, where

Вариативность на уровне объявления

Предположим, что существует обобщенный интерфейс Source<T> , у которого нет методов, принимающих T в качестве параметра, только методы, возвращающие T:

// Java
interface Source<T> {
    T nextT();
}

Тогда было бы совершенно безопасно хранить ссылку на экземпляр Source<String> в переменной типа Source<Object> — нет методов-потребителей для вызова. Но Java этого не знает и все равно запрещает это:

// Java
void demo(Source<String> strs) {
    Source<Object> objects = strs; // !!! Not allowed in Java
    // ...
}

Чтобы исправить это, вы должны объявить объекты типа Source<? extends Object> . Это бессмысленно, потому что вы можете вызывать те же самые методы на такой переменной, как и раньше, так что больше нет пользы от более сложного типа. Но компилятор этого не знает.

В Kotlin есть способ объяснить компилятору подобные вещи. Это называется вариативностью на уровне объявления: вы можете добавить аннотацию к параметру типа T класса Source , чтобы убедиться, что он только возвращается (производится) из членов Source<T>, и никогда не потребляется. Для этого используйте модификатор out:

interface Source<out T> {
    fun nextT(): T
}

fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs // This is OK, since T is an out-parameter
    // ...
}

Общее правило таково: когда параметр типа T класса C объявлен как out, он может встречаться только в позиции out в членах C, но в ответ C<Base> может безопасно быть супертипом C<Derived>.

Другими словами, вы можете сказать, что класс C ковариантен по параметру T, или что T является ковариантным параметром типа. Вы можете представить C как производителя T и не потребителя T.

Модификатор out называется аннотацией вариативности, и поскольку он предоставляется на уровне объявления параметра типа, он обеспечивает вариативность на уровне объявления. Это в отличие от вариативности на уровне использования Java, где символы подстановочных знаков в использовании типов делают типы ковариантными.

В дополнение к out, Kotlin предоставляет дополнительную аннотацию вариативности: in. Она делает параметр типа контравариантным, то есть он может использоваться только для потребления, а не для производства. Хорошим примером контравариантного типа является Comparable:

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
    x.compareTo(1.0) // 1.0 has type Double, which is a subtype of Number
    // Thus, you can assign x to a variable of type Comparable<Double>
    val y: Comparable<Double> = x // OK!
}

Слова in и out, кажется, самоочевидны (так как они уже успешно используются в C# довольно долго), и поэтому вышеупомянутая мнемоника не особо нужна. Ее на самом деле можно перефразировать на более высоком уровне абстракции:

Сущностное преобразование: Потребитель in, Производитель out!:-)

Изменчивость на месте использования: проекции типов

Очень легко объявить параметр типа T как out и избежать проблем с подтипированием на месте использования, но некоторые классы не могут быть ограничены только возвращением T! Хорошим примером этого является Array:

class Array<T>(val size: Int) {
    operator fun get(index: Int): T { ... }
    operator fun set(index: Int, value: T) { ... }
}

Этот класс не может быть ни ковариантным, ни контравариантным по отношению к T. И это накладывает определённые ограничения. Рассмотрим следующую функцию:

fun copy(from: Array<Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}

Эта функция должна копировать элементы из одного массива в другой. Попробуем применить её на практике:

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3) { "" } 
copy(ints, any)
//   ^ type is Array<Int> but Array<Any> was expected

Здесь вы столкнётесь с той же знакомой проблемой: Array<T> является инвариантным по отношению к T, и ни Array<Int>, ни Array<Any> не являются подтипом друг друга. Почему? Опять же, это связано с тем, что copy может иметь неожиданное поведение, например, оно может попытаться записать String в from, и если вы действительно передадите массив Int, то позже будет выброшено исключение ClassCastException.

Чтобы запретить функции copy записывать в from, вы можете сделать следующее:

fun copy(from: Array<out Any>, to: Array<Any>) { ... }

Это проекция типа, что означает, что from не является простым массивом, а является ограниченным (проецированным) массивом. Вы можете вызывать только методы, которые возвращают параметр типа T, что в данном случае означает, что вы можете вызывать только get(). Это наш подход к изменчивости на месте использования, и он соответствует изменчивости Java Array<? extends Object>, будучи несколько проще.

Вы можете спроецировать тип с in также:

fun fill(dest: Array<in String>, value: String) { ... }

Array<in String> соответствует изменчивости Java Array<? super String>. Это означает, что вы можете передать массив CharSequence или массив Object в функцию fill().

Проекции со звёздочкой

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

Kotlin предоставляет синтаксис для так называемых проекций со звёздочкой:

• Для Foo<out T : TUpper>, где T — ковариантный параметр типа с верхним ограничением TUpper, Foo<*> эквивалентно Foo<out TUpper>. Это означает, что когда T неизвестен, вы можете безопасно читать значения TUpper из Foo<*>.

• Для Foo<in T>, где T — контравариантный параметр типа, Foo<*> эквивалентно Foo<in Nothing>. Это означает, что когда T неизвестен, нет безопасного способа записывать в Foo<*>.

• Для Foo<T : TUpper>, где T — инвариантный параметр типа с верхним ограничением TUpper, Foo<*> эквивалентно Foo<out TUpper> для чтения значений и Foo<in Nothing> для записи значений.

Если у обобщённого типа несколько параметров типа, каждый из них может быть спроецирован независимо. Например, если тип объявлен как interface Function<in T, out U>, вы можете использовать следующие проекции со звёздочкой:

• Function<*, String> означает Function<in Nothing, String>.

• Function<Int, *> означает Function<Int, out Any?>.

• Function<*, *> означает Function<in Nothing, out Any?>.

Верхние границы

Наиболее распространённым типом ограничения является верхняя граница, которая соответствует ключевому слову Java extends:

fun <T : Comparable<T>> sort(list: List<T>) {  ... }

Тип, указанный после двоеточия, является верхней границей, указывающей, что только подтип Comparable<T> может быть заменён на T. Например:

sort(listOf(1, 2, 3)) // OK. Int is a subtype of Comparable<Int>
sort(listOf(HashMap<Int, String>())) // Error: HashMap<Int, String> is not a subtype of Comparable<HashMap<Int, String>>

По умолчанию верхней границей (если она не указана) является Any?. Внутри угловых скобок может быть указана только одна верхняя граница. Если одному и тому же параметру типа нужно более одной верхней границы, вам нужна отдельная where-строка:

fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence,
          T : Comparable<T> {
    return list.filter { it > threshold }.map { it.toString() }
}

Передаваемый тип должен удовлетворять всем условиям в where строке одновременно. В приведённом выше примере тип T должен реализовывать как CharSequence, так и Comparable.