Optional / Nullable — concetti chiave e lavoro con i tipi nullable

Cosa sono Optional e Nullable?

Optional in Swift e nullable in Kotlin sono strumenti linguistici che rendono null una parte esplicita del sistema di tipi. In Swift, Optional è un enum: Optional.none (nil) e Optional.some(Wrapped). In Kotlin, nullable è indicato dal suffisso ? nel tipo: String? può essere una stringa o null.

Entrambi gli approcci risolvono il problema fondamentale che Tony Hoare ha chiamato “errore da un miliardo di dollari” — null reference. Prima dell'avvento dei tipi opzionali, qualsiasi riferimento poteva essere null e il controllo era lasciato allo sviluppatore. Swift e Kotlin spostano questo controllo alla fase di compilazione: il codice che ignora null non verrà compilato.

Nonostante l'obiettivo comune, Swift e Kotlin implementano la null-safety in modo diverso. Swift utilizza il tipo algebrico Optional con pattern-matching completo. Kotlin incorpora nullable nel sistema di tipi a livello del compilatore senza creare un tipo wrapper separato.

Storicamente, null reference è apparso nel 1965 nel linguaggio ALGOL W come modo per rappresentare l'assenza di un valore. Per sei decenni, null è diventato la fonte di innumerevoli guasti — secondo la ricerca di Tony Hoare, dal 30 al 50 percento degli errori nel codice di produzione sono correlati a NullPointerException. Swift con Optional e Kotlin con i tipi nullable sono diventati i primi linguaggi mainstream a risolvere questo problema a livello del sistema di tipi, rendendo null una parte esplicita del contratto della funzione.

Optional in Swift: sintassi e lavoro con i tipi opzionali

In Swift, Optional è un tipo a tutti gli effetti dichiarato come enum Optional<Wrapped>. Lo zucchero sintattico ? sostituisce la notazione completa: Int? è equivalente a Optional<Int>. Lavorare con Optional include diversi modi per estrarre il valore.

Binding if-let e guard-let

if let — estrazione condizionale: se Optional contiene un valore, viene vincolato a una costante all'interno del blocco. guard let — uscita anticipata dalla funzione se Optional è nil. guard let mantiene il codice piatto, evitando if-let annidati.

Optional chaining

Optional chaining (accesso sicuro sequenziale) tramite ? consente di chiamare un metodo o una proprietà su un Optional senza unwrapping esplicito. Se un anello della catena è nil, l'intera catena restituisce nil. Questo riduce il codice quando si lavora con dati gerarchici.

Operatore nil-coalescing

?? (nil-coalescing) — un operatore che restituisce il valore Optional se non è nil, altrimenti restituisce un valore predefinito. È un'alternativa concisa a if-let per fornire un valore di fallback.

var name: String? = "Alice"

// Binding if-let
if let unwrapped = name {
    print("Ciao, \(unwrapped)")
}

// Optional chaining
let count = name?.count

// Nil-coalescing
let display = name ?? "Ospite"

// Map su Optional
let greeting = name.map { "Hello, \($0)" }

Nullable in Kotlin: chiamate sicure e operatore Elvis

In Kotlin, nullable è parte del sistema di tipi, non un tipo wrapper separato. Il tipo String? può contenere null, mentre String (senza punto interrogativo) mai. Il compilatore traccia nullable tramite smart cast e annotazioni.

Chiamata sicura ?.

?. — l'operatore di chiamata sicura. Se l'oggetto non è null, il metodo o la proprietà viene chiamato; se è null — viene restituito null senza chiamata. È analogo all'optional chaining in Swift, ma sintatticamente più corto.

Operatore Elvis ?:

?: — l'analogo Kotlin di nil-coalescing. Se l'espressione di sinistra non è null, viene restituita; altrimenti — il valore a destra. L'operatore Elvis è spesso combinato con un'uscita anticipata tramite return o throw.

Smart cast e operatore !!

Smart cast — il compilatore Kotlin converte automaticamente nullable in non-null dopo un controllo di null in if o when. !! — unwrapping forzato (force unwrap) che lancia NullPointerException se null. Usa !! solo quando null è un bug.

