Какие проблемы могут быть с Hashable?

Проблемы с Hashable в Swift

Hashable протокол в Swift позволяет использовать типы в качестве ключей словарей и элементов sets. Однако его неправильное использование может привести к серьёзным ошибкам. Расскажу о основных проблемах.

1. Нарушение контракта Hashable

Основное правило: если два объекта равны (a == b), их хеши должны быть одинаковыми (a.hashValue == b.hashValue). Нарушение этого приводит к непредсказуемому поведению:

struct Person: Hashable {
    let id: Int
    var name: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
    
    static func == (lhs: Person, rhs: Person) -> Bool {
        lhs.id == rhs.id && lhs.name == rhs.name
    }
}

let person1 = Person(id: 1, name: "Alice")
let person2 = Person(id: 1, name: "Bob")

var dict: [Person: String] = [:]
dict[person1] = "Developer"
print(dict[person2])

Правильный подход:

struct Person: Hashable {
    let id: Int
    let name: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
        hasher.combine(name)
    }
    
    static func == (lhs: Person, rhs: Person) -> Bool {
        lhs.id == rhs.id && lhs.name == rhs.name
    }
}

2. Изменяемые свойства в Hashable

Это одна из самых опасных ошибок. Если хеш объекта меняется после его добавления в set или dict, происходит катастрофа:

class User: Hashable, Equatable {
    var id: Int
    var email: String
    
    init(id: Int, email: String) {
        self.id = id
        self.email = email
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
        hasher.combine(email)
    }
    
    static func == (lhs: User, rhs: User) -> Bool {
        lhs.id == rhs.id && lhs.email == rhs.email
    }
}

let user = User(id: 1, email: "alice@example.com")
var users: Set<User> = [user]

user.email = "alice.new@example.com"
print(users.contains(user))

Решение — используй struct с let свойствами:

struct User: Hashable {
    let id: Int
    let email: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
        hasher.combine(email)
    }
}

3. Производительность хеша

Плохо написанный хеш может разрушить производительность:

struct Document: Hashable {
    let id: Int
    let content: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
        hasher.combine(content)
    }
}

Лучший подход — хешируй только ID:

struct Document: Hashable {
    let id: Int
    let content: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
    
    static func == (lhs: Document, rhs: Document) -> Bool {
        lhs.id == rhs.id
    }
}

4. Автоматический синтез Hashable

Swift может автоматически синтезировать Hashable, но это работает только если все свойства Hashable:

struct Point: Hashable {
    let x: Int
    let y: Int
}

struct Container: Hashable {
    let items: [String: Any]
}

Второй пример не скомпилируется, так как Dictionary не конформирует Hashable.

5. Коллизии хешей

Даже правильно реализованный Hashable может иметь много коллизий:

struct BadHash: Hashable {
    let value: Int
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(value % 10)
    }
}

struct GoodHash: Hashable {
    let value: Int
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(value)
    }
}

6. Класс и identity vs equality

Для классов есть особенность — можно использовать identity вместо equality:

class MutableUser: Hashable {
    let id: Int
    var email: String
    
    init(id: Int, email: String) {
        self.id = id
        self.email = email
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(self))
    }
    
    static func == (lhs: MutableUser, rhs: MutableUser) -> Bool {
        lhs === rhs
    }
}

Главные правила

• Используй struct вместо class для Hashable типов
• Только let свойства в Hashable структурах
• Хешируй все поля, участвующие в сравнении
• Оптимизируй производительность — не хешируй большие данные
• Тестируй — проверь контракт Hashable
• Помни о контракте — нарушение приводит к undefined behavior

Hashable требует внимательности, но дает мощный функционал для работы с collections.