Que se passera-t-il si on enlève les optionnels de Swift?

Cela conduirait à une réduction significative de la sécurité du code. De nombreuses opérations deviendraient potentiellement non sécurisées, car le compilateur ne pourrait pas garantir la présence d'une valeur.

1. Suppression du chaînage optionnel (?) et du déballage forcé (!). La syntaxe pour travailler avec les optionnels deviendrait invalide.
2. Nécessité de vérifications constantes de nil. Les développeurs devraient écrire manuellement des conditions if pour chaque opération avec une valeur potentiellement absente, ce qui augmenterait considérablement la quantité de code répétitif et sa complexité.
3. Augmentation du risque de plantages. Sans garanties du compilateur sur la présence de la valeur, tenter d'accéder à nil entraînerait une erreur à l'exécution.
4. Absence de solutions élégantes pour l'asynchronie. La gestion des résultats d'opérations asynchrones, qui peuvent échouer (retournant nil), deviendrait encombrante.
5. Complexification de l'interaction avec l'API Objective-C. De nombreuses méthodes Objective-C retournent nil pour indiquer un échec ou l'absence de valeur. L'interopérabilité deviendrait moins sûre.

Exemple de code avant et après (hypothétique) :

Avant :

var optionalString: String? = "Hello"
let length = optionalString?.count // Chaînage optionnel

Après (hypothétique) :

var nonOptionalString: String // Désormais, toutes les variables doivent avoir une valeur lors de l'initialisation ou être vérifiées explicitement
var potentiallyNilStringFromSomewhere: String

// Au lieu du chaînage optionnel, il faudrait écrire ainsi :
if someFunctionCouldReturnNil() {
    // Gestion d'erreur
} else {
    potentiallyNilStringFromSomewhere = ... // Attribution d'une valeur
    let length = potentiallyNilStringFromSomewhere.count // Risque de crash si la valeur est en réalité nil
}

// Ou ainsi, si le nil existait encore dans le langage, mais sans support du compilateur :
if potentiallyNilStringFromSomewhere != nil {
    let length = potentiallyNilStringFromSomewhere!.count // Extraction forcée risquée
} else {
    // Gestion du nil
}

Ainsi, le code deviendrait plus sujet à des erreurs à l'exécution, moins lisible et plus difficile à maintenir. Les optionnels sont l'un des mécanismes clés de Swift pour assurer la sécurité des types et lutter contre les exceptions de pointeur nul.