Как да осигурим безопасността на типовете в Kotlin…

Безопасността на типовете в Kotlin се осигурява по време на компилация чрез няколко ключови механизма:

Система за не-null типове: Kotlin различава референтни типове, които могат да приемат стойността null (означени с ? в края на името на типа), и тези, които не могат. Компилаторът изисква явни проверки за null или използване на безопасни извиквания (?.) и оператори (?:, !!).

// Референтен тип, който не може да бъде null
val nonNullableString: String = "Hello"

// Референтен тип, който може да бъде null
var nullableString: String? = "World"
nullableString = null // Разрешено

// Грешка при компилация: необходима е обработка на null
// val length = nullableString.length

// Безопасно извикване
val length: Int? = nullableString?.length

// Elvis оператор
val safeLength: Int = nullableString?.length ?: 0

Smart Casts: Компилаторът автоматично преобразува типа на променливата вътре в блокове if, when, while, for и други изрази след проверка на типа или null.

fun printLength(obj: Any) {
    if (obj is String) {
        // В този блок компилаторът знае, че obj е String
        println("Дължината на String е ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // В този блок компилаторът знае, че str не е null
        println("String не е null, дължина е ${str.length}")
    }
}

Генерични типове: Kotlin поддържа генеричности, които позволяват създаването на класове, интерфейси и функции, работещи с различни типове, осигурявайки безопасност на типовете по време на компилация.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Компилаторът знае, че item е String
    println(box.item.uppercase())
}
```
Ковариантност (out) и контравариантност (in): Позволяват уточняване как подтипове могат да се използват в универсални типове, предотвратявайки грешки при несъвместимост на типове по време на компилация.
```
interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Грешка при компилация
}

interface Sink<in T> {
    // fun produceT(): T // Грешка при компилация
    fun consumeT(t: T)
}
```

Sealed класове: Представляват ограничена йерархия на класове, където всички подкласове са известни по време на компилация. Това позволява на компилатора да проверява пълнотата на изразите when с подкласове на sealed класа, осигурявайки обработка на всички възможни случаи.

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val code: Int) : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Данни: ${result.data}")
        is Result.Error -> println("Грешка: ${result.code}")
        // Без 'else', компилаторът гарантира обработката на всички подкласове на sealed
    }
}

Тези механизми работят заедно, позволявайки откриването на много потенциални грешки, свързани с типовете, на ранен етап от разработката, преди изпълнението на приложението.

Как да осигурим безопасността на типовете в Kotlin?