В чем разница между dp и sp?

Что такое Unit и Nothing в Kotlin? Для чего нужен тип Nothing и какие выражения имеют такой тип?

Unit и Nothing — это два специальных типа в Kotlin, которые часто путают. Они решают разные проблемы и имеют разные роли в системе типов.

Unit

Unit — это эквивалент void в Java. Это тип для функций, которые ничего не возвращают (возвращают "единицу" или unit значение).

// Функции с Unit возвращаемым типом
fun printMessage(message: String): Unit {
    println(message)
}

// Unit опускается (по умолчанию)
fun printMessage(message: String) {
    println(message)
}

// Unit как значение
val unit: Unit = Unit
println(unit)  // kotlin.Unit

Важно: Unit имеет единственное значение — Unit. Это объект, который всегда один и тот же.

Nothing

Nothing — это специальный тип, который указывает, что функция НИКОГДА не вернёт значение. Это более "сильное" утверждение чем Unit.

// Функция, которая всегда выбрасывает исключение
fun throwException(message: String): Nothing {
    throw IllegalArgumentException(message)
}

// Функция, которая работает в бесконечном цикле
fun infiniteLoop(): Nothing {
    while (true) {
        doSomething()
    }
}

Nothing используется когда:

1. Функция выбросит исключение
2. Функция работает в бесконечном цикле
3. Функция никогда не завершится нормально

Различие

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

// Unit — выполняется и завершается
fun logError(error: Throwable): Unit {
    Log.e("Error", error.toString())
}

// Nothing — никогда не завершится нормально
fun fail(message: String): Nothing {
    throw AssertionError(message)
}

// Использование
try {
    if (user == null) {
        fail("User cannot be null")  // Nothing
    }
    println(user.name)  // Компилятор знает что user не null
} catch (e: AssertionError) {
    Log.e("Error", e.message ?: "Unknown")
}

Nothing в условных выражениях

Nothing очень полезен для типизации в когда исключение выбрасывается в одной ветке:

// Вместо этого
val value: String = if (condition) {
    "success"
} else {
    throw Exception("failed")
    "" // Этот код не достижим
}

// С Nothing это понятнее
val value: String = if (condition) {
    "success"
} else {
    fail("failed")  // Функция возвращает Nothing
}

// Компилятор понимает что вторая ветка не вернёт значение

when выражение с Nothing

// Когда перечисляешь все случаи, но один выбросит исключение
fun handleResult(result: Result): String = when (result) {
    is Success -> result.value
    is Error -> fail(result.message)  // Nothing
}

// Компилятор не требует else блока, потому что Nothing говорит что вторая ветка не вернёт

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

// DSL для конфигурации, где require выбросит исключение
inline fun buildUser(block: UserBuilder.() -> Unit): User {
    val builder = UserBuilder()
    builder.block()
    return builder.build() ?: fail("User not configured properly")
}

class UserBuilder {
    fun name(value: String) = apply { this.name = value }
    fun build(): User? = if (name != null) User(name!!) else null
}

// Использование
val user = buildUser {
    name("Alice")
}

Null-safety и Nothing

Nothing очень полезен при работе с null-safety:

fun <T> required(value: T?): T {
    return value ?: fail("Value is required")
}

val user: User = required(userOrNull)  // Типобезопасно

Когда использовать

Unit: почти всегда, когда функция ничего не возвращает (logging, обновление UI и т.д.)

Nothing: редко, но полезно для функций которые гарантированно не завершаются нормально (assertions, error handlers)

Ответ: Unit это тип для функций без возвращаемого значения, Nothing это тип для функций которые никогда не завершатся нормально (выбросят исключение или бесконечный цикл).