Wat gebeurt er als je de optionele types uit Swift verwijdert?

Dit zou leiden tot een aanzienlijke vermindering van de codeveiligheid. Veel operaties zouden potentieel onveilig worden, omdat de compiler niet de aanwezigheid van een waarde kon garanderen.

1. Verwijdering van Optional Chaining (?) en Forced Unwrapping (!). De syntax voor het werken met optionals zou ongeldig worden.
2. Constante controles op nil nodig. Ontwikkelaars zouden handmatig if-voorwaarden moeten schrijven voor elke operatie met een potentieel ontbrekende waarde, wat de hoeveelheid boilerplate-code en de complexiteit aanzienlijk zou verhogen.
3. Verhoogd risico op crashes. Zonder garanties van de compiler over de aanwezigheid van de waarde, zou proberen toegang te krijgen tot nil leiden tot een runtime-fout.
4. Gebrek aan elegante oplossingen voor asynchroniteit. Het afhandelen van resultaten van asynchrone operaties die kunnen falen (door nil terug te geven), zou omslachtig worden.
5. Complexiteit bij het werken met de Objective-C API. Veel Objective-C-methoden geven nil terug om falen of afwezigheid van een waarde aan te geven. Interoperabiliteit zou minder veilig worden.

Voorbeeld van code vóór en na (hypothetisch):

Vóór:

var optionalString: String? = "Hello"
let length = optionalString?.count // Optional chaining

Na (hypothetisch):

var nonOptionalString: String // Nu moeten alle variabelen een waarde hebben bij initialisatie of expliciet worden gecontroleerd
var potentiallyNilStringFromSomewhere: String

// In plaats van optional chaining, zou je zo moeten schrijven:
if someFunctionCouldReturnNil() {
    // Foutafhandeling
} else {
    potentiallyNilStringFromSomewhere = ... // Waarde toewijzen
    let length = potentiallyNilStringFromSomewhere.count // Potentieel crash als de waarde eigenlijk nil is
}

// Of zo, als nil nog steeds in de taal zou bestaan, maar zonder compilerondersteuning:
if potentiallyNilStringFromSomewhere != nil {
    let length = potentiallyNilStringFromSomewhere!.count // Gevaarlijke geforceerde extractie
} else {
    // Nil-afhandeling
}

Op deze manier zou de code vatbaarder worden voor runtime-fouten, minder leesbaar en moeilijker te onderhouden. Optionals zijn een van de kernmechanismen van Swift om typeveiligheid te garanderen en Null Pointer Exceptions te voorkomen.