Como garantir a segurança de tipos em Kotlin?

A segurança de tipos em Kotlin é garantida em tempo de compilação através de vários mecanismos-chave:

Sistema de tipos não nulos: Kotlin distingue entre tipos referenciados que podem aceitar o valor null (indicados com ? no final do nome do tipo) e aqueles que não podem. O compilador exige verificações explícitas de null ou o uso de chamadas seguras (?.) e operadores (?:, !!).

// Referência que não pode ser null
val nonNullableString: String = "Hello"

// Referência que pode ser null
var nullableString: String? = "World"
nullableString = null // Permitido

// Erro de compilação: é necessário tratar null
// val length = nullableString.length

// Chamada segura
val length: Int? = nullableString?.length

// Operador Elvis
val safeLength: Int = nullableString?.length ?: 0

Casts inteligentes (Smart Casts): O compilador converte automaticamente o tipo de uma variável dentro de blocos if, when, while, for e outras expressões após verificar o tipo ou null.

fun printLength(obj: Any) {
    if (obj is String) {
        // Dentro deste bloco, o compilador sabe que obj é String
        println("Comprimento de String é ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Dentro deste bloco, o compilador sabe que str não é null
        println("String não é null, comprimento é ${str.length}")
    }
}

Tipos genéricos (Generics): Kotlin suporta genéricos, que permitem criar classes, interfaces e funções que trabalham com diferentes tipos, garantindo a segurança de tipos em tempo de compilação.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // O compilador sabe que item é do tipo String
    println(box.item.uppercase())
}
```

Covariância (out) e contravariância (in): Permitem especificar como os subtipos podem ser usados em tipos genéricos, prevenindo erros de incompatibilidade de tipos em tempo de compilação.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Erro de compilação
}

interface Sink<in T> {
    // fun produceT(): T // Erro de compilação
    fun consumeT(t: T)
}

Classes seladas (Sealed classes): Representam uma hierarquia limitada de classes, onde todas as subclasses são conhecidas em tempo de compilação. Isso permite que o compilador verifique a completude das expressões when com subclasses de classes seladas, garantindo o tratamento de todos os casos possíveis.

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("Dados: ${result.data}")
        is Result.Error -> println("Erro: ${result.code}")
        // Sem 'else', o compilador garante o tratamento de todas as subclasses de Sealed
    }
}

Estes mecanismos trabalham em conjunto, permitindo detectar muitas potenciais erros relacionados a tipos em uma fase inicial do desenvolvimento, antes de executar a aplicação.