Generic — сутність узагальнених типів та параметри T

Що таке Generic в Swift?

Generic (узагальнений тип) — це синтаксична конструкція Swift, яка дозволяє писати гнучкий, багаторазово використовуваний код з параметризацією типів. Замість конкретного типу пишеться замісник у кутових дужках — зазвичай , але можна використовувати будь-яке ім’я. Generics лежать в основі SwiftUI (View, some View), стандартної бібліотеки (Array, Optional) та Combine.

Навіщо потрібні Generics

Без generics довелося б писати окремі функції для кожного типу: swapInts, swapStrings, swapDates. Одна узагальнена функція 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. Це означає, що узагальнена функція swapValues не має накладних витрат порівняно з рукописною функцією для Int. Swift не використовує стирання типів, як Java — generics існують і на етапі компіляції, і під час виконання (хоча оптимізація може їх спеціалізувати).

Узагальнені функції з параметром T

Узагальнені функції — це функції, які приймають один або більше параметрів-типів. Параметри-типи вказуються після імені функції в кутових дужках: . Вони можуть використовуватися в сигнатурі: тип аргументу, тип повернення та всередині тіла функції.

Кілька параметрів-типів

Функція може мати кілька узагальнених параметрів. Наприклад, функція 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, яке накладає додаткові обмеження на узагальнені параметри. На відміну від простого зазначення протоколу в кутових дужках (), 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 {
        // Імплементація доступна лише якщо 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 з узагальненим протоколом, але Swift використовує associated types для узгодженості з мостами Objective-C та кращої читабельності.

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 там, де потрібен конкретний тип. Розглянемо три часті сценарії, з якими стикаються розробники.

Надмірна параметризація

Додавання узагальнених параметрів там, де достатньо конкретного типу, — це антипатерн. Якщо функція завжди працює з String, не потрібно робити її . Це ускладнює код без користі. Generic виправданий, коли тип дійсно варіює, а не для абстрактної Б«гнучкості на майбутнєБ».

Відсутність обмеження where

Виклик методу на узагальненому параметрі без зазначення, що метод існує, — помилка. не може викликати .count, якщо не зазначено, що T: Collection. Завжди додавайте обмеження на параметри-типи, -- інакше компілятор відхилить код.

// ❌ Помилка: value не має методу count
func countElements<T>(value: T) -> Int { value.count }

// ✅ Працює: T: Collection гарантує наявність count
func countElements<T: Collection>(value: T) -> Int { value.count }

Помилка зрозуміла: узагальнений може бути будь-яким типом, і компілятор не знає, чи є в нього count. Обмеження Collection вирішує проблему. Те ж саме для Equatable, Hashable, Numeric — завжди вказуйте протокол, якщо плануєте викликати методи або оператори на узагальненому параметрі.