Default equality operator for objects in Swift

Question

When using find to search the index of an object in a array:

var index = find(Store.allItems, myItem)

The compiler says that the Item class does not conform to protocol Equatable.

My Item class is an object, so in my opinion, coming from C#, the default equality comparer should be reference equality.

In Swift, It seems that you need to specify Equatable on each reference-type in order for find to work.
Also, you need to imlement the == operator so that it uses === to compare references:

func ==(a:Item, b:Item) -> Bool {
    return a === b
}

Moreover, this last declaration must be top-level code, which disgust me...

I tried writing:

func ==(a:AnyObject, b:AnyObject) -> Bool {
    return a === b
}

but it seems not to work.

Is there some faster and more elegant way to achieve standard equality comparing for objects?

Answer 1

Just try to make Item class conforming to Equatable:

extension Item:Equatable { }
func ==(lhs:Item, rhs:Item) -> Bool {
    return lhs === rhs
}

Answer 2

You can get this to work by using a generic function for your == overload; you'll still have to make your class implement the Equatable protocol, of course.

The implementation would look something like this:

func ==<T: AnyObject>(a: T, b: T) -> Bool {
    return a === b
}

class AClass: Equatable {}

Testing it out:

let a = AClass()
let b = AClass()
let c = AClass()

let arr = [a, b, c]

let idxA = find(arr, a)
let idxB = find(arr, b)
let idxC = find(arr, c)

idxA, idxB, and idxC are 0, 1, and 2 respectively.

Answer 3

If you aren't crazy about implementing a custom operator, you could implement another version of find() that does what you want:

func find<C : CollectionType where C.Generator.Element : AnyObject>(domain: C, value: C.Generator.Element) -> C.Index? {
    var index = domain.startIndex
    while index != domain.endIndex {
        if domain[index] === value {
            return index
        }
        index = index.successor()
    }
    return nil
}

Answer 4

If you only want a reference equality, it's actually easy.

Just make your Item class inherit from NSObject.

class Item: NSObject {
        var name: String

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

let item1 = Item(name: "item1")
let item2 = Item(name: "item2")
let item3 = Item(name: "item3")

let items = [item1, item2, item3]

for item in items {
        if let index = find(items, item) {
                println(items[index].name)
        }
}

// Console Output:
// item1
// item2
// item3

Update

Object Comparison

“There are two distinct types of comparison when you compare two objects in Swift. The first, equality (==), compares the contents of the objects. The second, identity (===), determines whether or not the constants or variables refer to the same object instance.

Swift and Objective-C objects are typically compared in Swift using the == and === operators. Swift provides a default implementation of the == operator for objects that derive from the NSObject class. In the implementation of this operator, Swift invokes the isEqual: method defined on the NSObject class. The NSObject class only performs an identity comparison, so you should implement your own isEqual: method in classes that derive from the NSObject class. Because you can pass Swift objects (including ones not derived from NSObject) to Objective-C APIs, you should implement the isEqual: method for these classes if you want the Objective-C APIs to compare the contents of the objects rather than their identities.

As part of implementing equality for your class, be sure to implement the hash property according to the rules in Object comparison in Cocoa Core Competencies. Further, if you want to use your class as keys in a dictionary, also conform to the Hashable protocol and implement the hashValue property.

Excerpt From: Apple Inc. “Using Swift with Cocoa and Objective-C.” iBooks. https://itun.es/tw/1u3-0.l