Reduce boilerplate code with an automatic synthesis of Equatable and Hashable conformance

Swift Swift 4.1 Equtable Hashable

Equatable and Hashable are two essential protocols in the Swift world. Today, you will learn an old Swift feature that is very helpful if you want to make your types conform to those protocols.

Equatable #

Equatable make your types can be compared for value equality.

In the past, you have to do all of this manually.

struct Person {
let firstName: String
let lastName: String
}

If you want to compare two Person, you have to conform Equatable and write an implementation detail yourself.

extension Person: Equatable {
static func == (lhs: Person, rhs: Person) -> Bool {
return
lhs.firstName == rhs.firstName &&
lhs.lastName == rhs.lastName
}
}

This might seem like a trivial task, but most of your models are struct, which should be able to test for equality like other value types. That means you have to do it repeatedly for all of your models, which is a tiring process and error-prone.

Automatic Synthesis Of Equatable #

In Swift 4.1, you can remove the boilerplate entirely. You only need to tell the compiler that you want to opt-in for Equatable by declaring the protocol's conformance.

So, this is all you need to do to make your custom type conform Equatable.

struct Person: Equtable {
let firstName: String
let lastName: String
}

// Or

struct Person {
let firstName: String
let lastName: String
}

extension Person: Equatable {}

Hashable #

Hashable makes your types can be hashed to produce an integer value, which is required if you want your type to be used as a key in Dictionary or add to a Set.

To make our Person struct support Hashable, we can manually do it like this.

extension Person: Hashable {
func hash(into hasher: inout Hasher) {
hasher.combine(firstName)
hasher.combine(lastName)
}
}

Automatic Synthesis Of Hashable #

Just like Equatable, Swift 4.1 automatically synthesize conformance to Hashable.

You can opt-in for this by declaring the conformance to the protocol. Since Hashable is a inherits from Equatable, you also get synthesis for Equatable for free.

struct Person: Hashable {
let firstName: String
let lastName: String
}

// Or

struct Person {
let firstName: String
let lastName: String
}

extension Person: Hashable {}

Limitations and conditions #

There are some limitations and conditions that you should know.

Overriding synthesized conformances #

If you have don't want to compare every property in your type, You can provide implementations of == or func hash(into: inout Hasher) and that will override the one that generated by the compiler.

Conditions where synthesis is allowed #

For a struct, it only works if all of its stored instance properties conform to Equatable or Hashable.

For an enum with an associated value, it only works if all of its cases conform to Equatable or Hashable.

For an enum with no associated values, Swift already derives Equatable and Hashable conformance for them without opting in.

I find this automatic synthesis of Equatable and Hashable is particularly useful for an enum.

The code that must be written to implement equality for enums is quite verbose and very error-prone. If you add a new enum case and forget to add a counterpart == case, the bug is waiting for you there.

enum Token: Equatable {
case string(String)
case number(Int)
case lparen
case rparen

static func == (lhs: Token, rhs: Token) -> Bool {
switch (lhs, rhs) {
case (.string(let lhsString), .string(let rhsString)):
return lhsString == rhsString
case (.number(let lhsNumber), .number(let rhsNumber)):
return lhsNumber == rhsNumber
case (.lparen, .lparen), (.rparen, .rparen):
return true
default:
return false
}
}
}

With automatic synthesis, you can save yourself from all the headaches and reduce the code to this.

enum Token: Equatable {
case string(String)
case number(Int)
case lparen
case rparen
}

Synthesis for class types and tuples #

Synthesize conformances for class, and tuples are not supported.

Conclusion #

Things move quickly in the iOS development world. Each year you have a lot of stuff to cache up, and it is ok to miss some of them. Today, I introduced you to a handy Swift feature that I don't aware of (I knew it and forgot about its existence), and it introduced way back in Swift 4.1 on March 29, 2018.


Feel free to follow me on Twitter and ask your questions related to this post. Thanks for reading and see you next time.

If you enjoy my writing, please check out my Patreon https://www.patreon.com/sarunw and become my supporter. Sharing the article is also greatly appreciated.

Become a patron Tweet Share

If you enjoy this article, you can subscribe to the weekly newsletter.

Every Friday, you’ll get a quick recap of all articles and tips posted on this site — entirely for free.

← Home