What are generics in Swift and how to use them?

What are generics in Swift? How to use generics? What are generic constraints and associated types?

Generics in Swift are a powerful feature that allows you to write flexible, reusable code while maintaining type safety. Generics enable you to write functions and types that work with multiple types without repeating code for each type.

Basic Concepts of Generics:

• Generics allow you to use placeholder type names (like T) to represent types
• The compiler infers the specific type when used
• Provides type safety, avoiding runtime type errors
• Reduces code duplication and improves code reusability

Generic Functions:

swift
// Generic function example
func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Using generic function
var x = 10
var y = 20
swapValues(&x, &y)

Generic Types:

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

// Using generic type
var intStack = Stack<Int>()
intStack.push(1)

Generic Constraints:

• Restrict generic types to conform to specific protocols
• Use where clause to add more complex constraints
• Common constraint types:
  • T: Equatable - Type must conform to Equatable protocol
  • T: Comparable - Type must conform to Comparable protocol
  • T: SomeProtocol - Type must conform to specified protocol
  • T: AnyObject - Type must be a class type

swift
// Generic constraint example
func findFirstIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {
    for (index, item) in array.enumerated() {
        if item == value {
            return index
        }
    }
    return nil
}

// Using where clause
func allItemsMatch<C1: Container, C2: Container>(_ container1: C1, _ container2: C2) -> Bool
    where C1.Item == C2.Item, C1.Item: Equatable {
    return true
}

Associated Types:

• Placeholder type names defined in protocols
• Declared using associatedtype keyword
• Allows protocols to define flexible type requirements
• Specify concrete types when conforming to protocols

swift
// Protocol with associated type
protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

// Conforming to protocol and specifying associated type
struct IntStack: Container {
    typealias Item = Int
    private var items: [Int] = []
    
    mutating func append(_ item: Int) {
        items.append(item)
    }
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> Int {
        return items[i]
    }
}

Best Practices:

1. Reasonably use generics to improve code reusability
2. Use generic constraints to ensure type safety
3. Use associated types in protocols for flexibility
4. Avoid overusing generics that leads to code complexity
5. Use meaningful names for generic parameters