Învață Swift: ghiduri, optionals, protocoale și concurență explicate cu exemple

Swift este un limbaj de programare compilat de uz general, modern, performant și cu garanții matematice de siguranță a memoriei, creat inițial de Chris Lattner și echipa Apple și dezvoltat în prezent ca proiect open-source de amploare globală. Conceput ca un salt generațional peste bătrânul Objective-C, Swift fuzionează viteza nativă fără compromisuri a C++ cu expresivitatea și eleganța limbajelor dinamice precum Python sau Ruby. Swift domină suita de platforme Apple (iOS, iPadOS, macOS, watchOS, tvOS, visionOS) și cunoaște o adopție masivă în sisteme backend de înaltă performanță (prin Vapor și Swift Server Workgroup) și dispozitive embedded (Embedded Swift).

# Spre deosebire de compilatoarele tradiționale C/C++ care trec direct din AST în LLVM IR,
# Swift introduce SIL — o reprezentare intermediară conștientă de semantica limbajului:

# 1. Swift Source Code (.swift)
#    ↓
# 2. Parsing & AST Generation (Abstract Syntax Tree):
#    - Verificarea sintactică și rezolvarea sistemului de tipuri (Type Checking & Inference).
#    ↓
# 3. SILGen (Raw SIL):
#    - Emite SIL brut, fără optimizări, reflectând direct logica de execuție a codului.
#    ↓
# 4. SIL Analysis & Mandatory Passes (Canonical SIL):
#    - Definite Initialization: garantează că nicio variabilă nu este citită înainte de inițializare!
#    - Flow-sensitive Memory Safety: verifică epuizarea switch-urilor și return-urile pe toate ramurile.
#    - ARC Optimization: elimină retain/release-urile redundante înainte de codul mașină.
#    - Generics Devirtualization: specializează genericele pentru tipuri concrete (Zero-Cost Abstractions).
#    ↓
# 5. IRGen (LLVM Intermediate Representation):
#    - Transformă Canonical SIL în LLVM IR generic, independent de arhitectura fizică.
#    ↓
# 6. LLVM Backend & Code Generation:
#    - Vectorizare, optimizări hardware, register allocation și compilare în cod mașină nativ (ARM64 / x86_64).

Modelul de Memorie: Automatic Reference Counting (ARC) și Referințe

Swift nu utilizează un Garbage Collector cu opriri aleatoare de tip Stop-the-World (precum Java sau Go). În schimb, memoria pe heap este administrată determinist prin Automatic Reference Counting (ARC): compilatorul inserează automat instrucțiuni swift_retain și swift_release la nivel de mașină.

Pentru a preveni scurgerile de memorie prin cicluri de referință (retain cycles), Swift pune la dispoziție trei tipuri de legături între obiecte:

// 1. Strong Reference (Implicită):
//    - Incrementează contorul de referințe. Obiectul trăiește cât timp contorul > 0.

// 2. Weak Reference (weak var):
//    - NU incrementează contorul de referințe.
//    - Este întotdeauna opțională (Optional<T>). Când obiectul este eliberat din memorie,
//      ARC îl setează automat pe 'nil' prin mecanismul de Side Tables.
class ViewController {
    weak var delegate: ServiceDelegate?
}

// 3. Unowned Reference (unowned let/var):
//    - NU incrementează contorul și NU este opțională.
//    - Presupune că obiectul referit trăiește cel puțin la fel de mult ca și deținătorul său.
//    - Dacă este accesat după dealocare, provoacă o oprire controlată imediată (Fatal Error), nu comportament nedefinit!
class CreditCard {
    unowned let customer: Customer
    init(customer: Customer) { self.customer = customer }
}

// 4. Capture Lists în Închideri Funcționale (Closures):
//    - Elimină retain cycle-ul dintre o instanță de clasă și closure-ul pe care îl deține:
networkManager.fetchData { [weak self] data in
    guard let self else { return } // Swift 5.7+ shorthand unwrapping
    self.updateUI(with: data)
}

Semantica de Valoare (Value Types) vs. Referință (Reference Types) și Copy-on-Write (CoW)

Arhitectura Swift favorizează masiv Value Types (struct, enum, tipurile primitive precum Int, Double, String, Array, Dictionary). Când un value type este atribuit unei alte variabile sau transmis unei funcții, se creează o copie logică independentă, izolată de orice mutație colaterală.

Colecțiile standard din Swift evită copiile costisitoare pe memorie prin mecanismul sofisticat Copy-on-Write (CoW): buffer-ul din heap este partajat la citire între mai multe instanțe; alocarea și clonarea fizică a datelor are loc doar în milisecunda în care una dintre instanțe încearcă să modifice datele (mutating):

var listaA = [1, 2, 3, 4, 5] // Buffer-ul este alocat pe Heap
var listaB = listaA           // Nicio copiere de memorie! listaB indică spre același buffer fizic!

listaB.append(6) 
// Doar în acest moment CoW detectează că buffer-ul este partajat:
// 1. Alocă un nou buffer în memorie pentru listaB.
// 2. Copiază elementele existente și adaugă valoarea 6.
// 3. listaA rămâne neatinsă: [1, 2, 3, 4, 5], iar listaB devine: [1, 2, 3, 4, 5, 6].

Swift 6: Siguranță Totală a Concurenței la Compilare (Data-Race Safety)

Lansat cu Swift 6, modelul de concurență aduce o revoluție în industrie: Data-Race Safety garantat la compilare. Swift elimină erorile de concurență (fire paralele care modifică aceeași memorie fără sincronizare) printr-un sistem strict de domenii de izolare:

• Modelul async/await bazat pe stivă cooperativă: Firele de execuție nu sunt blocate; operațiile asincrone suspendă execuția și cedează nucleul CPU planificatorului cooperativ (Cooperative Thread Pool).
• Actori (actor): Tipuri de referință cu stare izolată, unde accesul concurent la proprietăți este serializat automat printr-o cutie poștală internă (mailbox) asincronă.
• Global Actors și @MainActor: Izolează execuția pe firul principal al aplicației (Main Thread / UI RunLoop), prevenind actualizările de interfață grafică din thread-uri secundare.
• Protocolul Sendable: Verifică la compilare că datele transmise între domenii de izolare sau thread-uri concurente sunt fie imutabile, fie Value Types fără stare partajată, fie actori protejați.

Arhitectura Modernă a Aplicațiilor: SwiftUI și Framework-ul Observation

Începând cu Swift 5.9 și iOS 17+, macrocomanda @Observable a înlocuit vechiul framework Combine (ObservableObject, @Published). Noul model de observație urmărește granular doar proprietățile efectiv accesate de corpul unui View, eliminând randările parazite și sporind performanța la 120 FPS pe ecranele ProMotion.

Consultă ghidurile detaliate de mai jos pentru a explora funcționalitățile moderne din Swift 5.9 și Swift 6: de la macrocomenzi sintactice, task groups concurente și actori, până la tipuri non-copiabile (~Copyable) și arhitecturi enterprise iOS.