Сумна історія про Swift Equatable

class Person: Equatable {
    let name: String

    init(name: String) {
        self.name = name
    }

    static func == (lhs: Person, rhs: Person) -> Bool {
        Swift.print(">> Person operator == called")
        return lhs.name == rhs.name
    }

    static func != (lhs: Person, rhs: Person) -> Bool {
        // Зазвичай я не реалізую цей оператор – компілятор згенерує його сам.
        // Я просто хочу додати трохи логів
        // Навіть якби мені довелось реалізувати !=, я б реалізував його через ==.
        // Заради логування нехай буде дійсно тупий
        //
        Swift.print(">> Person operator != called")
        return lhs.name != rhs.name
    }
}

let john = Person(name: "John")
let jack = Person(name: "Jack")

john == jack // false
john != jack // true

class Worker: Person {
    let job: String

    init(name: String, job: String) {
        self.job = job
        super.init(name: name)
    }

    static func == (lhs: Worker, rhs: Worker) -> Bool {
        Swift.print(">> Worker operator == called")

        return lhs.name == rhs.name &&
               lhs.job == rhs.job
    }

    // не буду реалізовувати !=. Нехай компілятор зробить свою роботу.
}

let johnTheProgramer = Worker(name: "John", job: "iOS Developer")
let johnTheGardener = Worker(name: "John", job: "Gardener")

johnTheProgramer == johnTheGardener // звісно false
johnTheProgramer != johnTheGardener // барабанна дріб – false теж!

// Equatable успадкований від NSObject тут
class Car: NSObject {
    let brand: String

    init(brand: String) {
        self.brand = brand
        super.init()
    }

    static func ==(lhs: Car, rhs: Car) -> Bool {
        return lhs.brand == rhs.brand
    }
}

let toyota = Car(brand: "Toyota")
let toyota2 = Car(brand: "Toyota")

toyota == toyota2 // true
toyota != toyota2 // 💩 true теж

toyota != toyota  // false – той самий вказівник

class Phone: Equatable {
    let brand: String

    init(brand: String) {
        self.brand = brand
    }

    static func == (lhs: Phone, rhs: Phone) -> Bool {
        return lhs.brand == rhs.brand
    }
}

// для iPhone я навіть почну назву класу з маленької літери
//
class iPhone: Phone {
    let model: String

    init(model: String) {
        self.model = model
        super.init(brand: "iPhone")
    }

    static func == (lhs: iPhone, rhs: iPhone) -> Bool {
        return  lhs.brand == rhs.brand &&
                lhs.model == rhs.model
    }
}

let iPhoneX = iPhone(model: "X")

let phones = [ iPhone(model: "3G"), iPhone(model: "4"), iPhoneX, iPhone(model: "6") ]

// пошук ніби працює...
phones.contains(iPhoneX) // true

// або ні?...
phones.firstIndex(of: iPhoneX) // 💩 – 0

// можемо також подивитись як filter "працює":

let oldModels = phones.filter { $0 != iPhoneX }
oldModels.count // 0 (нуль)

// реалізація == базового класу викликається у всіх цих тестах :)

class Animal: NSObject {
    let type: String

    init(type: String) {
        self.type = type
        super.init()
    }

    override func isEqual(_ object: Any?) -> Bool {
        guard let other = object as? Animal else {
            return false
        }

        return self.type == other.type
    }
}

let lizard = Animal(type: "lizard")
let snail = Animal(type: "snail")

assert(lizard == lizard)
assert(false == (lizard != lizard))
assert(false == (lizard == snail))
assert(lizard != snail)

class Cat: Animal {
    let name: String

    init(name: String) {
        self.name = name
        super.init(type: "cat")
    }

    override func isEqual(_ object: Any?) -> Bool {
        if false == super.isEqual(object) {
            return false
        }

        guard let other = object as? Cat else {
            return false
        }

        return self.name == other.name
    }
}

let catTom = Cat(name: "Tom")
assert(catTom == catTom)
assert(false == (catTom != catTom))

let animals = [ Animal(type: "dog"), catTom, Animal(type: "bird") ]

assert(animals.contains(catTom))
assert(1 == animals.firstIndex(of: catTom))