If you haven’t heard about Protocol Oriented Programming in Swift, you have been living under a rock for the last two months.
Protocol extensions in particular, which are at the core of whole concept, are neat and abstract and complex, and my brain hurts a little when I think about it. But the thing is, it is not that difficult to wrap your head around them.
Consider a protocol:
|
1 2 3 4 |
protocol Behaviour { func methodA() func methodB() } |
Now, we have two classes that implement that protocol:
|
1 2 3 4 5 6 7 8 9 10 11 |
class ClassA: Behaviour { init() { print("classA initializer") } } class ClassB: Behaviour { init() { print("classB initializer") } } |
But we want them to implement it with a little twist. We want ClassB’s implementation of method B to be a little bit different.
So we can start with a default implementation of the protocol, in a protocol extension:
|
1 2 3 4 5 6 7 8 9 |
extension Behaviour { func methodA() { print("methodA in default extension") } func methodB() { print("methodB in default extension") } } |
And now an extension to that protocol that will only be aplicable to instances of ClassB
|
1 2 3 4 5 |
extension Behaviour where Self: ClassB { func methodB() { print("methodB in specific to class B extension") } } |
And if we do this:
|
1 2 3 4 5 6 7 8 |
let a: Behaviour = ClassA() let b: Behaviour = ClassB() a.methodA() a.methodB() b.methodA() b.methodB() |
We get this trace:
|
1 2 3 4 5 6 |
classA initializer classB initializer methodA in default extension methodB in default extension methodA in default extension methodB in specific to class B extension |
Boom.
Final words
Now, consider the second extension, the one I called ExtensionToClassB. What if, instead of applying that extension to a class type, I apply it to another protocol?
Mind blown.
[…] Swift protocol extensions 101 […]