Como é implementada a abertura em Swift (opcionais…

Os opcionais em Swift representam um tipo que pode conter um valor do tipo T (valor envolvido) ou nil, indicando a ausência de valor.

Os principais mecanismos para trabalhar com opcionais:

Ligação Opcional (if let, guard let): Extração segura do valor de um opcional.
- if let: Extrai o valor e atribui a uma constante ou variável temporária se o opcional contiver um valor. O bloco de código só é executado neste caso.
```
let optionalString: String? = "Hello"
if let unwrappedString = optionalString {
    // unwrappedString tem tipo String
}
```
- guard let: Extrai o valor. Se o opcional for nil, o bloco else é executado (geralmente para sair do escopo atual). Se o valor for extraído com sucesso, está disponível após guard no escopo atual.
```
func processString(_ optionalString: String?) {
    guard let unwrappedString = optionalString else {
        return // Sair da função
    }
    // unwrappedString do tipo String está disponível aqui
}
```

Encadeamento Opcional (?): Permite chamar propriedades, métodos e índices em um opcional. Se em qualquer etapa da cadeia o opcional for nil, toda a cadeia é interrompida e o resultado tem tipo opcional contendo nil.

class Person {
    var job: Job?
}

class Job {
    var salary: Double?
}

let person: Person? = Person()
person?.job = Job()
let salary = person?.job?.salary // salary tem tipo Double?

Desembrulhamento Forçado (!): Extração não segura do valor. Conduz a um erro em tempo de execução (crash) se o opcional contiver nil. Deve ser usado com muita precaução, apenas quando se sabe com certeza que o opcional não é nil.

let requiredString: String! = "Must be present" // Opcional implícito
let unwrappedString = requiredString! // Desembrulhamento forçado

let dangerousOptional: String? = nil
// let crash = dangerousOptional! // Causará um erro

Operador de Coalescência Nula (??): Fornece um valor padrão se o opcional for nil.

let optionalValue: Int? = nil
let definiteValue = optionalValue ?? 0 // definiteValue será 0

Opcionais Implícitos Desembrulhados (!): Opcionais que se desembrulham automaticamente ao usar. São declarados com !. Devem ser usados quando se garante que o valor será atribuído antes do primeiro uso, mas não necessariamente na inicialização (por exemplo, IBOutlets). Ao acessar, se o valor for nil, ocorre um erro em tempo de execução.
```
var button: UIButton! // Presume-se que será inicializado em viewDidLoad
// button.setTitle("Tap me", for: .normal) // Desembrulhamento automático ao usar
```

"Contratos" neste contexto não são um mecanismo de linguagem separado em Swift, semelhante aos contratos em outras linguagens. Swift garante segurança através de um sistema de tipos, incluindo opcionais e controle de acesso, o que ajuda a expressar claramente as intenções e prevenir erros. Os opcionais servem como "contrato" indicando a possibilidade de ausência de valor.

Como é implementada a abertura em Swift (opcionais, contratos e outros mecanismos)?