Generics в Swift для начинающих: зачем нужны и как использовать

Введение: Почему без Generics в Swift никуда?

Представьте, что вам нужно написать функцию, которая складывает два числа. Затем — функцию для сложения двух строк. А потом — для массивов. Без обобщенного программирования (Generics) вам пришлось бы создавать отдельную версию кода для каждого типа данных. Это не только увеличивает объем кода, но и усложняет его поддержку.

Generics (дженерики) в Swift — это мощный инструмент, который позволяет писать гибкий, переиспользуемый и типобезопасный код. Они являются фундаментом таких популярных структур, как Array, Dictionary и Optional. В этой статье мы разберем, зачем нужны Generics, как их использовать на практике и почему каждый начинающий iOS/macOS разработчик должен освоить эту тему.

Что такое Generics простыми словами?

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

Проблема без Generics

Допустим, вы пишете функцию для обмена значениями двух переменных. Без 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
}

Это явное дублирование. Если понадобится обменять Double или пользовательские типы, количество функций будет расти.

Решение с Generics

Одна универсальная функция заменит все предыдущие:

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) // x = 20, y = 10

var firstName = "Анна"
var lastName = "Иванова"
swapValues(&firstName, &lastName) // firstName = "Иванова"

Угловые скобки <T> объявляют плейсхолдер типа. Компилятор автоматически определяет, что T — это Int в первом случае и String во втором. Код становится лаконичным и безопасным.

Как использовать Generics: основные сценарии

Generics в Swift применяются в функциях, структурах, классах, перечислениях и протоколах. Рассмотрим самые частые случаи.

1. Обобщенные функции

Мы уже видели пример с swapValues. Но можно пойти дальше — создать функцию, которая находит индекс элемента в массиве:

func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {
    for (index, element) in array.enumerated() {
        if element == value {
            return index
        }
    }
    return nil
}

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

Обратите внимание на <T: Equatable>. Это ограничение типа (type constraint). Мы говорим: «T должен соответствовать протоколу Equatable, чтобы мы могли использовать оператор ==». Без этого ограничения код не скомпилируется.

2. Обобщенные типы (структуры и классы)

Создадим простую структуру «Стек» (LIFO), которая может хранить любые типы:

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 intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
print(intStack.pop() ?? "Пусто") // 2

var stringStack = Stack<String>()
stringStack.push("Hello")
print(stringStack.peek() ?? "Пусто") // Hello

Тип Element — это плейсхолдер. При создании стека для Int компилятор проверяет, что все операции типовые. Ошибка вроде intStack.push("строка") будет поймана на этапе компиляции.

3. Расширения обобщенных типов

Вы можете расширять обобщенный тип, добавляя новые методы. Например, добавим метод для очистки стека:

extension Stack {
    mutating func clear() {
        items.removeAll()
    }
}

var myStack = Stack<Double>()
myStack.push(3.14)
myStack.clear()
print(myStack.peek() ?? "Пусто") // Пусто

Обратите внимание: в расширении мы не указываем <Element> — Swift автоматически использует его из исходного объявления.

4. Generics и протоколы (Associated Types)

Иногда нужно сделать обобщенным сам протокол. Для этого используются ассоциированные типы (associated types).

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

// Реализация протокола для нашего стека:
extension Stack: Container {
    mutating func append(_ item: Element) {
        push(item)
    }

    var count: Int {
        return items.count
    }

    subscript(i: Int) -> Element {
        return items[i]
    }
}

Теперь любой тип, соответствующий Container, гарантирует, что его элементы однотипны. Это мощный паттерн, используемый в стандартной библиотеке Swift.

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

Generics становятся еще гибче с помощью where-клауз. Они позволяют накладывать дополнительные условия на типы.

Пример: функция для слияния двух контейнеров

func merge<C1: Container, C2: Container>(_ first: C1, _ second: C2) -> [C1.Item]
    where C1.Item == C2.Item, C1.Item: Equatable {