Wyprowadzanie Hashable/Equatable/Comparable

Co jest generowane automatycznie?

Generowanie dla struktur

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 dla wyliczeń

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

Comparable dla struktur

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)

Niestandardowa równość i haszowanie

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

Najlepsze praktyki

Lista kontrolna generowania

Podsumowanie