Приведи пример использования Generics

Пример использования Generics в Swift

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

Базовый пример: обобщённая функция

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

С использованием Generics мы создаём одну универсальную функцию:

// С Generics - единое решение для всех типов
func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Использование с разными типами
var number1 = 5, number2 = 10
swapValues(&number1, &number2)
print("Numbers: \(number1), \(number2)") // Numbers: 10, 5

var text1 = "Hello", text2 = "World"
swapValues(&text1, &text2)
print("Texts: \(text1), \(text2)") // Texts: World, Hello

Практический пример: обобщённая структура Stack

Один из классических примеров — реализация структуры Stack (стек), которая может работать с любым типом элементов:

struct Stack<Element> {
    private var elements: [Element] = []
    
    var isEmpty: Bool {
        return elements.isEmpty
    }
    
    var count: Int {
        return elements.count
    }
    
    // Добавление элемента
    mutating func push(_ element: Element) {
        elements.append(element)
    }
    
    // Извлечение элемента
    mutating func pop() -> Element? {
        return elements.popLast()
    }
    
    // Просмотр верхнего элемента
    func peek() -> Element? {
        return elements.last
    }
}

// Использование стека с разными типами
var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
intStack.push(3)
print("Int stack count: \(intStack.count)") // Int stack count: 3

var stringStack = Stack<String>()
stringStack.push("Apple")
stringStack.push("Banana")
print("Popped from string stack: \(stringStack.pop() ?? "")") // Banana

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

Мы можем расширять обобщённые типы, добавляя новую функциональность:

extension Stack {
    // Преобразование в массив
    func toArray() -> [Element] {
        return elements
    }
    
    // Поиск элемента (только если Element соответствует Equatable)
    func contains(_ element: Element) -> Bool where Element: Equatable {
        return elements.contains(element)
    }
}

Generics с ограничениями (Type Constraints)

Часто нам нужно ограничить типы, с которыми может работать обобщённый код. Например, функция для поиска минимального элемента требует, чтобы тип поддерживал сравнение:

func findMin<T: Comparable>(_ array: [T]) -> T? {
    guard !array.isEmpty else { return nil }
    return array.min()
}

let numbers = [5, 2, 8, 1, 9]
let minNumber = findMin(numbers) // 1

let names = ["John", "Alice", "Bob"]
let minName = findMin(names) // "Alice"

Generics в протоколах

Протоколы также могут быть обобщёнными через Associated Types:

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

struct GenericContainer<T>: Container {
    private var items: [T] = []
    
    var count: Int {
        return items.count
    }
    
    mutating func add(_ item: T) {
        items.append(item)
    }
    
    subscript(i: Int) -> T? {
        guard i >= 0 && i < items.count else { return nil }
        return items[i]
    }
}

Преимущества использования Generics:

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

Пример из стандартной библиотеки Swift

Самые известные примеры Generics в Swift — это стандартные коллекции:

let array: Array<String> = ["A", "B", "C"] // Array<String> — обобщённая коллекция
let dictionary: Dictionary<String, Int> = ["age": 25] // Dictionary<Key, Value>
let optional: Optional<Int> = 42 // Optional<T> — тоже Generic!

Generics являются фундаментальной частью Swift и активно используются в:

• Коллекциях (Array, Dictionary, Set)
• Опциональных типах (Optional)
• Замыканиях с параметрами
• Протоколах с associated types
• Функциях высшего порядка (map, filter, reduce)

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