Generics и типизация в Swift: как писать код, который работает за вас

Почему без дженериков ваш Swift-код скоро превратится в спагетти

Представьте, что вы пишете приложение для доставки пиццы. Вам нужно обрабатывать заказы, клиентов, курьеров — и каждый раз писать один и тот же код для сортировки, поиска или фильтрации, меняя только тип данных? Звучит как кошмар любого разработчика. Именно здесь на сцену выходят Generics в Swift — мощный инструмент, который позволяет писать гибкий, переиспользуемый код, не жертвуя безопасностью типов.

В этой статье мы не просто пробежимся по синтаксису. Мы разберём, как типизация в Swift и дженерики работают в связке, чтобы ваш код был не только красивым, но и надёжным. Вы узнаете, как избавиться от копипаста, как использовать protocol с associatedtype и почему where-клаузы — ваш лучший друг.

Что такое Generics и почему они меняют правила игры

Generics (дженерики, обобщённые типы) — это механизм, который позволяет писать функции, структуры, классы и перечисления, работающие с любым типом данных, который удовлетворяет определённым условиям. Вместо того чтобы писать три версии функции для Int, String и Double, вы пишете одну, которая работает с любым типом.

В Swift типизация строгая и статическая. Это значит, что компилятор проверяет типы на этапе компиляции. Generics не нарушают это правило — они делают его более гибким. Компилятор сам выводит конкретный тип при вызове функции, но проверки остаются.

Первый пример: функция без дженериков

// Плохо: три функции для трёх типов
func swapInts(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

func swapStrings(_ a: inout String, _ b: inout String) {
    let temp = a
    a = b
    b = temp
}

func swapDoubles(_ a: inout Double, _ b: inout Double) {
    let temp = a
    a = b
    b = temp
}

А теперь — элегантное решение с дженериками:

// Хорошо: одна функция для всех типов
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) // T = Int

var name1 = "Alice"
var name2 = "Bob"
swapValues(&name1, &name2) // T = String

Видите магию? <T> — это placeholder (заполнитель) типа. Компилятор сам подставляет реальный тип при вызове. Это и есть основа обобщённого программирования в Swift.

Generic-типы: создаём свой универсальный стек

Дженерики в Swift работают не только с функциями, но и с целыми типами. Давайте создадим структуру Stack — классический пример структуры данных LIFO (Last In, First Out).

struct Stack<Element> {
    private var items: [Element] = []
    
    mutating func push(_ item: Element) {
        items.append(item)
    }
    
    mutating func pop() -> Element? {
        return items.popLast()
    }
    
    func peek() -> Element? {
        return items.last
    }
    
    var count: Int {
        return items.count
    }
}

// Использование:
var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
intStack.push(3)
print(intStack.pop() ?? 0) // 3

var stringStack = Stack<String>()
stringStack.push("Swift")
stringStack.push("Generics")
print(stringStack.peek() ?? "") // "Generics"

Обратите внимание: тип Element мы указываем в угловых скобках при объявлении структуры. При создании экземпляра мы конкретизируем его — Stack<Int> или Stack<String>. Компилятор гарантирует, что вы не сможете случайно положить строку в стек целых чисел.

Protocol с associatedtype: дженерики для протоколов

В Swift протоколы не могут иметь generic-параметров напрямую. Вместо этого используется associatedtype — ассоциированный тип. Это мощный паттерн, который лежит в основе многих фреймворков Apple.

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

// Реализация для нашего стека
extension Stack: Container where Element: Equatable {
    mutating func append(_ item: Element) {
        push(item)
    }
    
    subscript(i: Int) -> Element {
        return items[i]
    }
}

Здесь associatedtype Item — это placeholder, который будет конкретизирован в реализации. При этом мы добавили ограничение where Element: Equatable, что значит: этот extension работает только для тех элементов, которые можно сравнивать.

Ограничения (Constraints): когда не все типы подходят

Иногда вам нужно, чтобы дженерик работал не с любым типом, а только с теми, которые соответствуют определённым условиям. Для этого используются generic constraints.

Базовые ограничения

// Функция работает только с типами, которые можно сравнивать
func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

let numbers = [3, 5, 7, 9]
if let index = findIndex(of: 7, in: numbers) {
    print("Индекс: \(index)") // Индекс: 2
}

Ограничение T: Equatable гарантирует, что для типа T определён оператор ==. Без этого ограничения код бы не скомпилировался.

Множественные ограничения и where-клаузы

protocol Summable {
    static func + (lhs: Self, rhs: Self) -> Self
}

extension Int: Summable {}
extension Double: Summable {}

// Множественные ограничения
func sum<T>(_ a: T, _ b: T) -> T where T: Summable, T: Equatable {
    return a + b
}

print(sum(5, 10)) // 15
print(sum(3.14, 2.86)) // 6.0

Ограничения можно комбинировать через запятую и использовать where для более сложных условий. Например, вы можете потребовать, чтобы тип соответствовал двум протоколам одновременно.

Расширения с where-клаузами: точечная настройка

Одна из самых мощных возможностей Swift — расширять generic-типы с дополнительными методами, доступными только при определённых условиях.

extension Stack where Element: Equatable {
    func contains(_ item: Element) -> Bool {
        return items.contains(item)
    }
}

extension Stack where Element: CustomStringConvertible {
    func printAll() {
        for item in items {
            print(item.description)
        }
    }
}

// Теперь:
var myStack