Type constraints with protocol conformance in Swift

Introduction

Type constraints with protocol conformance help you make sure a type follows certain rules before using it. This keeps your code safe and clear.

When you want a function to accept only types that can do specific actions.

When you want to write reusable code that works with many types but only if they follow a protocol.

When you want to avoid errors by checking type capabilities before running code.

Syntax

Swift

func functionName<T: ProtocolName>(parameter: T) {
    // code using T that conforms to ProtocolName
}

The <T: ProtocolName> means T must follow the rules of ProtocolName.

You can use this with classes, structs, or enums that conform to the protocol.

Examples

This function only accepts types that can greet, using the Greetable protocol.

Swift

protocol Greetable {
    func greet() -> String
}

func sayHello<T: Greetable>(to person: T) {
    print(person.greet())
}

This function requires the type to have an id property from the Identifiable protocol.

Swift

protocol Identifiable {
    var id: String { get }
}

func printID<T: Identifiable>(_ item: T) {
    print("ID is \(item.id)")
}

Sample Program

This program defines a protocol Describable and a struct Car that follows it. The function printDescription only accepts types that conform to Describable. It prints the description of the car.

Swift

protocol Describable {
    func describe() -> String
}

struct Car: Describable {
    var model: String
    func describe() -> String {
        return "Car model: \(model)"
    }
}

func printDescription<T: Describable>(_ item: T) {
    print(item.describe())
}

let myCar = Car(model: "Tesla Model 3")
printDescription(myCar)

Important Notes

Protocols define what methods or properties a type must have.

Type constraints help catch mistakes early by limiting what types can be used.

You can use multiple protocol constraints by separating them with commas, like <T: Protocol1 & Protocol2>.

Summary

Type constraints ensure a type follows a protocol before using it.

This helps write safer and reusable code.

Use <T: ProtocolName> syntax to add constraints.