Equatable, Hashable, Comparable protocols in Swift - Mini Project: Build & Apply

Using Equatable, Hashable, and Comparable Protocols in Swift

📖 Scenario: You are creating a simple app to manage a collection of books. Each book has a title and a number of pages. You want to compare books, check if two books are the same, and use books in sets or as dictionary keys.

🎯 Goal: Build a Swift program that defines a Book struct which conforms to Equatable, Hashable, and Comparable protocols. You will create books, compare them, and print sorted books.

📋 What You'll Learn

Define a struct called Book with properties title (String) and pages (Int).

Make Book conform to Equatable and Hashable protocols automatically.

Make Book conform to Comparable by comparing books based on their pages count.

Create a list of books with exact titles and pages.

Sort the list of books using the Comparable conformance.

Print the sorted list of book titles.

💡 Why This Matters

🌍 Real World

Managing collections of items like books, contacts, or products often requires comparing, checking equality, and using them in sets or dictionaries.

💼 Career

Understanding these protocols is essential for Swift developers to write efficient, clean, and correct code when working with custom data types.

1

Create the Book struct with properties

Define a struct called Book with two properties: title of type String and pages of type Int. Create a constant array called books with these exact entries: Book(title: "Swift Basics", pages: 200), Book(title: "Advanced Swift", pages: 350), Book(title: "iOS Development", pages: 300).

Swift

# Define the Book struct and create the books array
# Your code here

Hint

Use struct Book {} and add two let properties inside. Then create an array books with the exact Book instances.

2

Make Book conform to Equatable and Hashable

Make the Book struct conform to the Equatable and Hashable protocols by adding them after the struct name. No need to write extra code because Swift can synthesize them automatically.

Swift

struct Book: Equatable, Hashable {
    let title: String
    let pages: Int
}

let books = [
    Book(title: "Swift Basics", pages: 200),
    Book(title: "Advanced Swift", pages: 350),
    Book(title: "iOS Development", pages: 300)
]
# Your code here

Hint

Add : Equatable, Hashable after Book in the struct definition.

3

Make Book conform to Comparable by pages

Add Comparable conformance to the Book struct. Implement the required static function func < (lhs: Book, rhs: Book) -> Bool that returns true if lhs.pages is less than rhs.pages.

Swift

struct Book: Equatable, Hashable, Comparable {
    let title: String
    let pages: Int

    static func  Bool {
        // Your code here
    }
}

let books = [
    Book(title: "Swift Basics", pages: 200),
    Book(title: "Advanced Swift", pages: 350),
    Book(title: "iOS Development", pages: 300)
]

Hint

Add , Comparable after Hashable and write the < function comparing pages.

4

Sort and print the book titles

Create a constant called sortedBooks by sorting the books array. Then use a for loop to print each book's title from sortedBooks.

Swift

let sortedBooks = books.sorted()

for book in sortedBooks {
    // Your code here
}

Hint

Use books.sorted() to sort and then print each title in a for loop.

Practice

1.

Which protocol in Swift allows you to check if two instances of a type are equal using ==?

easy

A. Hashable

B. Codable

C. Comparable

D. Equatable

Solution

1. Step 1: Understand the purpose of Equatable

   Equatable protocol allows comparing two instances for equality using ==.

2. Step 2: Compare with other protocols

   Hashable is for hashing, Comparable is for ordering, Codable is for encoding/decoding.

3. Final Answer:

   Equatable -> Option D

4. Quick Check:

   Equality check = Equatable [OK]

Hint: Equality means Equatable protocol [OK]

Common Mistakes:

• Confusing Hashable with Equatable
• Thinking Comparable checks equality
• Mixing Codable with Equatable

2.

Which of the following is the correct way to declare a struct Person that conforms to Equatable and Hashable?

struct Person: ??? {
    var name: String
    var age: Int
}

easy

A. Equatable, Hashable

B. Comparable, Hashable

C. Equatable, Comparable

D. Codable, Hashable

Solution

1. Step 1: Identify needed protocols

   To compare equality and use in sets/dictionaries, use Equatable and Hashable.

2. Step 2: Check syntax for protocol conformance

   Protocols are listed separated by commas after colon in struct declaration.

3. Final Answer:

   Equatable, Hashable -> Option A

4. Quick Check:

   Equality + hashing = Equatable, Hashable [OK]

Hint: List protocols comma-separated after colon [OK]

Common Mistakes:

• Using Comparable instead of Equatable
• Forgetting commas between protocols
• Using Codable instead of Equatable

3.

What will be the output of the following Swift code?

struct Item: Comparable {
    var value: Int
    static func < (lhs: Item, rhs: Item) -> Bool {
        return lhs.value < rhs.value
    }
}

let items = [Item(value: 3), Item(value: 1), Item(value: 2)]
let sortedValues = items.sorted().map { $0.value }
print(sortedValues)

medium

A. [3, 2, 1]

B. [1, 2, 3]

C. [2, 3, 1]

D. Compilation error

Solution

1. Step 1: Understand Comparable conformance

   The < operator compares value properties to sort ascending.

2. Step 2: Analyze sorting and mapping

   Sorting the array orders items by value: 1, 2, 3. Mapping extracts values in this order.

3. Final Answer:

   [1, 2, 3] -> Option B

4. Quick Check:

   Sorted values ascending = [1, 2, 3] [OK]

Hint: Comparable sorts ascending by < operator [OK]

Common Mistakes:

• Assuming descending order by default
• Confusing map output with original array
• Forgetting to implement < operator

4.

Identify the error in this Swift struct that tries to conform to Hashable:

struct Book: Hashable {
    var title: String
    var pages: Int

    func hash(into hasher: inout Hasher) {
        hasher.combine(title)
    }
}

medium

A. Missing combine call for all properties in hash(into:)

B. Struct cannot conform to Hashable without Codable

C. Incorrect method signature for hash(into:)

D. Missing == operator implementation for Equatable

Solution

1. Step 1: Check Hashable requirements

   Hashable requires hashing all properties that affect equality.

2. Step 2: Analyze hash(into:) implementation

   Only title is combined; pages is missing, causing incorrect hashing.

3. Final Answer:

   Missing combine call for all properties in hash(into:) -> Option A

4. Quick Check:

   Hash all relevant properties [OK]

Hint: Hash all properties used in equality [OK]

Common Mistakes:

• Hashing only some properties
• Forgetting to implement == operator if needed
• Wrong method signature for hash(into:)

5.

You want to create a struct Player that can be stored in a Set, compared for equality, and sorted by score descending. Which protocols should Player conform to, and how should you implement the sorting?

hard

A. Conform to Equatable and Hashable; implement < to compare scores descending

B. Conform to Comparable only; implement < to compare scores ascending

C. Conform to Equatable, Hashable, Comparable; implement < to compare scores descending

D. Conform to Hashable only; sorting is automatic

Solution

1. Step 1: Identify needed protocols

   To store in Set and check equality, conform to Equatable and Hashable. To sort, conform to Comparable.

2. Step 2: Implement sorting logic

   Implement < operator to compare scores descending by reversing comparison.

3. Final Answer:

   Conform to Equatable, Hashable, Comparable; implement < for descending scores -> Option C

4. Quick Check:

   Set + equality + custom sort = Equatable, Hashable, Comparable [OK]

Hint: Use all three protocols; reverse < for descending sort [OK]

Common Mistakes:

• Forgetting Comparable for sorting
• Sorting ascending instead of descending
• Missing Equatable or Hashable for Set storage