Generic — podstata generických typů a parametr T

Co je Generic ve Swiftu?

Generic (generický typ) — je syntaktická konstrukce Swiftu, která umožňuje psát flexibilní, znovupoužitelný kód s parametrizací podle typu. Místo konkrétního typu se píše placeholder v úhlových závorkách — obvykle , ale lze použít libovolné jméno. Generic leží v základu SwiftUI (View, some View), standardní knihovny (Array, Optional) a Combine.

Proč jsou Generic potřeba

Bez generik by se musely psát oddělené funkce pro každý typ: swapInts, swapStrings, swapDates. Generická funkce swap nahrazuje všechny tři varianty jedinou deklarací. To snižuje duplicitu, zvyšuje čitelnost a snižuje pravděpodobnost chyb při kopírování kódu.

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)

Kompilátor Swift generuje specializovaný kód pro každé konkrétní použití generik. To znamená, že generická funkce swapValues nemá režii ve srovnání s ručně napsanou funkcí pro Int. Swift nepoužívá mazání typů jako Java — generika existují jak ve fázi kompilace, tak za běhu (i když optimalizace je může specializovat).

Generické funkce s parametrem T

Generické funkce — jsou funkce, které přijímají jeden nebo více parametrů-typů. Parametry-typy se uvádějí za názvem funkce v úhlových závorkách: . Mohou být použity v signatuře: typ argumentu, návratový typ a uvnitř těla funkce.

Více parametrů-typů

Funkce může mít několik generických parametrů. Například funkce findKey přijímá slovník s klíči K a hodnotami V. Každý parametr-typ je jedinečný a lze jej použít v omezeních.

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
}

Omezení K: Hashable a where V: Equatable zaručují, že findKey lze zavolat pouze se slovníkem, jehož klíče jsou hašovatelné a hodnoty porovnatelné. Taková omezení nejsou byrokracie, ale nutnost: bez Hashable nelze indexovat vyhledávání podle klíče, bez Equatable nelze porovnat value s dictValue.

Omezení typu pomocí where

where — je klíčové slovo Swiftu, které ukládá dodatečná omezení na generické parametry. Na rozdíl od jednoduchého uvedení protokolu v úhlových závorkách () umožňuje where vyjádřit složitější podmínky: shodu s více protokoly, vztah mezi parametry-typy a upřesnění associated types.

Syntaxe where

Klauzule where se píše za signaturou funkce nebo typu, před otevírací složenou závorkou. V where lze uvést, že T: Comparable & Hashable (současně dva protokoly), nebo že T.U == Int (konkretizace 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
    }
}

Rozšíření s where přidává metody pouze pro ty typy, které splňují podmínku. Container získá metodu isSorted, ale Container ne, protože Any není Comparable. To je mocný mechanismus podmíněné funkcionality.

Associated Types v protokolech

Associated Types (asociované typy) — je způsob, jak učinit protokol generickým bez uvedení konkrétního typu ve fázi deklarace. Místo protokol deklaruje associatedtype, který je konkretizován v implementaci. To je zvláště důležité pro kolekce: protokol Sequence neví, jaké prvky bude sekvence obsahovat.

Propojení associated types pomocí where

Pomocí where lze vytvořit vazby mezi associated types různých protokolů. Lze například požadovat, aby Item jednoho protokolu odpovídal Iterator.Element druhého. To zaručuje kompatibilitu typů na úrovni kompilace.

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 konkretizuje Element jako Int pomocí typealias. Kompilátor kontroluje, zda jsou všechny požadavky protokolu s tímto typem splněny. Bez associated types by se musel psát StackProtocol s generickým protokolem, ale Swift používá associated types pro jednotnost s mosty Objective-C a lepší čitelnost.

Generic v rozšířeních a subskriptech

Generická rozšíření umožňují přidávat metody ke generickému typu s dodatkovými omezeními. To je vzor „podmíněné shody”, kdy typ získává funkcionalitu pouze za určitých podmínek. Subskripty mohou být také generické.

Generický subskript

Subskript může být generický: přijímá generické parametry v úhlových závorkách. To je užitečné pro bezpečný přístup ke kolekcím s libovolným indexem, když index může být různých typů.

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

Taková konstrukce poskytuje mocnou kompozici: metoda sum se objevuje pouze u numerických polí, subskript s libovolnými indexy pracuje s jakoukoli sekvencí celočíselných indexů. Kompilátor sám řídí viditelnost těchto členů na základě podmínek where.

Typické chyby při práci s generiky

Chyby při použití generik jsou často spojeny s nesprávnými omezeními nebo pokusem použít generika tam, kde je potřeba konkrétní typ. Podívejme se na tři časté scénáře, se kterými se vývojáři setkávají.

Nadměrná parametrizace

Přidávání generických parametrů tam, kde stačí konkrétní typ — je antipattern. Pokud funkce vždy pracuje s String, není třeba ji dělat . To komplikuje kód bez přínosu. Generika jsou ospravedlnitelná, když se typ skutečně mění, ne pro abstraktní „budoucí flexibilitu”.

Chybějící omezení where

Volání metody na generickém parametru bez určení, že metoda existuje — je chyba. nemůže volat .count, pokud není uvedeno, že T: Collection. Vždy přidávejte omezení na parametry-typy, jinak kompilátor kód odmítne.

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

Chyba je pochopitelná: generické může být libovolný typ a kompilátor neví, zda má count. Omezení Collection problém řeší. Podobně pro Equatable, Hashable, Numeric — vždy uvádějte protokol, pokud plánujete volat metody nebo operátory na generickém parametru.