val name: String? = "Alice"

// Chiamata sicura
val length = name?.length

// Operatore Elvis
val display = name ?: "Ospite"

// Smart cast dopo controllo
if (name != null) {
    println("Lunghezza: ${name.length}")
}

// Let con lambda
name?.let { println("Ciao, $it") }

// Force unwrap — solo quando sicuri
val forced = name!!

Optional vs Nullable: differenze chiave degli approcci

Sebbene Swift e Kotlin risolvano lo stesso compito, i loro approcci alla null-safety sono fondamentalmente diversi. Comprendere queste differenze è importante per gli sviluppatori che lavorano con entrambe le piattaforme.

Rappresentazione nel sistema di tipi

Swift usa enum Optional — un tipo algebrico standard. Kotlin incorpora nullable a livello del sistema di tipi del compilatore senza creare un oggetto wrapper. Questo influisce sulle prestazioni: Optional in Swift è un oggetto sull'heap, mentre nullable in Kotlin è un controllo di null senza allocazione.

Sintassi ed espressività

La sintassi di Kotlin è più corta grazie agli operatori integrati ?., ?:, !!. Swift richiede una sintassi più esplicita: if let, guard let, map su Optional. Tuttavia, Swift fornisce il pattern-matching tramite switch, che Kotlin non supporta direttamente per nullable.

Pattern di null-safety nello sviluppo mobile

Nello sviluppo mobile, sono emersi pattern standard per lavorare con i tipi opzionali che riducono il codice boilerplate e aumentano la sicurezza.

Map e flatMap su Optional

Swift e Kotlin supportano map e flatMap per Optional e nullable. Se un valore esiste, viene applicata una trasformazione; se è null — viene restituito null. Questo elimina i controlli if-let annidati.

Valori predefiniti tramite Elvis

Invece di if-let + else, usa ?: o ?? con un valore predefinito. Questo rende il codice dichiarativo: “usa X se disponibile, altrimenti Y” invece di un controllo procedurale.

Nullable in Compose e SwiftUI

In Jetpack Compose e SwiftUI, i tipi opzionali controllano il rendering: se lo stato è null — nascondi il componente, altrimenti mostralo. Questo segue il principio della single source of truth.

data class UserState(
    val name: String?,
    val email: String?
)

// Smart cast in when con varianti diverse
fun greeting(state: UserState): String = when {
    state.name != null && state.email != null ->
        "${state.name} (${state.email})"
    state.name != null -> state.name
    else -> "Ospite"
}

// Compose: visualizzazione per presenza
@Composable
fun UserProfile(name: String?) {
    name?.let {
        Text(text = it)
    } ?: Text(text = "Nessun dato")
}

Per migrare codice Java esistente a Kotlin, si consiglia di utilizzare le annotazioni @Nullable e @NonNull del pacchetto androidx.annotation. Il compilatore Kotlin rispetta queste annotazioni durante l'interop con Java, rendendo automaticamente i tipi corrispondenti nullable o non-null. La migrazione graduale con annotazioni esplicite è più sicura dell'abilitazione globale della null-safety nel progetto.

Errori comuni quando si lavora con Optional e Nullable

La null-safety riduce il numero di errori, ma non li elimina completamente. Gli sviluppatori commettono spesso errori caratteristici quando lavorano con i tipi opzionali.

• Force unwrap senza garanzia — name! o name!! senza la certezza che il valore non sia nil provoca un crash in produzione. Controlla null prima del force unwrap.
• If-let eccessivo — if-let annidati per tre o più Optional creano una piramide del doom. Usa guard let o flatMap.
• Ignorare nil-coalescing — il controllo esplicito tramite if-let con blocco else può essere sostituito con ?? o ?:, riducendo il codice e migliorando la leggibilità.
• Nullable nelle API pubbliche — se una funzione accetta nullable, ogni chiamata richiede un controllo. Preferisci non-null con un valore predefinito o overload.