Generics, Type Constraints & Associated Types

In Plain English

Generics allow you to write flexible, reusable functions and types that work with any type while maintaining strict compile-time type safety. Master generic parameters (<T>), type constraints (T: Numeric, T: Equatable), generic structs, and where clauses.

The Mental Model

"A non-generic box is shaped to hold only a single specific shoe. A generic Container<T> is a universal shipping container: it safely transports whatever payload you seal inside (Electronics, Books, Vehicles) while strictly ensuring you get the exact same type back out."

Deep Dive: How It Works

Generic Functions: func swapValues<T>(_ a: inout T, _ b: inout T) works uniformly across all types in Swift.

Type Constraints: func findIndex<T: Equatable>(of item: T, in list: [T]) -> Int? requires that T supports equality checks.

Generic Types: struct Stack<Element> defines a custom LIFO data structure capable of holding any data type.

Where Clauses: Enforce complex relationship constraints (where T: Sequence, T.Element == String).

Syntax Blueprint

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

Define generic types using <T> and constrain parameters with <T: Comparable>.

Core Rules to Remember

Zero Code Duplication: Write one algorithm that works seamlessly across Int, Double, String, and custom structs.

Compile-Time Specialization: The Swift compiler monomorphizes generics into fast specialized machine instructions with zero runtime boxing penalty.

Type Constraints: Use T: Protocol to ensure generic types provide necessary operations (e.g. + for Numeric).

Common Beginner Traps & How to Fix Them

Mistake:Trying to compare generic items (if itemA == itemB) without constraining T: Equatable.

Why it happens: Generic T could be a type that does not support equality comparison.

How to fix: Constrain the generic parameter: <T: Equatable>.

Pro Tip: In Swift 5.7+, you can use the some Protocol and any Protocol syntax for cleaner generic parameters without explicit <T> angle brackets.

Live Interactive Example

Hit Run Code to see it live

Generic Stack Data Structure and Type-Constrained Search

Swift 5.10 / LLVM

Output Console

Click "Run Code" to view the rendered output.

How it works: Stack<String> handled string elements, and findFirst<T: Equatable> verified equality across generic items.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Generic Duplicate Value Finder

Write a generic function hasDuplicate<T: Hashable>(_ array: [T]) -> Bool.
Use Set<T> to check if Set(array).count < array.count.
In top-level code, test with [1, 2, 3, 2] and print "Has duplicates: \(hasDuplicate([1, 2, 3, 2]))".

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.