Generics in Swift: Complete Guide with Code Examples

Generics in Swift: Why They Are Needed and How to Use Them in Practice

Generics (generic programming) is one of the most powerful and fundamental features of the Swift language. They allow you to write flexible, type-safe, and reusable code, avoiding duplication. If you have ever used Array<Int>, Dictionary<String, Any>, or Optional<T>, you have already encountered generics. In this article, we will break down why they are needed, how to use them correctly, and look at practical examples for iOS/macOS development.

Why Are Generics Needed in Swift?

The main problem that generics solve is the need to write the same code for different data types. Without them, you would have to create separate functions for working with Int, String, Double, and custom structures. This leads to code duplication, errors, and increased maintenance complexity.

Key advantages of generics:

• Type safety: the compiler checks types at compile time, preventing runtime errors.
• Code reuse: one function or type works with any data type.
• Performance: generics in Swift are implemented through specialization — the compiler creates optimized code for each specific type, comparable to manually writing duplicate code.
• Readability and abstraction: the code becomes more concise and expressive.

Let's look at a simple example. Suppose we need a function to swap the values of two variables. Without generics, you would have to write it like this:

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}// ... and so on for each type

With generics, the solution becomes universal:

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

var x = 10var y = 20swapValues(&x, &y) // Works with Int

var str1 = "Hello"var str2 = "World"swapValues(&str1, &str2) // Works with String

As you can see, <T> is a placeholder for the type. The compiler automatically infers the specific type when the function is called.

Generic Functions and Types

Generics can be used not only with functions but also with custom types: structures, classes, and enumerations.

Generic Functions

In addition to a simple placeholder, you can impose constraints on the type. For example, a function that only works with types that implement the Equatable protocol:

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

let numbers = [1, 5, 3, 12]if let index = findIndex(of: 5, in: numbers) {    print("Index found: \\(index)") // Output: Index found: 1}

The constraint <T: Equatable> guarantees that the == operator is defined for type T.

Generic Types (Structures and Classes)

Let's create a simple stack — a data structure operating on the LIFO (Last In, First Out) principle:

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

var intStack = Stack<Int>()intStack.push(10)intStack.push(20)print(intStack.pop() ?? 0) // 20

var str