How is optional opening (optionals, contracts, and…

Optionals in Swift represent a type that can either contain a value of type T (wrapped value) or nil, indicating the absence of a value.

Main mechanisms for working with optionals:

Optional Binding (if let, guard let): Safe extraction of a value from an optional.
- if let: Extracts the value and assigns it to a temporary constant or variable if the optional contains a value. The code block executes only in this case.
```
let optionalString: String? = "Hello"
if let unwrappedString = optionalString {
    // unwrappedString is of type String
}
```
- guard let: Extracts the value. If the optional is nil, the else block executes (usually to exit the current scope). If the value is successfully extracted, it is available after guard in the current scope.
```
func processString(_ optionalString: String?) {
    guard let unwrappedString = optionalString else {
        return // Exit the function
    }
    // unwrappedString of type String is accessible here
}
```

Optional Chaining (?): Allows calling properties, methods, and indices on an optional. If the optional is nil at any point in the chain, the entire chain is broken, and the result is of optional type containing nil.

class Person {
    var job: Job?
}

class Job {
    var salary: Double?
}

let person: Person? = Person()
person?.job = Job()
let salary = person?.job?.salary // salary is of type Double?

Forced Unwrapping (!): Unsafe extraction of a value. Leads to runtime error (crash) if the optional contains nil. Should be used with caution, only when it is certain that the optional is not nil.

let requiredString: String! = "Must be present" // Implicitly unwrapped optional
let unwrappedString = requiredString! // Forced unwrapping

let dangerousOptional: String? = nil
// let crash = dangerousOptional! // Will cause an error

Nil-Coalescing Operator (??): Provides a default value if the optional is nil.

let optionalValue: Int? = nil
let definiteValue = optionalValue ?? 0 // definiteValue will be 0

Implicitly Unwrapped Optionals (!): Optionals that are automatically unwrapped when used. Declared with !. Should be used when the value is guaranteed to be assigned before first use, but not necessarily during initialization (e.g., IBOutlets). When accessed and the value is nil, a runtime error occurs.
```
var button: UIButton! // Expected to be initialized in viewDidLoad
// button.setTitle("Tap me", for: .normal) // Automatic unwrapping when used
```

"Contracts" in this context are not a separate language mechanism in Swift, similar to contracts in other languages. Swift ensures safety through its type system, including optionals and access control, which helps explicitly express intentions and prevent errors. Optionals serve as a "contract" indicating the possibility of absence of a value.

How is optional opening (optionals, contracts, and other mechanisms) implemented in Swift?