Explain protocol-oriented programming with protocols and extensions.

Question

IT Interview Practice · Accepted Answer

**Protocol-oriented programming (POP)** is Swift's preferred way to share behavior: instead of inheriting from a base class, types **conform to protocols**, and **protocol extensions** supply reusable default implementations. This gives you composition and code reuse without the rigidity of single inheritance.

## How it works

A protocol declares requirements; an extension on that protocol provides default behavior any conformer inherits for free.

```swift
protocol Identifiable {
    var id: String { get }          // requirement
}

protocol Describable {
    var name: String { get }
}

// Default implementation shared by ALL conformers
extension Describable {
    func describe() -> String { "Item: \(name)" }
}

struct Product: Identifiable, Describable {   // composes multiple protocols
    let id: String
    let name: String
}

Product(id: "1", name: "Book").describe()     // => "Item: Book" (free)
```

## Protocol extensions vs class inheritance

- **Structs and enums can conform** — POP works on value types, class inheritance cannot.
- **Multiple conformance**: a type can adopt many protocols; a class has one superclass.
- **Constrained extensions** add behavior only where it makes sense:

```swift
extension Collection where Element: Numeric {
    func total() -> Element { reduce(0, +) }   // only for numeric collections
}
[1, 2, 3].total()   // => 6
```

## Pitfalls

- **Static vs dynamic dispatch:** a method defined *only* in the extension (not in the protocol) is dispatched statically by the variable's declared type — so overriding it in a conformer may not be called through a protocol-typed reference. Declare it in the protocol to get dynamic dispatch.

## Why it matters

POP is the backbone of the Swift standard library (`Equatable`, `Collection`, `Codable`) and of testable architecture — you depend on protocols and swap conformers for mocks. Interviewers probe this to see if you compose behavior with protocols instead of building deep, brittle class hierarchies.

How it works

Protocol extensions vs class inheritance

Pitfalls

Why it matters

Related questions