Swift: Why You Should Avoid Using Default Implementations in Protocols

Composition over inheritance, the interface-segregation principle, method dispatch, and unit testing

Photo by Alex Knight on Unsplash

Because the reasons for not using them outweigh the benefits you’d get from doing so. Let’s see some of them:

• Composition over inheritance and interface-segregation principles.
• Method dispatch for protocols.
• Unit Testing.

Protocol Default Implementation

As mentioned in Swift’s documentation:

“You can use protocol extensions to provide a default implementation to any method or computed property requirement of that protocol.”

In fact, not only can you provide a default implementation to methods or computed properties defined in the protocol, you can also add new ones.

Let’s see an example:

protocol SampleProtocol {
  func foo()
}
extension SampleProtocol {
  func foo() {
    print("foo")
  }
  func bar() {
    print("bar")
  }
}
class SampleClass: SampleProtocol {}
let sample: SampleProtocol = SampleClass()
sample.foo() // prints "foo"
sample.bar() // prints "bar"

Favor Composition Over Inheritance

In my opinion, the fact that you need a default implementation for a method or computed property is a code smell.

If you’re not familiar with this term, a code smell is something in the code that possibly indicates a deeper problem.

There might be other reasons why you would think you need to use this approach but the most probable one is to avoid code duplication. If that’s the case, you’d be doing something similar to subclassing an abstract BaseX class and that’s not exactly the best approach.

According to the OOP principles, you should favor composition over inheritance for that purpose.

Inheritance is more rigid, avoids concrete implementation to be injected or changed at runtime, breaks encapsulation, decreases code legibility, makes testing more difficult, etc.

I talk about the topic in another article.

Interface Segregation Principle

Another reason why you would need to use default implementation is that you miss having optional methods in Objective-C protocols. You might want to provide a default implementation as a replacement.

Again, this might not be the best approach. The interface-segregation principle is one of the five SOLID principles and states that no client should be forced to depend on methods it does not use.

In short: If that’s the case, split your protocol into smaller ones.

Method Dispatch

If we go back to the first example of the article and try to override the protocol’s default implementation, let’s see what happens:

protocol SampleProtocol {
    func foo()
}
extension SampleProtocol {
    func foo() {
        print("protocol foo")
    }
    func bar() {
        print("protocol bar")
    }
}
class SampleClass: SampleProtocol {
    func foo() {
        print("class foo")
    }
    func bar() {
        print("class bar")
    }
}
let sample: SampleProtocol = SampleClass()
sample.foo() // prints "class foo"
sample.bar() // prints "protocol bar"

I repeat:Sample.bar() prints “protocol bar”.

If you, or anyone reading your code, are not familiar with how method dispatch works in Swift, it’s quite counterintuitive.

And, it is also a source of hard-to-find bugs.

This is why it happens:

SampleProtocol defines two methods: foo(), which is defined in the protocol as requirement, and bar(), which is defined in the extension.

Protocol-required methods use dynamic dispatch, which chooses the method implementation to execute at runtime.

Extension-defined methods use static dispatch, which chooses the method implementation to execute at building time. That means that the only implementation used will be the one of the extension. And, you can’t override it.

Dispatch Precedence and Constraints

Following with the Method Dispatch issue, there’s another thing to take in account if you’re using constraints:

protocol SampleProtocol {
    func foo()
}
extension SampleProtocol {
    func foo() {
        print("SampleProtocol")
    }
}
protocol BarProtocol {}
extension SampleProtocol where Self: BarProtocol {
    func foo() {
        print("BarProtocol")
    }
}
class SampleClass: SampleProtocol, BarProtocol {}
let sample: SampleProtocol = SampleClass()
sample.foo() // prints "BarProtocol"

You can override default implementations (as long as they are required by the protocol) using constraints. And constrained default implementations have precedence over the not constrained.

So the precedence would be: class/struct/enum conforming the protocol -> constrained protocol extension -> simple protocol extension.

Again, you possibly knew that already, but it might definitely be confusing for anyone else reading, changing, or debugging your code.

Unit Testing

Assuming that you’re writing tests for your code, injecting dependencies, and using mocks, you will find difficulties trying to both: mock protocols with default implementations and test those default implementations.

When you try to mock protocols with default implementations you will run into the method dispatch issue and, therefore, you won’t be able to mock extension-defined methods:

protocol DependencyProtocol {}
extension DependencyProtocol {
    func foo() -> Int {
        return 0
    }
}
class SampleClass {
    let dependency: DependencyProtocol
    init(dependency: DependencyProtocol) {
        self.dependency = dependency
    }
    
    // You will never be able to mock dependency.foo()
    func sampleMethod() {
        let dependencyValue = dependency.foo()
        print(dependencyValue)
    }
}

Additionally, you might find difficulties detecting when and where to mock newly added methods with default implementations because the compiler won’t complain about it.

You might end up including default implementations in other classes’ tests, instead of mocked methods.

Testing default implementations is not a minor issue because you would have to code and instantiate a dummy class conforming to the protocol, so you can call those methods.

This dummy class would have to implement all those protocol-required methods that don’t have default implementation.

protocol SampleProtocol {
    func same(input: Int) -> Int
}
extension SampleProtocol {
    func double(input: Int) -> Int {
        return input * input
    }
}
// You need a dummy class so you can call protocol default implementations
class SampleProtocolDummy: SampleProtocol {
    // You need to implement notimplemented-required-methods with dummy code
    func same(input: Int) -> Int {
        return 0
    }
}
let sut: SampleProtocol = SampleProtocolDummy()
let result = sut.double(input: 2)
XCTAssertEqual(expectedResult, result)

Thanks for reading!
If you liked the article, please clap :)