Generic — istota typów ogólnych i parametr T

Czym jest Generic w Swift?

Generic (typ ogólny) — to konstrukcja składniowa Swift, która pozwala pisać elastyczny, wielokrotnego użytku kod z parametryzacją typu. Zamiast konkretnego typu pisze się placeholder w nawiasach ostrych — zazwyczaj , ale można użyć dowolnej nazwy. Generic leży u podstaw SwiftUI (View, some View), standardowej biblioteki (Array, Optional) i Combine.

Po co są Generic

Bez generic trzeba by pisać osobne funkcje dla każdego typu: swapInts, swapStrings, swapDates. Funkcja generic swap zastępuje wszystkie trzy warianty jedną deklaracją. Zmniejsza to powielanie, zwiększa czytelność i zmniejsza prawdopodobieństwo błędów przy kopiowaniu kodu.

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)

Kompilator Swift generuje wyspecjalizowany kod dla każdego konkretnego użycia generic. Oznacza to, że funkcja generic swapValues nie ma narzutów w porównaniu z ręcznie napisaną funkcją dla Int. Swift nie używa wymazywania typów jak Java — generic istnieją zarówno na etapie kompilacji, jak i w czasie wykonania (choć optymalizacja może je wyspecjalizować).

Funkcje ogólne z parametrem T

Funkcje generic — to funkcje, które przyjmują jeden lub więcej parametrów-typów. Parametry-typy są podawane po nazwie funkcji w nawiasach ostrych: . Mogą być używane w sygnaturze: typ argumentu, typ zwracany i wewnątrz ciała funkcji.

Wiele parametrów-typów

Funkcja może mieć kilka parametrów generic. Na przykład funkcja findKey przyjmuje słownik z kluczami K i wartościami V. Każdy parametr-typ jest unikalny i może być użyty w ograniczeniach.

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
}

Ograniczenia K: Hashable i where V: Equatable gwarantują, że findKey można wywołać tylko ze słownikiem, którego klucze są haszowalne, a wartości porównywalne. Takie ograniczenia to nie biurokracja, ale konieczność: bez Hashable nie można indeksować wyszukiwania po kluczu, bez Equatable nie można porównać value z dictValue.

Ograniczenia typu przez where

where — to słowo kluczowe Swift, które nakłada dodatkowe ograniczenia na parametry generic. W przeciwieństwie do prostego określenia protokołu w nawiasach ostrych (), where pozwala wyrazić bardziej złożone warunki: zgodność z wieloma protokołami, związek między parametrami-typami i doprecyzowanie associated types.

Składnia where

Klauzula where jest pisana po sygnaturze funkcji lub typu przed otwierającym nawiasem klamrowym. W where można określić, że T: Comparable & Hashable (jednocześnie dwa protokoły), lub że T.U == Int (konkretyzacja 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
    }
}

Rozszerzenie z where dodaje metody tylko dla tych typów, które spełniają warunek. Container otrzyma metodę isSorted, a Container — nie, ponieważ Any nie jest Comparable. To potężny mechanizm warunkowej funkcjonalności.

Associated Types w protokołach

Associated Types (typy stowarzyszone) — to sposób na uczynienie protokołu ogólnym bez określania konkretnego typu na etapie deklaracji. Zamiast protokół deklaruje associatedtype, który jest konkretyzowany w implementacji. Jest to szczególnie ważne dla kolekcji: protokół Sequence nie wie, jakie elementy będzie zawierać sekwencja.

Powiązanie associated types przez where

Za pomocą where można ustanawiać powiązania między associated types różnych protokołów. Na przykład można wymagać, aby Item jednego protokołu był zgodny z Iterator.Element innego. Gwarantuje to kompatybilność typów na poziomie kompilacji.

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 konkretyzuje Element jako Int, używając typealias. Kompilator sprawdza, czy wszystkie wymagania protokołu są spełnione z tym typem. Bez associated types trzeba by pisać StackProtocol z protokołem generic, ale Swift używa associated types dla jednolitości z mostami Objective-C i lepszej czytelności.

Generic w rozszerzeniach i subskryptach

Rozszerzenia generic pozwalają dodawać metody do typu generic z dodatkowymi ograniczeniami. To wzorzec „conditional conformance”, gdzie typ otrzymuje funkcjonalność tylko przy określonych warunkach. Subskrypty również mogą być generic.

Subskrypt generic

Subskrypt może być ogólny: przyjmuje parametry generic w nawiasach ostrych. Jest to przydatne do bezpiecznego dostępu do kolekcji z dowolnym indeksem, gdy indeks może być różnych typów.

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

Taka konstrukcja daje potężną kompozycję: metoda sum pojawia się tylko w tablicach numerycznych, a subskrypt z dowolnymi indeksami działa z każdą sekwencją indeksów całkowitych. Kompilator sam zarządza widocznością tych członków na podstawie warunków where.

Typowe błędy przy pracy z generykami

Błędy przy użyciu generic często są związane z nieprawidłowymi ograniczeniami lub próbą użycia generic tam, gdzie potrzebny jest konkretny typ. Rozważmy trzy częste scenariusze, z którymi spotykają się programiści.

Nadmierna parametryzacja

Dodawanie parametrów generic tam, gdzie wystarczy konkretny typ — to antywzorzec. Jeśli funkcja zawsze działa z String, nie trzeba robić jej . Komplikuje to kod bez korzyści. Generic jest uzasadniony, gdy typ rzeczywiście się zmienia, a nie dla abstrakcyjnej „elastyczności na przyszłość”.

Brak ograniczenia where

Wywołanie metody na parametrze generic bez określenia, że metoda istnieje — to błąd. nie może wywołać .count, jeśli nie określono, że T: Collection. Zawsze dodawaj ograniczenia do parametrów-typów, w przeciwnym razie kompilator odrzuci kod.

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

Błąd jest zrozumiały: generic może być dowolnym typem, a kompilator nie wie, czy ma on count. Ograniczenie Collection rozwiązuje problem. Podobnie dla Equatable, Hashable, Numeric — zawsze określaj protokół, jeśli planujesz wywoływać metody lub operatory na parametrze generic.