Come garantire la sicurezza dei tipi in Kotlin…

La sicurezza dei tipi in Kotlin è garantita in fase di compilazione attraverso diversi meccanismi chiave:

Sistema di tipi non nullabili: Kotlin distingue tra tipi referenziali che possono accettare il valore null (indicati con ? alla fine del nome del tipo) e quelli che non possono. Il compilatore richiede verifiche esplicite di null o l'uso di chiamate sicure (?.) e operatori (?:, !!).

// Riferimento che non può essere null
val nonNullableString: String = "Hello"

// Riferimento che può essere null
var nullableString: String? = "World"
nullableString = null // Permesso

// Errore di compilazione: gestione del null richiesta
// val length = nullableString.length

// Chiamata sicura
val length: Int? = nullableString?.length

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

Cast intelligenti (Smart Casts): Il compilatore converte automaticamente il tipo di una variabile all'interno di blocchi if, when, while, for e altre espressioni dopo aver verificato il tipo o null.

fun printLength(obj: Any) {
    if (obj is String) {
        // Dentro questo blocco, il compilatore sa che obj è String
        println("Lunghezza String è ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Dentro questo blocco, il compilatore sa che str non è null
        println("String non è null, lunghezza è ${str.length}")
    }
}

Tipi generici (Generics): Kotlin supporta i generici, che consentono di creare classi, interfacce e funzioni che lavorano con diversi tipi, garantendo la sicurezza dei tipi in fase di compilazione.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Il compilatore sa che item è di tipo String
    println(box.item.uppercase())
}
```

Covarianza (out) e contravarianza (in): Permettono di specificare come i sottotipi possono essere usati nei tipi generici, prevenendo errori di incompatibilità di tipi durante la compilazione.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Errore di compilazione
}

interface Sink<in T> {
    // fun produceT(): T // Errore di compilazione
    fun consumeT(t: T)
}

Classi sealed: Rappresentano una gerarchia limitata di classi, dove tutte le sottoclassi sono note in fase di compilazione. Questo permette al compilatore di verificare la completezza delle espressioni when con sottoclassi di classi sealed, garantendo la gestione di tutti i casi possibili.

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("Dati: ${result.data}")
        is Result.Error -> println("Errore: ${result.code}")
        // Senza 'else', il compilatore garantisce la gestione di tutte le sottoclassi di Sealed
    }
}

Questi meccanismi lavorano insieme, permettendo di individuare molte potenziali errori legati ai tipi in una fase precoce dello sviluppo, prima di eseguire l'applicazione.

Come garantire la sicurezza dei tipi in Kotlin?