Что такое конструкция to в List?

Конструкция to в Kotlin для создания пар (Pairs)

Конструкция to в контексте List в Kotlin — это на самом деле не специфическая конструкция для списков, а инфиксная функция (infix function) с именем to, которая используется для создания пар Pair<A, B>. Она часто применяется при инициализации коллекций, включая списки, через функции типа listOf().

Что такое to на самом деле?

Функция to определена в стандартной библиотеке Kotlin как расширение для любого типа:

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

Ключевые моменты:

• infix — позволяет вызывать функцию без точки и скобок
• Принимает один параметр that любого типа B
• Возвращает объект Pair<A, B>, где A — тип получателя, B — тип параметра

Использование с List

Чаще всего to встречается при создании списков пар или ассоциативных списков (Map):

// Создание списка пар
val pairs: List<Pair<String, Int>> = listOf(
    "apple" to 1,
    "banana" to 2,
    "orange" to 3
)

// Эквивалент без infix функции:
val pairsExplicit = listOf(
    Pair("apple", 1),
    Pair("banana", 2),
    Pair("orange", 3)
)

Распространённые сценарии использования

1. Создание Map

Наиболее частый случай — инициализация ассоциативных массивов:

val fruitMap: Map<String, Int> = mapOf(
    "apple" to 100,
    "banana" to 50,
    "orange" to 75
)

// Для изменяемого Map
val mutableFruitMap = mutableMapOf(
    "apple" to 100,
    "banana" to 50
)
mutableFruitMap["orange"] = 75

2. Деструктуризация в циклах

При итерации по списку пар:

val countries = listOf("RU" to "Russia", "US" to "USA", "FR" to "France")

for ((code, name) in countries) {
    println("Code: $code, Name: $name")
}

// Или с использованием forEach
countries.forEach { (code, name) ->
    println("$code = $name")
}

3. В сложных структурах данных

// Список сложных пар
val complexPairs = listOf(
    (1..5).toList() to "range_1_5",
    listOf("a", "b", "c") to "letters"
)

// Пара как промежуточный результат
val transformed = listOf(1, 2, 3, 4, 5)
    .map { it to (it * it) }  // Создаём пары (число, квадрат)
    .filter { (_, square) -> square % 2 == 0 }  // Деструктуризация в фильтре
    .toMap()  // Преобразуем в Map

Преимущества использования to

1. Лаконичность синтаксиса — более читабельно, чем явное создание Pair()
2. Естественный вид — "key" to value интуитивно понятен
3. Безопасность типов — сохраняет информацию о типах
4. Совместимость — работает с любыми типами, даже nullable

// С nullable типами
val nullablePairs = listOf(
    "token" to null,
    null to "default"
)

Важные особенности

Равенство пар

Пары сравниваются по содержимому:

val pair1 = "a" to 1
val pair2 = Pair("a", 1)
println(pair1 == pair2)  // true - структурное равенство
println(pair1 === pair2) // false - разные объекты в памяти

Неизменяемость

Pair — иммутабельный (неизменяемый) класс данных:

val pair = "key" to "value"
// pair.first = "newKey"  // Ошибка компиляции - val параметр

Альтернативы для списков

Для создания списков обычно используют listOf() без пар, но если нужны именно пары:

// Альтернативный способ создать список пар
val zippedPairs = listOf("a", "b", "c").zip(listOf(1, 2, 3))
// Результат: [("a", 1), ("b", 2), ("c", 3)]

Практический пример

data class User(val id: Int, val name: String)

// Преобразование списка пользователей в список пар
val users = listOf(
    User(1, "Alice"),
    User(2, "Bob"),
    User(3, "Charlie")
)

// Создание списка пар (id, name)
val idNamePairs: List<Pair<Int, String>> = users.map { user ->
    user.id to user.name
}

// Преобразование в Map
val userMap: Map<Int, String> = idNamePairs.toMap()
// или напрямую
val userMapDirect = users.associate { it.id to it.name }

Вывод: Конструкция to — это не специальная возможность для List, а универсальная инфиксная функция Kotlin для создания пар, которая особенно удобна при работе со списками пар и ассоциативными массивами. Она делает код более чистым и выразительным при работе с парами значений в коллекциях.