0Pricing
Swift Academy · Lesson

Hashable/Equatable/Comparable derivations

Let Swift synthesize Equatable/Hashable (and Codable) for simple structs/enums; implement custom Comparable (lexicographic) and manual hash(into:) when needed.

Hashable/Equatable/Comparable derivations is a free Swift Academy lesson on CoddyKit — lesson 3 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What gets synthesized?

Swift can synthesize common conformances for simple types:

  • Equatable: value equality
  • Hashable: dictionary/set keys
  • Codable: encode/decode

Implement Comparable yourself (lexicographic) or rely on enum case order when applicable.

Synthesis for structs

For structs whose stored properties are Equatable/Hashable, Swift generates both automatically.

struct Point: Equatable, Hashable {
    var x: Int
    var y: Int
    // No extra code: Equatable & Hashable are synthesized
}
let p1 = Point(x: 1, y: 2)
let p2 = Point(x: 1, y: 2)
print(p1 == p2)                 // true
let set: Set<Point> = [p1, p2]  // Hashable works; duplicates coalesce
print(set.count)                // 1

Comparable for enums

An enum without associated values can get Comparable synthesis based on case order.

enum Priority: Comparable { case low, medium, high }
// Comparable is synthesized using case order: low < medium < high
print(Priority.low < .high)  // true

Comparable for structs

For structs, write < manually. A simple lexicographic comparison (last, then first) is common.

struct Person: Comparable, Hashable {
    let last: String
    let first: String
    static func < (lhs: Person, rhs: Person) -> Bool {
        if lhs.last != rhs.last { return lhs.last < rhs.last }
        return lhs.first < rhs.first
    }
}
let a = Person(last: "Doe", first: "Ana")
let b = Person(last: "Doe", first: "Max")
print(a < b)   // true (Ana before Max)

Custom equality & hashing

Write == and hash(into:) when equality/hash should ignore formatting (e.g., case, spaces).

struct FileID: Hashable, Equatable {
    let path: String
    // Normalize case/trim when hashing & comparing
    static func == (l: FileID, r: FileID) -> Bool {
        l.path.lowercased().trimmingCharacters(in: .whitespaces) ==
        r.path.lowercased().trimmingCharacters(in: .whitespaces)
    }
    func hash(into hasher: inout Hasher) {
        hasher.combine(path.lowercased().trimmingCharacters(in: .whitespaces))
    }
}
let f1 = FileID(path: " Readme.md ")
let f2 = FileID(path: "readme.md")
print(f1 == f2)                 // true
print(Set([f1, f2]).count)      // 1

Best practices

Tips:

  • Keep == and hash(into:) consistent: equal values must hash equally.
  • Prefer synthesis first; go manual only for custom semantics.
  • Document ordering rules for Comparable.
  • Use enums without payloads when a simple ordered scale fits.

Synthesis checklist

Quick check: What can Swift synthesize automatically for simple structs/enums?

Recap

Recap: Let Swift synthesize Equatable/Hashable (and Codable) for simple models. Implement Comparable with clear lexicographic rules or rely on enum case order when possible.

Frequently asked questions

Is the “Hashable/Equatable/Comparable derivations” lesson free?

Yes — the full text of “Hashable/Equatable/Comparable derivations” is free to read here on the web, and the Swift Academy course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “Hashable/Equatable/Comparable derivations”?

Let Swift synthesize Equatable/Hashable (and Codable) for simple structs/enums; implement custom Comparable (lexicographic) and manual hash(into:) when needed. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “Hashable/Equatable/Comparable derivations” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Operator overloading & precedence groups
  2. Subscripts & custom indices revisited
  3. Hashable/Equatable/Comparable derivations
← Back to Swift Academy