This morning I was playing with a couple of model objects, trying to find a way to make them conform to Equatable. That’s not a big deal, you might say… well, in this case I wanted to make the protocol those objects implement, not the actual objects, conform to Equatable, so things got a little tricky.
Let’s say this is where I started:
|
1 2 3 4 5 6 7 8 9 |
protocol Drinkable { var name: String { get } var alcohol: Float { get } } struct Beer: Drinkable { let name: String let alcohol: Float } |
Now, I want everything that conforms to Drinkable to be Equatable. So this was my first attempt:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
extension Drinkable: Equatable { } func == (lhs: Drinkable, rhs: Drinkable) -> Bool { return lhs.name == rhs.name && lhs.alcohol == rhs.alcohol } let guiness = Beer(name: "Guiness", alcohol: 6) let anotherGuiness = Beer(name: "Guiness", alcohol: 6) let singha = Beer(name: "Singha", alcohol: 5) print(guiness == anotherGuiness) print(guiness == singha) |
Nah-ha. “Extension of protocol ‘Drinkable’ cannot have an inheritance clause”
The solution? Turning things around little bit (would this qualify as “inverting the dependency”, haha-lol?) and enforce Equatable to respond to == when the type implementing Equatable is Drinkable. In other words…
|
1 2 3 4 5 |
extension Equatable where Self: Drinkable {} func == (lhs: Drinkable, rhs: Drinkable) -> Bool { return lhs.name == rhs.name && lhs.alcohol == rhs.alcohol } |
Ta-dahhhhh!
Here is a playground, just for you: Protocol_Equatable.playground
Hi Cesar !
I’m in no way a Swift expert, but either there is a huge thing I can’t even see or the extension actually does not add anything.
With the extension commented out the Playground’s results are identical.
Moreover, Beer still does not conform to Equatable.
‘func == (lhs: Drinkable, rhs: Drinkable)’ just provides the ability to ‘compare’ (with == operator) two Drinkable but it does not make the Drinkable-conforming types Equatable.
func takesAnEquatable(param: T) {
print(param)
}
takesAnEquatable(guiness) // error: cannot invoke ‘takesAnEquatable’ with an argument list of type ‘(Beer)’
As opposed to a type that does conform to Equatable:
struct Water: Drinkable, Equatable {
let name: String
let alcohol: Float
}
func == (lhs: Water, rhs: Water) -> Bool { // Without that Water does not conform to Equatable
return lhs.name == rhs.name && lhs.alcohol == rhs.alcohol
}
takesAnEquatable(evian) // prints: Water(name: “Evian”, alcohol: 0.0)
‘func == (lhs: Drinkable, rhs: Drinkable)’ just provides the ability to ‘compare’ two Drinkable, even with different types, regardless their Equatable-conforming.
let evian = Water(name: “Evian”, alcohol: 0)
print(evian == guiness) // false
Equatable is about comparing two instances of the same type: func ==(_ lhs: Self, _ rhs: Self) -> Bool
Dude! This is amazing! Worked like a charm for me on Swift 3.0.