Swift Protocols

protocol Describable {
    var title: String { get }
    func describe() -> String
}

struct Book: Describable {
    let title: String
    let author: String
    func describe() -> String { "\(title) by \(author)" }
}

• Property requirements state the type and whether they're read-only ({ get }) or also writable ({ get set }). A let or computed property satisfies { get }.
• Conform by adding the protocol after a colon: struct Book: Describable.
• A type can conform to several protocols, separated by commas, and a class lists its superclass first.
• If a requirement is missing, the compiler shows an error and offers to add stubs.

A protocol can be used as a type, so one variable or array can hold different conforming types:

let items: [any Describable] = [Book(...), Film(...), Podcast(...)]
for item in items { print(item.describe()) }

any Describable means "a value of some type that conforms". Functions can accept protocols too, which lets them work with any conforming type. some Describable instead means "one specific conforming type, chosen by the code", which is how SwiftUI's var body: some View works.

A protocol extension adds methods and computed properties to every conforming type, including default implementations of requirements:

extension Describable {
    func printDescription() { print(describe()) }
    func describe() -> String { "Item: \(title)" }     // default
}

Types can use the default or provide their own. This is how Swift shares behaviour without inheritance: a struct can't inherit from another struct, but it can conform to protocols that bring ready-made methods with them.

Just declare conformance, such as struct Point: Equatable, Hashable, and Swift writes the implementation when it can.

A protocol can build on another one. A type that adopts the child protocol must meet both sets of requirements:

protocol Named {
    var name: String { get }
}
protocol Employee: Named {
    var role: String { get }
}
struct Developer: Employee {
    let name: String
    let role: String
}

When a function needs several abilities at once, combine protocols with & instead of inventing a new protocol just for that function:

protocol Aged { var age: Int { get } }

func greet(_ person: some Named & Aged) {
    print("\(person.name), \(person.age)")
}

Any type that conforms to both Named and Aged can be passed in.

Two other modifiers appear often. A method that changes a struct or enum must be declared mutating in the protocol too, as in mutating func toggle(); classes conforming to it simply leave the word out. And protocol Delegate: AnyObject limits a protocol to classes, which lets you hold conforming objects in a weak property.