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

Что такое Generics в Swift и зачем они нужны

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

Представьте, что вам нужно написать функцию, которая меняет местами два значения. Без 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
}

С Generics это делается одной строкой:

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 10, y = 20
swapValues(&x, &y) // работает с Int

var str1 = "Hello", str2 = "World"
swapValues(&str1, &str2) // работает с String

Основные преимущества Generics

• Безопасность типов: компилятор проверяет типы на этапе компиляции, исключая ошибки времени выполнения
• Переиспользование кода: один раз написанный код работает с любыми типами
• Производительность: Generics в Swift реализованы на уровне компилятора, без потери скорости выполнения
• Читаемость: уменьшает дублирование кода, делает его более лаконичным

Generic функции и параметры типа

Generic функция объявляется с помощью угловых скобок <>, внутри которых указывается параметр типа (обычно обозначается буквой T, но можно использовать любые имена). Параметр типа становится placeholder'ом, который заменяется реальным типом при вызове функции.

Пример: поиск элемента в массиве

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, 3, 12, 7]
if let index = findIndex(of: 12, in: numbers) {
    print("Индекс числа 12: \(index)") // Индекс числа 12: 3
}

let names = ["Анна", "Борис", "Виктор"]
if let index = findIndex(of: "Борис", in: names) {
    print("Индекс имени Борис: \(index)") // Индекс имени Борис: 1
}

Обратите внимание на ограничение T: Equatable. Это type constraint — мы требуем, чтобы тип T поддерживал протокол Equatable, иначе операция сравнения == была бы невозможна.

Generic типы: структуры, классы и перечисления

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

Создание Generic стека

Классический пример — структура данных Stack (стек), работающая с любым типом:

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

// Использование
var intStack = Stack<Int>()
intStack.push(10)
intStack.push(20)
print(intStack.pop() ?? "") // 20

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

Generic перечисления

Перечисления также могут быть обобщёнными. Отличный пример — стандартный тип Optional, который реализован как Generic enum:

enum Result<T, E: Error> {
    case success(T)
    case failure(E)
}

// Использование
func fetchUser(id: Int) -> Result<String, Error> {
    if id > 0 {
        return .success("User_\(id)")
    } else {
        return .failure(NSError(domain: "Invalid ID", code: 400))
    }
}

let result = fetchUser(id: 42)
switch result {
case .success(let username):
    print("Получен пользователь: \(username)")
case .failure(let error):
    print("Ошибка: \(error.localizedDescription)")
}

Расширение Generic типов

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

extension Stack {
    var top: Element? {
        return items.last
    }
    
    mutating func pushMultiple(_ newItems: Element...) {
        for item in newItems {
            items.append(item)
        }
    }
}

var stack = Stack<Double>()
stack.pushMultiple(1.5, 2.7, 3.14)
print(stack.top ?? "") // 3.14

Если расширение должно работать только с определёнными типами, используйте where-условия:

extension Stack where Element: Comparable {
    func sorted() -> [Element] {
        return items.sorted()
    }
}

var numberStack = Stack<Int>()
numberStack.pushMultiple(5, 2, 8, 1)
print(numberStack.sorted()) // [1, 2, 5, 8]

Generic протоколы и Associated Types

Протоколы в Swift не могут иметь параметры типа напрямую, но используют 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]
    }
}

Использование where с протоколами

func allItemsMatch<C1: Container, C2: Container>(
    _