Generic — az általános típusok lényege és a T paraméter

Mi az a Generic Swiftben?

Generic (általános típus) — egy szintaktikai szerkezet Swiftben, amely lehetővé teszi rugalmas, újrafelhasználható kód írását típus paraméterezéssel. Konkrét típus helyett egy helyőrző kerül a szögletes zárójelekbe — általában , de bármilyen név használható. A Generic a SwiftUI (View, some View), a szabványos könyvtár (Array, Optional) és a Combine alapját képezi.

Miért van szükség Generic-re

Generic nélkül külön függvényeket kellene írni minden típushoz: swapInts, swapStrings, swapDates. A generic swap függvény mindhárom változatot egyetlen deklarációval helyettesíti. Ez csökkenti az ismétlést, növeli az olvashatóságot és csökkenti a hibák valószínűségét a kód másolásakor.

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)

A Swift fordító specializált kódot generál minden egyes konkrét generic használathoz. Ez azt jelenti, hogy a swapValues generic függvénynek nincs többletköltsége a kézzel írt Int függvényhez képest. A Swift nem használ típus törlést, mint a Java — a generic mind a fordítási fázisban, mind futásidőben létezik (bár az optimalizálás specializálhatja őket).

Általános függvények T paraméterrel

Generic függvények — olyan függvények, amelyek egy vagy több típus-paramétert fogadnak el. A típus-paraméterek a függvény neve után szögletes zárójelekben kerülnek megadásra: . Használhatók az aláírásban: az argumentum típusa, a visszatérési típus és a függvény törzsén belül.

Több típus-paraméter

Egy függvénynek több generic paramétere lehet. Például a findKey függvény egy szótárt fogad el K kulcsokkal és V értékekkel. Minden típus-paraméter egyedi és használható megszorításokban.

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
}

A K: Hashable és where V: Equatable megszorítások garantálják, hogy a findKey csak olyan szótárral hívható meg, amelynek kulcsai hash-elhetők és értékei összehasonlíthatók. Az ilyen megszorítások nem bürokrácia, hanem szükségszerűség: Hashable nélkül nem lehet indexelni a kulcs szerinti keresést, Equatable nélkül nem lehet összehasonlítani a value-t a dictValue-val.

Típusmegszorítások where segítségével

where — egy Swift kulcsszó, amely további megszorításokat ró a generic paraméterekre. Ellentétben a protokoll egyszerű megadásával szögletes zárójelekben (), a where lehetővé teszi összetettebb feltételek kifejezését: több protokollnak való megfelelés, kapcsolat a típus-paraméterek között és az associated types pontosítása.

A where szintaxisa

A where záradék a függvény vagy típus aláírása után, a nyitó kapcsos zárójel előtt íródik. A where-ben megadható, hogy T: Comparable & Hashable (egyidejűleg két protokoll), vagy hogy T.U == Int (associated type konkretizálása).

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
    }
}

A where-es kiterjesztés csak azokhoz a típusokhoz ad metódusokat, amelyek teljesítik a feltételt. A Container megkapja az isSorted metódust, de a Container nem, mert az Any nem Comparable. Ez a feltételes funkcionalitás erőteljes mechanizmusa.

Associated Types a protokollokban

Associated Types (kapcsolódó típusok) — egy mód arra, hogy a protokoll általánossá váljon anélkül, hogy a deklarációs fázisban megadnánk a konkrét típust. A helyett a protokoll deklarál egy associatedtype-ot, amely a megvalósításban konkretizálódik. Ez különösen fontos a gyűjteményeknél: a Sequence protokoll nem tudja, hogy a sorozat milyen elemeket fog tartalmazni.

Associated types kapcsolata where segítségével

A where segítségével kapcsolatok hozhatók létre a különböző protokollok associated types között. Például előírható, hogy az egyik protokoll Item-je egyezzen meg a másik Iterator.Element-jével. Ez garantálja a típusok kompatibilitását fordítási szinten.

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() }
}

Az IntStack a typealias segítségével Element-et Int-ként konkretizálja. A fordító ellenőrzi, hogy a protokoll összes követelménye teljesül-e ezzel a típussal. Associated types nélkül StackProtocol-et kellene írni egy generic protokollal, de a Swift az associated types-t használja az Objective-C hidakkal való egységesség és jobb olvashatóság érdekében.

Generic kiterjesztésekben és subscriptekben

Generic kiterjesztések lehetővé teszik metódusok hozzáadását egy generic típushoz további megszorításokkal. Ez a „feltételes megfelelés” minta, amikor a típus csak bizonyos feltételek mellett kap funkcionalitást. A subscriptek is lehetnek generic-ek.

Generic subscript

Egy subscript lehet általános: generic paramétereket fogad el szögletes zárójelekben. Ez hasznos a gyűjteményekhez való biztonságos hozzáféréshez tetszőleges indexszel, amikor az index különböző típusú lehet.

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] }
    }
}

Az ilyen szerkezet erőteljes kompozíciót biztosít: a sum metódus csak numerikus tömböknél jelenik meg, a tetszőleges indexű subscript pedig bármilyen egész indexsorozattal működik. A fordító maga kezeli ezeknek a tagoknak a láthatóságát a where feltételek alapján.

Tipikus hibák a generikusokkal való munkában

Hibák a generic használatakor gyakran kapcsolódnak helytelen megszorításokhoz vagy a generic használatának kísérletéhez ott, ahol konkrét típusra van szükség. Vizsgáljunk meg három gyakori forgatókönyvet, amellyel a fejlesztők találkoznak.

Túlzott paraméterezés

Generic paraméterek hozzáadása ott, ahol a konkrét típus elegendő — egy anti-minta. Ha egy függvény mindig String-tel dolgozik, nem kell -vé tenni. Ez bonyolultabbá teszi a kódot előny nélkül. A generic akkor indokolt, ha a típus ténylegesen változik, nem absztrakt „jövőbeli rugalmasság” miatt.

Hiányzó where megszorítás

Metódus hívása egy generic paraméteren anélkül, hogy megadnánk, hogy a metódus létezik — hiba. nem hívhatja meg a .count-ot, ha nincs megadva, hogy T: Collection. Mindig adjon hozzá megszorításokat a típus-paraméterekhez, különben a fordító elutasítja a kódot.

// ❌ 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 }

A hiba érthető: a generic bármilyen típus lehet, és a fordító nem tudja, hogy van-e count-ja. A Collection megszorítás megoldja a problémát. Hasonlóan az Equatable, Hashable, Numeric esetében — mindig adja meg a protokollt, ha metódusokat vagy operátorokat kíván hívni a generic paraméteren.