Implementing Equatable for Protocols in Swift

Posted on July 25th, 2016

Last week I attended iOSDevCampDC, where I had the pleasure of hearing @ayanonagon‘s talk on testing. You can view the code sample here.

For testing purposes and to my surprise, she implemented a default Equatable on a protocol similar to this:

protocol Rectangle: Equatable {
    var width: Double { get }
    var height: Double { get}
}

// all objects that conform to this protocol 
// will now have default equality based on the 
// protocol properties
func ==<T: Rectangle>(lhs: T, rhs: T) -> Bool {
    return lhs.width == rhs.width &&
        rhs.height == lhs.height
}

protocol Rectangle: Equatable {

var width: Double { get }

var height: Double { get}

}

// all objects that conform to this protocol

// will now have default equality based on the

// protocol properties

func ==<T: Rectangle>(lhs: T, rhs: T) -> Bool {

return lhs.width == rhs.width &&

rhs.height == lhs.height

}

I say to my surprise, because I never thought of having all objects that conform to a protocol have a default implementation like this. It definitely made me think! And of course it made sense for Ayaka’s example at the time – she added this purely for testing purposes.

But when I played around with this and thought about it some more, I started seeing future bugs. What if the value that conforms to this protocol has other properties as well. Now it has default equality that might not work as intended. For example:

struct ColorfulRectangle: Rectangle {
    let width: Double
    let height: Double
    let color: UIColor
}

let blueRectangle = ColorfulRectangle(width: 10, height: 10, color: .blueColor())
let redRectangle = ColorfulRectangle(width: 10, height: 10, color: .redColor())

// these two rectangles are the same, 
// despite having a different color
blueRectangle == redRectangle // true

struct ColorfulRectangle: Rectangle {

let width: Double

let height: Double

let color: UIColor

}

let blueRectangle = ColorfulRectangle(width: 10, height: 10, color: .blueColor())

let redRectangle = ColorfulRectangle(width: 10, height: 10, color: .redColor())

// these two rectangles are the same,

// despite having a different color

blueRectangle == redRectangle // true

Of course this would be fixed if ColorfulRectangle got it’s own custom Equatable implementation:

func ==(lhs: ColorfulRectangle, rhs: ColorfulRectangle) -> Bool {
    return lhs.width == rhs.width &&
        rhs.height == lhs.height &&
        rhs.color == lhs.color
}

// false as expected
blueRectangle == redRectangle // false

func ==(lhs: ColorfulRectangle, rhs: ColorfulRectangle) -> Bool {

return lhs.width == rhs.width &&

rhs.height == lhs.height &&

rhs.color == lhs.color

}

// false as expected

blueRectangle == redRectangle // false

But the worry is that this could be easily forgotten, especially since the compiler wouldn’t complain about the equality not being implemented.

So while implementing default Equality on a Protocol level is pretty powerful, it’s also a little dangerous. Use responsibly!

Join me for a Swift Community Celebration 🎉 in New York City on September 1st and 2nd. Use code NATASHATHEROBOT to get $100 off!

feloneouscat

This is just as bad as how some have demonstrated Hashable (with arguments that “Oh, we don’t have to have a decent hash function, Equality will take care of that” (Eye-Roll here)

See my article on Hashable:

https://feloneouscat.wordpress.com/2016/03/31/stupid-hash-functions/
Khawer Khaliq

Hi Natasha,

Nice post! This is something that comes up all the time when programming to abstractions. Having faced this with projects I have been working on, I have come up with a way to deal with the issue using type erasure. This allows conforming to Equatable at the protocol level, even for protocols that don’t declare any properties, while ensuring that the actual equality comparison is made at the level of the concrete type.

I have written a two-part post on my blog. Part one demonstrates the problems associated with trying to implement Equatable conformance or even just equality comparisons for protocols. Part two suggests a practical approach to deal with the issue using type erasure, as noted above.

Check out the following links:

https://khawerkhaliq.com/blog/swift-protocols-equatable-part-one/
https://khawerkhaliq.com/blog/swift-protocols-equatable-part-two/

Cheers, Khawer