Generic — esența tipurilor generice și parametrul T

Ce este Generic în Swift?

Generic (tip generic) — este o construcție sintactică Swift care permite scrierea de cod flexibil, reutilizabil cu parametrizare după tip. În locul unui tip concret se scrie un placeholder în paranteze unghiulare — de obicei , dar se poate folosi orice nume. Generic stă la baza SwiftUI (View, some View), bibliotecii standard (Array, Optional) și Combine.

De ce sunt necesare Generic

Fără generic ar trebui scrise funcții separate pentru fiecare tip: swapInts, swapStrings, swapDates. Funcția generic swap înlocuiește toate cele trei variante cu o singură declarație. Aceasta reduce duplicarea, crește lizibilitatea și scade probabilitatea erorilor la copierea codului.

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 10
var y = 20
swapValues(&x, &y)

Compilatorul Swift generează cod specializat pentru fiecare utilizare concretă a generic. Aceasta înseamnă că funcția generic swapValues nu are costuri suplimentare față de o funcție scrisă manual pentru Int. Swift nu folosește ștergerea tipurilor ca Java — generic există atât în faza de compilare, cât și în runtime (deși optimizarea le poate specializa).

Funcții generice cu parametrul T

Funcțiile generic — sunt funcții care acceptă unul sau mai mulți parametri-tip. Parametrii-tip sunt indicați după numele funcției în paranteze unghiulare: . Ei pot fi folosiți în semnătură: tipul argumentului, tipul returnat și în interiorul corpului funcției.

Parametri-tip multipli

O funcție poate avea mai mulți parametri generic. De exemplu, funcția findKey acceptă un dicționar cu chei K și valori V. Fiecare parametru-tip este unic și poate fi folosit în constrângeri.

func findKey<K: Hashable, V>(
    for value: V,
    in dictionary: [K: V]
) -> K? where V: Equatable {
    for (key, dictValue) in dictionary {
        if dictValue == value {
            return key
        }
    }
    return nil
}

Constrângerile K: Hashable și where V: Equatable garantează că findKey poate fi apelat doar cu un dicționar ale cărui chei sunt hashingabile și valorile comparabile. Astfel de constrângeri nu sunt birocrație, ci necesitate: fără Hashable nu se poate indexa căutarea după cheie, fără Equatable nu se poate compara value cu dictValue.

Constrângeri de tip prin where

where — este un cuvânt cheie Swift care impune constrângeri suplimentare asupra parametrilor generic. Spre deosebire de simpla specificare a protocolului în paranteze unghiulare (), where permite exprimarea unor condiții mai complexe: conformitatea cu mai multe protocoale, legătura între parametri-tip și rafinarea associated types.

Sintaxa where

Clauza where se scrie după semnătura funcției sau tipului, înainte de acolada deschisă. În where se poate specifica că T: Comparable & Hashable (simultan două protocoale), sau că T.U == Int (concretizarea associated type).

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
}

extension Container where Item: Comparable {
    func isSorted() -> Bool {
        // Implementation available only if Item: Comparable
        return true
    }
}

Extensia cu where adaugă metode doar pentru acele tipuri care îndeplinesc condiția. Container primește metoda isSorted, iar Container — nu, deoarece Any nu este Comparable. Acesta este un mecanism puternic de funcționalitate condiționată.

Associated Types în protocoale

Associated Types (tipuri asociate) — este un mod de a face protocolul generic fără a specifica tipul concret în faza de declarare. În loc de protocolul declară un associatedtype, care este concretizat în implementare. Acest lucru este deosebit de important pentru colecții: protocolul Sequence nu știe ce elemente va conține secvența.

Legătura associated types prin where

Cu ajutorul where se pot stabili legături între associated types ale diferitelor protocoale. De exemplu, se poate cere ca Item al unui protocol să coincidă cu Iterator.Element al altuia. Aceasta garantează compatibilitatea tipurilor la nivel de compilare.

protocol StackProtocol {
    associatedtype Element
    mutating func push(_ item: Element)
    mutating func pop() -> Element?
}

struct IntStack: StackProtocol {
    typealias Element = Int
    private var items: [Int] = []
    
    mutating func push(_ item: Int) { items.append(item) }
    mutating func pop() -> Int? { items.popLast() }
}

IntStack concretizează Element ca Int, folosind typealias. Compilatorul verifică dacă toate cerințele protocolului sunt îndeplinite cu acest tip. Fără associated types ar trebui scris StackProtocol cu un protocol generic, dar Swift folosește associated types pentru uniformitate cu punțile Objective-C și o mai bună lizibilitate.

Generic în extensii și subscriptări

Extensiile generic permit adăugarea de metode la un tip generic cu constrângeri suplimentare. Acesta este pattern-ul „conformitate condiționată”, când tipul primește funcționalitate doar în anumite condiții. Subscriptările pot fi și ele generic.

Subscriptare generic

O subscriptare poate fi generică: acceptă parametri generic în paranteze unghiulare. Acest lucru este util pentru acces sigur la colecții cu un index arbitrar, când indexul poate fi de diferite tipuri.

extension Array where Element: Numeric {
    func sum() -> Element {
        return reduce(0, +)
    }
}

extension Array {
    subscript<Indices: Sequence>(indices: Indices) -> [Element]
        where Indices.Element == Int {
        return indices.map { self[$0] }
    }
}

O astfel de construcție oferă o compunere puternică: metoda sum apare doar la array-urile numerice, iar subscriptarea cu indici arbitrari funcționează cu orice secvență de indici întregi. Compilatorul însuși gestionează vizibilitatea acestor membri pe baza condițiilor where.

Erori tipice la lucrul cu generice

Erorile la utilizarea generic sunt adesea legate de constrângeri incorecte sau încercarea de a folosi generic acolo unde este nevoie de un tip concret. Să analizăm trei scenarii frecvente cu care se confruntă dezvoltatorii.

Parametrizare excesivă

Adăugarea parametrilor generic acolo unde este suficient un tip concret — este un anti-pattern. Dacă o funcție lucrează întotdeauna cu String, nu este nevoie să o faceți . Acest lucru complică codul fără beneficiu. Generic este justificat când tipul variază cu adevărat, nu pentru o „flexibilitate pe viitor” abstractă.

Lipsa constrângerii where

Apelarea unei metode pe un parametru generic fără a specifica că metoda există — este o eroare. nu poate apela .count dacă nu s-a specificat că T: Collection. Adăugați întotdeauna constrângeri la parametrii-tip, altfel compilatorul va respinge codul.

// ❌ Error: value has no count method
func countElements<T>(value: T) -> Int { value.count }

// ✅ Works: T: Collection guarantees count exists
func countElements<T: Collection>(value: T) -> Int { value.count }

Eroarea este de înțeles: generic poate fi orice tip, iar compilatorul nu știe dacă are count. Constrângerea Collection rezolvă problema. Similar pentru Equatable, Hashable, Numeric — specificați întotdeauna protocolul dacă intenționați să apelați metode sau operatori pe parametrul generic.