Generic — суштина генеричких типова и параметар T

Шта је Generic у Swift-у?

Generic (генерички тип) — је синтаксичка конструкција Swift-а која омогућава писање флексибилног, поново употребљивог кода са параметризацијом по типу. Уместо конкретног типа пише се плејсхолдер у угластим заградама — обично , али се може користити било које име. Generic лежи у основи SwiftUI (View, some View), стандардне библиотеке (Array, Optional) и Combine.

Зашто су потребни Generic

Без generic-а би се морале писати одвојене функције за сваки тип: swapInts, swapStrings, swapDates. Generic функција swap замењује све три варијанте једном декларацијом. Ово смањује дуплирање, повећава читљивост и смањује вероватноћу грешака при копирању кода.

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)

Swift компајлер генерише специјализовани код за сваку конкретну употребу generic-а. То значи да generic функција swapValues нема додатних трошкова у поређењу са ручно написаном функцијом за Int. Swift не користи брисање типова као Java — generic постоје и у фази компајлирања и у runtime-у (иако их оптимизација може специјализовати).

Генеричке функције са параметром T

Generic функције — су функције које прихватају један или више параметара-типова. Параметри-типови се наводе после имена функције у угластим заградама: . Могу се користити у потпису: тип аргумента, повратни тип и унутар тела функције.

Вишеструки параметри-типови

Функција може имати више generic параметара. На пример, функција findKey прихвата речник са кључевима K и вредностима V. Сваки параметар-тип је јединствен и може се користити у ограничењима.

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
}

Ограничења K: Hashable и where V: Equatable гарантују да се findKey може позвати само са речником чији су кључеви хеширани, а вредности упоредиве. Таква ограничења нису бирократија, већ неопходност: без Hashable не може се индексирати претрага по кључу, без Equatable не може се упоредити value са dictValue.

Ограничења типа преко where

where — је кључна реч Swift-а која намеће додатна ограничења на generic параметре. За разлику од једноставног навођења протокола у угластим заградама (), where омогућава изражавање сложенијих услова: усклађеност са више протокола, везу између параметара-типова и прецизирање associated types.

Синтакса where

Клаузула where се пише после потписа функције или типа, пре отварајуће витичасте заграде. У where се може навести да T: Comparable & Hashable (истовремено два протокола), или да T.U == Int (конкретизација 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
    }
}

Проширење са where додаје методе само за оне типове који испуњавају услов. Container добија метод isSorted, а Container — не, јер Any није Comparable. Ово је моћан механизам условне функционалности.

Associated Types у протоколима

Associated Types (асоцијативни типови) — су начин да протокол буде генерички без навођења конкретног типа у фази декларације. Уместо протокол декларише associatedtype, који се конкретизује у имплементацији. Ово је посебно важно за колекције: протокол Sequence не зна које елементе ће секвенца садржати.

Повезивање associated types преко where

Помоћу where се могу успоставити везе између associated types различитих протокола. На пример, може се захтевати да Item једног протокола одговара Iterator.Element другог. Ово гарантује компатибилност типова на нивоу компајлирања.

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 конкретизује Element као Int, користећи typealias. Компајлер проверава да ли су сви захтеви протокола испуњени са овим типом. Без associated types би се морао писати StackProtocol са generic протоколом, али Swift користи associated types ради уједначености са Objective-C мостовима и боље читљивости.

Generic у проширењима и субскриптима

Generic проширења омогућавају додавање метода generic типу са додатним ограничењима. Ово је образац „условне усклађености”, када тип добија функционалност само под одређеним условима. Субскрипти такође могу бити generic.

Generic субскрипт

Субскрипт може бити генерички: прихвата generic параметре у угластим заградама. Ово је корисно за безбедан приступ колекцијама са произвољним индексом, када индекс може бити различитих типова.

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

Оваква конструкција пружа моћну композицију: метод sum се појављује само у нумеричким низовима, а субскрипт са произвољним индексима ради са било којом секвенцом целобројних индекса. Компајлер сам управља видљивошћу ових чланова на основу where услова.

Типичне грешке при раду са генерицима

Грешке при коришћењу generic-а су често повезане са нетачним ограничењима или покушајем коришћења generic-а тамо где је потребан конкретан тип. Размотримо три честа сценарија са којима се сусрећу програмери.

Прекомерна параметризација

Додавање generic параметара тамо где је довољан конкретан тип — антиобразац. Ако функција увек ради са String-ом, не треба је чинити . То компликује код без користи. Generic је оправдан када се тип заиста мења, а не за апстрактну „флексибилност у будућности”.

Недостатак where ограничења

Позивање метода на generic параметру без навођења да метод постоји — грешка. не може позвати .count ако није наведено да је T: Collection. Увек додајте ограничења на параметре-типове, иначе ће компајлер одбити код.

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

Грешка је разумљива: generic може бити било који тип, а компајлер не зна да ли има count. Ограничење Collection решава проблем. Слично за Equatable, Hashable, Numeric — увек наведите протокол ако планирате да позивате методе или операторе на generic параметру.