Protocols

Reviewed & published by Brayan K

Protocols are Swift's way of describing what a type can do without saying how. You'll define and adopt protocols, list property and method requirements, use a protocol as a type, and add shared default behaviour with protocol extensions.

Part of the free Swift course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• • Define a protocol with property and method requirements
• • Adopt a protocol on a struct, class, or enum
• • Conform to multiple protocols at once
• • Use a protocol as a type for variables and arrays
• • Provide default implementations via protocol extensions
• • Recognize built-in protocols like Equatable

1️⃣ Defining & Adopting a Protocol

A protocol lists requirements — properties and methods — with no bodies. A type adopts it by listing it after a colon and then conforming: providing an implementation for every requirement.

// A protocol is a blueprint: it lists requirements but no implementation.
protocol Animal {
    var name: String { get }     // a read-only property requirement
    func makeSound() -> String   // a method requirement (no body here)
}

// A type ADOPTS the protocol by listing it after a colon, then provides
// implementations for every requirement.
struct Dog: Animal {
    let name: String
    func makeSound() -> String { return "Woof" }
}

struct Cat: Animal {
    let name: String
    func makeSound() -> String { return "Meow" }
}

let rex = Dog(name: "Rex")
print("\(rex.name) says \(rex.makeSound())")   // Rex says Woof

2️⃣ Protocol as a Type

Once several types conform to the same protocol, you can treat them uniformly by using the protocol as a type — for example an array of Animal holding both dogs and cats.

// Because Dog and Cat both conform to Animal, you can treat them uniformly
// by using the PROTOCOL as a type.
protocol Animal {
    var name: String { get }
    func makeSound() -> String
}
struct Dog: Animal { let name: String; func makeSound() -> String { "Woof" } }
struct Cat: Animal { let name: String; func makeSound() -> String { "Meow" } }

// An array of 'any Animal' can hold both Dogs and Cats:
let pets: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]

for pet in pets {
    print("\(pet.name): \(pet.makeSound())")
}

3️⃣ Default Implementations

A protocol extension can supply default behaviour. Conformers inherit it automatically and may override it. This is how Swift shares code without class inheritance.

// A protocol extension can supply a DEFAULT implementation. Conformers get
// it for free unless they provide their own.
protocol Greeter {
    var name: String { get }
    func greet() -> String
}

extension Greeter {
    // Default behaviour shared by every conformer:
    func greet() -> String {
        return "Hello, I'm \(name)"
    }
}

struct Person: Greeter {
    let name: String
    // No greet() here — it uses the default from the extension.
}

struct Robot: Greeter {
    let name: String
    // Robot overrides the default:
    func greet() -> String { return "BEEP. UNIT \(name)." }
}

print(Person(name: "Ada").greet())   // Hello, I'm Ada
print(Robot(name: "X1").greet())     // BEEP. UNIT X1.

4️⃣ Conforming to Multiple Protocols

A type can conform to several protocols, and a parameter can require a composition of them with & (e.g. Named & Aged).

// A type can conform to several protocols at once (comma-separated).
protocol Named { var name: String { get } }
protocol Aged  { var age: Int { get } }

struct User: Named, Aged {
    let name: String
    let age: Int
}

func describe(_ thing: Named & Aged) {
    print("\(thing.name) is \(thing.age)")
}

describe(User(name: "Sam", age: 30))   // Sam is 30

Your turn. Fill in the blanks to conform to a protocol and implement its method.

// 🎯 YOUR TURN — fill in the blanks, then run it in SwiftFiddle.
protocol Shape {
    func area() -> Double
}

// 1) Make Square conform to Shape. Replace ___ with the protocol name.
struct Square: ___ {        // 👉 replace ___ with 'Shape'
    let side: Double
    // 2) Provide the required method. Replace ___ with the keyword 'func'.
    ___ area() -> Double {  // 👉 replace ___ with 'func'
        return side * side
    }
}

let s = Square(side: 4)
print(s.area())   // 16.0

Pro Tips

• 💡 Name protocols by capability. Drawable, Comparable, Codable describe what a type can do.
• 💡 Put shared logic in extensions. Defaults keep conformers small.
• 💡 Prefer small protocols. Many focused protocols compose better than one giant one.
• 💡 Let the compiler synthesize Equatable/Hashable when possible.

Common Errors (and the fix)

• "Type 'X' does not conform to protocol 'Y'" — a requirement is missing or has the wrong signature. Implement every member exactly.
• "Protocol 'Y' requirement 'name' cannot be satisfied by a non-final class" — usually a signature mismatch; match the declared types.
• Read-only property declared as let in the protocol — declare protocol properties with var ... { get }, not let.
• Forgetting the colon — adopt with struct Dog: Animal, not a keyword like extends.

📋 Quick Reference

Mini-Challenge: Describable

No blanks this time — just a brief and an outline. Build it, run it, and check your output against the example in the comments.

// 🎯 MINI-CHALLENGE: a Describable protocol
// 1. Define a protocol Describable with a method describe() -> String.
// 2. Add a protocol extension giving a default describe() that returns
//    "An unknown thing".
// 3. Make a struct Book conform; override describe() to return its title.
// 4. Make a struct Mystery conform but DON'T override (uses the default).
// 5. Print both describe() results.
//
// ✅ Expected output:
//    Swift Basics
//    An unknown thing

// your code here

🎉 Lesson Complete!

• ✅ Protocols declare requirements; types conform by implementing them
• ✅ Adopt with a colon: struct Dog: Animal
• ✅ A protocol can be used as a type to store any conformer
• ✅ Protocol extensions supply default implementations
• ✅ Types can conform to many protocols at once

Practice quiz

Continue this course

• Previous: map, filter & reduce
• Next: Extensions — Add functionality to existing types — even ones you don't own

Frequently asked questions

What is a protocol in Swift, and how is it different from a class?

A protocol is a blueprint of requirements — methods, properties, and so on — that a type promises to provide. Unlike a class, a protocol contains no stored state and no implementation by itself (until you add a protocol extension). Structs, enums, and classes can all conform to protocols, and a type can conform to many at once.

How does a type adopt or conform to a protocol?

List the protocol after a colon in the type declaration, e.g. struct Dog: Animal, then implement every requirement the protocol declares. If you miss any requirement, the compiler reports an error. You can conform to several protocols by separating them with commas: struct X: A, B.

Can I use a protocol as a type?

Yes. A protocol can be used as the type of a variable, parameter, or array element, so it can hold any conforming value. For example [Animal] can store both a Dog and a Cat. In recent Swift you write 'any Animal' to make this existential type explicit.

How do I give protocol methods a default implementation?

Add a protocol extension and implement the method there. Every conforming type then gets that behavior for free and can override it by supplying its own implementation. This is the core technique behind protocol-oriented programming and lets you share code without inheritance.

What are some important built-in protocols?

Equatable enables ==, Comparable adds ordering with <, Hashable lets values be used in Sets and as Dictionary keys, and Codable enables encoding/decoding to formats like JSON. Many of these can be synthesized automatically by the compiler when your stored properties already conform.