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 существуют и на этапе компиляции, и в рантайме (хотя оптимизация может их специализировать).

Обобщённые функции с параметром 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-типу с дополнительными ограничениями. Это — паттерн "conditional conformance", когда тип получает функциональность только при определённых условиях. Сабскрипты также могут быть 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 оправдан, когда тип действительно варьируется, а не для абстрактной "гибкости на будущее".

Missing where constraint

Вызов метода на 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-параметре.