Обобщения: 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(). Это наш подход к вариативности в месте использования, и он соответствует Array<? extends Object> Java, будучи немного проще.

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

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

Array<in String> соответствует Array<? super String> Java. Это означает, что вы можете передать массив 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>. Это означает, что вы не можете безопасно записывать в Foo<*> способом, когда T неизвестен.

• Для 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?>.

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

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

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.

Проверки и преобразования типов обобщённых типов

Из-за стирания типов нет универсального способа проверить во время выполнения, был ли экземпляр обобщённого типа создан с определёнными аргументами типа, и компилятор запрещает такие проверки типа, как is—проверки, такие как ints is List<Int> или list is T (параметр типа). Однако вы можете проверить экземпляр на соответствие звёздно-проецированному типу:

if (something is List<*>) {
    something.forEach { println(it) } // The items are typed as `Any?`
}

Аналогично, когда у вас уже есть аргументы типа экземпляра, проверенные статически (во время компиляции), вы можете выполнить проверку is или преобразование, которое затрагивает необобщённую часть типа. Обратите внимание, что угловые скобки в этом случае опущены:

fun handleStrings(list: MutableList<String>) {
    if (list is ArrayList) {
        // `list` is smart-cast to `ArrayList<String>`
    }
}

Тот же синтаксис, но с опущенными аргументами типа, может использоваться для преобразований, которые не учитывают аргументы типа: list as ArrayList.

Аргументы типа вызовов обобщённых функций также проверяются только во время компиляции. Внутри тел функций параметры типа не могут использоваться для проверок типа, и преобразования типа к параметрам типа (foo as T) не проверяются. Единственным исключением являются встроенные функции с реализованными параметрами типа, у которых фактические аргументы типа вставляются в каждом месте вызова. Это позволяет проверять типы и выполнять преобразования для параметров типа. Однако описанные выше ограничения всё ещё применяются к экземплярам обобщённых типов, используемым внутри проверок или преобразований. Например, в проверке типа arg is T, если arg является экземпляром обобщённого типа, его аргументы типа всё равно стираются.

//sampleStart
inline fun <reified A, reified B> Pair<*, *>.asPairOf(): Pair<A, B>? {
    if (first !is A || second !is B) return null
    return first as A to second as B
}

val somePair: Pair<Any?, Any?> = "items" to listOf(1, 2, 3)


val stringToSomething = somePair.asPairOf<String, Any>()
val stringToInt = somePair.asPairOf<String, Int>()
val stringToList = somePair.asPairOf<String, List<*>>()
val stringToStringList = somePair.asPairOf<String, List<String>>() // Compiles but breaks type safety!
// Expand the sample for more details

//sampleEnd

fun main() {
    println("stringToSomething = " + stringToSomething)
    println("stringToInt = " + stringToInt)
    println("stringToList = " + stringToList)
    println("stringToStringList = " + stringToStringList)
    //println(stringToStringList?.second?.forEach() {it.length}) // This will throw ClassCastException as list items are not String
}

Преобразования типов без проверки

Преобразования типов к обобщённым типам с конкретными аргументами типа, такими как foo as List<String>, не могут быть проверены во время выполнения.
Эти преобразования типов без проверки могут использоваться, когда безопасность типа подразумевается логикой программы высокого уровня, но не может быть выведена непосредственно компилятором. См. пример ниже.

fun readDictionary(file: File): Map<String, *> = file.inputStream().use { 
    TODO("Read a mapping of strings to arbitrary elements.")
}

// We saved a map with `Int`s into this file
val intsFile = File("ints.dictionary")

// Warning: Unchecked cast: `Map<String, *>` to `Map<String, Int>`
val intsDictionary: Map<String, Int> = readDictionary(intsFile) as Map<String, Int>

Для преобразования в последней строке появляется предупреждение. Компилятор не может полностью проверить его во время выполнения и не даёт гарантии, что значения в карте являются Int.

Чтобы избежать преобразований типов без проверки, можно переработать структуру программы. В приведённом выше примере вы могли бы использовать интерфейсы DictionaryReader<T> и DictionaryWriter<T> с безопасными по типу реализациями для разных типов. Можно ввести разумные абстракции, чтобы перенести преобразования типов без проверки из места вызова в детали реализации. Правильное использование вариативности обобщённых типов также может помочь.

Для обобщённых функций использование реализованных параметров типа делает преобразования типа, такие как arg as T, проверяемыми, если тип arg не имеет своих собственных аргументов типа, которые стираются.

Предупреждение о преобразовании типа без проверки можно подавить, пометив оператор или объявление, где оно возникает, аннотацией @Suppress("UNCHECKED_CAST"):

inline fun <reified T> List<*>.asListOfType(): List<T>? =
    if (all { it is T })
        @Suppress("UNCHECKED_CAST")
        this as List<T> else
        null