Why Equatable, Hashable, Comparable protocols in Swift? - Purpose & Use Cases

The Big Idea

What if you could teach your app to instantly know when two things are the same or which one comes first, without writing extra code every time?

The Scenario

Imagine you have a list of friends and you want to find if a particular friend is already in your list, or you want to sort them by their names. Doing this by checking each friend manually one by one or writing custom code every time can be tiring and slow.

The Problem

Manually comparing each friend's details every time you want to check equality or order is error-prone and repetitive. It's easy to forget a detail or write inconsistent code, which leads to bugs and wasted time.

The Solution

Swift's Equatable, Hashable, and Comparable protocols let you define simple rules once, so the system can automatically check if two items are equal, store them efficiently in collections, or sort them. This saves time and avoids mistakes.

Before vs After

✗ Before

func areFriendsEqual(f1: Friend, f2: Friend) -> Bool {
  return f1.name == f2.name && f1.age == f2.age
}

✓ After

struct Friend: Equatable, Hashable, Comparable {
  let name: String
  let age: Int

  static func < (lhs: Friend, rhs: Friend) -> Bool {
    return lhs.name < rhs.name
  }
}

What It Enables

It enables you to easily compare, store, and sort your data with simple, reusable rules that the system understands.

Real Life Example

Think about a contacts app that needs to quickly find if a contact exists, sort contacts alphabetically, or store them in a phonebook without duplicates. These protocols make that smooth and reliable.

Key Takeaways

Manually comparing or sorting data is slow and error-prone.

Equatable, Hashable, Comparable let you define simple rules once.

These protocols help your app compare, store, and sort data easily and correctly.