Почему Nothing можно использовать как любой класс?

Отличный и очень глубокий вопрос, который затрагивает основы системы типов Kotlin и её отличия от Java. Nothing — это специальный тип в Kotlin, который является предельно "нижним" (bottom) типом в иерархии. Это ключевое концептуальное отличие.

Давайте разберем по порядку, почему и как Nothing "можно использовать как любой класс".

1. Концепция Bottom-типа (Нижнего типа)

В теории типов bottom-тип — это тип, который не имеет значений и является подтипом всех других типов. В Kotlin эту роль выполняет Nothing.

• Any (или Any? в Kotlin) — это верхний тип (top type). Все классы являются его подтипами.
• Nothing — это нижний тип (bottom type). Он является подтипом всех типов, включая Any, String, Int, YourCustomClass и даже nullable-версии (String?).

Это можно представить так:

          Any? (верхний тип, супертип всего)
          /  |  \
     String  Int  YourClass ...
        \    |    /
         Nothing (нижний тип, подтип всего)

Поскольку Nothing — подтип всего, компилятор позволяет безопасно присвоить "значение" типа Nothing переменной любого другого типа. На практике самого значения не существует, но сигнатура типа работает.

2. Для чего нужен Nothing? Практическое применение

Так как создать экземпляр Nothing невозможно (класс private и не имеет конструкторов), его основное применение — обозначение вычислений, которые никогда не завершаются нормально.

a) Функции, которые всегда бросают исключение

Самая частая ситуация — функции, которые всегда завершаются с ошибкой.

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

fun example(userInput: String?): String {
    // Компилятор знает, что `fail` возвращает `Nothing` (подтип `String`)
    // Поэтому выражение `input ?: fail(...)` имеет тип `String`
    val name = userInput ?: fail("Input must not be null")
    // Компилятор "понимает", что после этого point `name` — гарантированно не-null String
    return name.uppercase()
}

Здесь fail("...") имеет тип Nothing, который является подтипом String, поэтому всё выражение userInput ?: fail(...) корректно типизируется как String. Без Nothing тип был бы Any? или потребовалась бы неуместная cast-операция.

b) Функции, которые всегда зацикливаются

fun infiniteLoop(): Nothing {
    while (true) {
        println("This never returns...")
    }
}

Тип возврата Nothing точно указывает, что функция никогда не вернёт управление.

c) TODO() — встроенная функция

Знаменитая функция TODO() из стандартной библиотеки Kotlin возвращает Nothing.

@kotlin.internal.InlineOnly
public inline fun TODO(reason: String): Nothing = throw NotImplementedError("An operation is not implemented: $reason")

fun myUnfinishedFunction(): List<String> {
    TODO("Implement parsing logic") // Корректно, т.к. `Nothing` подтип `List<String>`
}

d) Работа с пустыми коллекциями и sealed class

В обобщённых (generic) типах Nothing полезен для описания пустых состояний.

// Пустой список, который можно безопасно привести к списку любого типа
val emptyList: List<Nothing> = listOf()

// Это безопасно, т.к. List<Nothing> является подтипом List<String>
val strings: List<String> = emptyList
val ints: List<Int> = emptyList

В sealed class, представляющих результат операции (например, Success/Failure или Loading/Data/Error), Nothing может использоваться для отсутствия данных в определенных состояниях.

sealed class Result<out T : Any>
data class Success<out T : Any>(val data: T) : Result<T>()
data class Error(val exception: Throwable) : Result<Nothing>() // Здесь нет данных типа T

// Использование
fun handleResult(result: Result<User>) {
    when (result) {
        is Success -> println(result.data.name) // data имеет тип User
        is Error -> println(result.exception)   // у Error нет поля data типа User
    }
}

3. Отличие от Unit и void

• Unit — это тип с ровно одним значением (Unit). Функция возвращает Unit, когда она завершается нормально, но не производит значимого результата. Аналог void в Java, но полноценный тип.
• Nothing — это тип без значений. Функция возвращает Nothing, когда она гарантированно не завершается нормально (всегда бросает исключение или зацикливается).

4. Nullable Nothing? — особая история

Здесь есть нюанс. Nothing? — это тип, имеющий ровно одно значение: null. Он является подтипом любого nullable-типа.

val x: Nothing? = null
val s: String? = x // OK, Nothing? подтип String?
val i: Int? = x    // OK

Таким образом, null в Kotlin можно считать единственным существующим "экземпляром" типа Nothing?.

Итог

Nothing можно использовать везде не потому, что он "превращается" в любой класс, а потому что он является подтипом любого класса в системе типов Kotlin. Это фундаментальное свойство bottom-типа, которое позволяет:

1. Корректно типизировать функции, не возвращающие управления.
2. Улучшать вывод типов и flow analysis компилятора (как в примере с fail() и null-проверкой).
3. Создавать безопасные абстракции с пустыми коллекциями и sealed-иерархиями.

Это делает систему типов Kotlin более выразительной, строгой и безопасной по сравнению с Java, где подобные ситуации часто требуют заглушек (return null, return dummy value) или неконтролируемых исключений (RuntimeException).