Why Type constraints with protocol conformance in Swift? - Purpose & Use Cases

The Big Idea

What if you could write one function that magically works for many types without extra work?

The Scenario

Imagine you want to write a function that works only with types that can be compared, like numbers or strings. Without type constraints, you might try to write separate functions for each type or check types manually inside the function.

The Problem

This manual approach is slow and messy. You end up repeating code for each type, and if you forget to handle a type, your program might crash or behave unexpectedly. It's like trying to fit square pegs into round holes by force.

The Solution

Type constraints with protocol conformance let you tell the compiler exactly what kind of types your function can accept. This way, you write one clean function that works with any type that follows the rules (protocol). The compiler helps you catch mistakes early, making your code safer and easier to read.

Before vs After

✗ Before

func compareInts(a: Int, b: Int) -> Bool {
    return a < b
}

func compareStrings(a: String, b: String) -> Bool {
    return a < b
}

✓ After

func compare<T: Comparable>(a: T, b: T) -> Bool {
    return a < b
}

What It Enables

You can write flexible, reusable functions that work with many types safely and clearly.

Real Life Example

Think of a sorting function that can sort numbers, names, or dates without rewriting the code for each type.

Key Takeaways

Manual type checks cause repeated and error-prone code.

Type constraints specify exactly what types a function accepts.

This leads to safer, cleaner, and reusable code.