¿Cómo garantizar la seguridad de tipos en Kotlin…

La seguridad de tipos en Kotlin se garantiza en tiempo de compilación mediante varios mecanismos clave:

Sistema de tipos no nulos: Kotlin distingue entre tipos referenciales que pueden aceptar el valor null (denotados con ? al final del nombre del tipo) y aquellos que no pueden. El compilador requiere verificaciones explícitas de null o el uso de llamadas seguras (?.) y operadores (?:, !!).

// Referencia que no puede ser null
val nonNullableString: String = "Hello"

// Referencia que puede ser null
var nullableString: String? = "World"
nullableString = null // Permitido

// Error de compilación: se requiere manejo de null
// val length = nullableString.length

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

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

Casts inteligentes (Smart Casts): El compilador convierte automáticamente el tipo de una variable dentro de bloques if, when, while, for y otras expresiones después de verificar el tipo o null.

fun printLength(obj: Any) {
    if (obj is String) {
        // Dentro de este bloque, el compilador sabe que obj es String
        println("Longitud de String es ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Dentro de este bloque, el compilador sabe que str no es null
        println("String no es null, longitud es ${str.length}")
    }
}

Tipos genéricos (Generics): Kotlin soporta genéricos, que permiten crear clases, interfaces y funciones que trabajan con diferentes tipos, asegurando la seguridad de tipos en tiempo de compilación.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // El compilador sabe que item es de tipo String
    println(box.item.uppercase())
}
```

Covarianza (out) y contravarianza (in): Permiten especificar cómo los subtipos pueden usarse en tipos genéricos, previniendo errores de incompatibilidad de tipos en tiempo de compilación.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Error de compilación
}

interface Sink<in T> {
    // fun produceT(): T // Error de compilación
    fun consumeT(t: T)
}

Clases selladas (Sealed classes): Representan una jerarquía limitada de clases, donde todas las subclases son conocidas en tiempo de compilación. Esto permite que el compilador verifique la exhaustividad de las expresiones when con subclases de clases selladas, asegurando el manejo de todos los casos posibles.

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("Datos: ${result.data}")
        is Result.Error -> println("Error: ${result.code}")
        // Sin 'else', el compilador garantiza el manejo de todas las subclases de Sealed
    }
}

Estos mecanismos trabajan en conjunto, permitiendo detectar muchas posibles errores relacionados con tipos en una etapa temprana del desarrollo, antes de ejecutar la aplicación.

¿Cómo garantizar la seguridad de tipos en Kotlin?