Can't make Swift use my Generic == Operator - ios

Question

My app contains many Core Data NSManagedObject subclasses, all of which have an NSDate which I call their recordID. When comparing two objects, I want to use this data to determine if they are the same. Now since there are many subclasses, I created a protocol to show that they all implement a recordID:
protocol HasID
{
var recordID: NSDate {get}
}
Simple, right? Now I have implemented the == operator as follows:
func == <T: HasID>(left: T, right: T) -> Bool
{
return left.recordID == right.recordID ? true : false
}
Problem- Swift doesn't use my beautiful == operator and instead compares with some generic crap as follows
func ==(lhs: NSObject, rhs: NSObject) -> Bool
Now if I implement == for each individual subclass as follows
func == (left: Pilot, right: Pilot) -> Bool
{
return left.recordID == right.recordID ? true : false
}
Then it uses my operator and works. (I've also got a == operator implemented for NSDate which is why the above code is fine.)
Any idea how I can get my generic == operator to be used rather than the NSObject one?

Answer 1

Putting together previous comments and proposal, it seems it is due to NSManagedObject.
Put the following code in a playground:
import UIKit
import CoreData
protocol HasID
{
var recordID: NSDate {get}
}
func == <T: HasID>(left: T, right: T) -> Bool
{
println("==")
return left.recordID.isEqualToDate(right.recordID)
}
func ~= <T: NSManagedObject where T: HasID>(left: T, right: T) -> Bool
{
println("~=")
return left.recordID.isEqualToDate(right.recordID)
}
class Managed: NSManagedObject, HasID {
let recordID: NSDate = {
let components = NSDateComponents()
components.day = 31
components.month = 3
components.year = 2015
let gregorian = NSCalendar(calendarIdentifier: NSGregorianCalendar)!
return gregorian.dateFromComponents(components)!
}()
}
let foo = Managed()
let bar = Managed()
foo == bar
foo ~= bar
switch foo {
case bar:
println("Equal")
default:
println("Not Equal")
}
As you will see the overloaded == is never called, but ~= is.
Thus I suggest not going too far forcing NSManagedObject to use an overloaded == and use ~= instead. As you can see, you will get it to work in switch statements as well (in fact it is the pattern match operator).
If you play removing NSManagedObject from my example, you will see that for an ordinary class, your solution would work.
My opinion is that == operator for NSManagedObject is used to compare between managed object ids, and not pointers in memory. The same managed object could have different pointers in memory when it is present in different managed object context. That's why I wouldn't try to overload it. It helps keep track of the same managed object in different context.

Answer 2

You can declare an infix operator:
// I've modified your protocol just for my example
protocol HasID
{
var recordID: Int {get}
}
infix operator <*> {
associativity right
}
func <*> (left: HasID, right: HasID) -> Bool
{
return left.recordID == right.recordID ? true : false
}
// example:
class Fake: HasID {
var recordID = 1
}
class Bull: HasID {
var recordID = 1
}
let fake = Fake()
let bull = Bull()
if fake <*> bull {
println("is equal")
}