protocol Basics / Conformance

// Define a protocol
protocol ProtocolName {
    // Required property (read-only or read-write)
    var readOnly: Type { get }
    var readWrite: Type { get set }

    // Required method
    func methodName() -> Type

    // Mutating method (for struct conformance)
    mutating func mutatingMethod()
}

// Conform to a protocol
struct TypeName: ProtocolName {
    // Implement all protocol requirements
}

// Define protocols
protocol Describable {
    var description: String { get }
    func describe()
}

protocol Resizable {
    mutating func resize(by factor: Double)
    var area: Double { get }
}

// Conform a struct to both protocols
struct Circle: Describable, Resizable {
    var radius: Double

    var description: String {
        return "Circle (radius: \(radius))"
    }

    func describe() {
        print(description)
    }

    var area: Double {
        return Double.pi * radius * radius
    }

    mutating func resize(by factor: Double) {
        radius *= factor
    }
}

var circle = Circle(radius: 5.0)
circle.describe()
print("Area: \(String(format: "%.2f", circle.area))")

circle.resize(by: 2.0)
circle.describe()

// Use a protocol as a type
func printInfo(_ item: Describable) {
    item.describe()
}

printInfo(circle)

// Protocol composition (& operator)
func resizeAndDescribe(_ item: inout Describable & Resizable, by factor: Double) {
    item.resize(by: factor)
    item.describe()
}

A protocol defines "what a type can do." By conforming different types to the same protocol, you can achieve polymorphism.

Even if a property requirement is declared as { get } in a protocol, the conforming type can implement it as either a stored property or a computed property. The mutating keyword is required when a struct or enum conforms to a protocol that declares mutating methods. When a class conforms, you can omit mutating.

For protocol default implementations, see Protocol Default Implementations / Protocol Composition.