Protocol Default Implementations / Protocol Composition

// Default implementation for a protocol
extension ProtocolName {
    func methodName() { /* implementation */ }
}

// Protocol composition
func functionName(param: ProtocolA & ProtocolB) { }

// any (existential type)
var variableName: any ProtocolName

// some (opaque type)
func functionName() -> some ProtocolName { }

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

// Add a default implementation via extension
extension Greetable {
    func greet() -> String {
        return "Hello, I'm \(name)!"
    }
}

protocol Farewell {
    func farewell() -> String
}

struct Person: Greetable, Farewell {
    var name: String
    // greet() uses the default implementation
    func farewell() -> String { "Goodbye from \(name)!" }
}

// Protocol composition
func introduce(_ x: Greetable & Farewell) {
    print(x.greet())
    print(x.farewell())
}

let p = Person(name: "Hanako")
introduce(p)

// any (existential type)
var anyone: any Greetable = Person(name: "Jiro")
print(anyone.greet())

Default protocol implementations are provided using extensions. If a conforming type defines a method with the same name, it overrides the default; otherwise, the default is used. This approach significantly reduces code duplication.

Protocol composition (&) is used when you need a value to conform to multiple protocols simultaneously. Unlike inheritance, it works with classes, structs, and enums alike.

any is an existential type introduced in Swift 5.7 for type erasure. Because it incurs a boxing cost, consider using some or a concrete type in performance-sensitive code. some hides the return type from the caller while letting the compiler track the concrete type, which is why it is widely used in SwiftUI.