Swift2: extension to Array that compares exact objects?

Question

I want to find out if an exact instance of an object is in an Array. This seemed like a pretty useful function to have, so I tried to make an extension of Array:

extension Array {
  func containsIdenticalObject(object: AnyObject)->Bool {
    if self.count > 0 {
      for (_, objectToCompare) in self.enumerate() {
        if object === objectToCompare {
          return true
        }
      }
    }
    return false
  }
}

I get the message:

error: binary operator '===' cannot be applied to operands of type 'AnyObject' and 'Element'. 

I have tried jiggering it around with various generic modifications, such as <T: This> and where Self: That, but I always get the same message.

This seems like it should definitely be possible. How do I need to modify this function to make it work?

Edit

I have been able to make this work as a stand-alone function:

func arrayContainsExactInstance<T>(array:[T], _ object:T)->Bool {
  if array.count > 0 {
    for (_, givenObject) in array.enumerate() {
        let givenObjectAsAnyObject = givenObject as! AnyObject
        let targetObjectAsAnyObject = object as! AnyObject
        if ObjectIdentifier(givenObjectAsAnyObject) == ObjectIdentifier(targetObjectAsAnyObject) {
          return true
      }
    }
  }
  return false
}

...which is great, except a) it seems over-complicated, and b) there must be some way to add it to an actual extension...

Answer 1

The "identical operator" === is defined for instances of classes only, therefore you have to restrict the extension to arrays where the elements are instances of a class as well.

AnyObject is the protocol to which all classes implicitly conform, so you can add a where Element : AnyObject restriction to the extension declaration.

Note that the method itself can be simplified.

extension Array where Element : AnyObject {
    func containsIdenticalObject(object: AnyObject) -> Bool {
        return contains { $0 === object }
    }
}

Example:

class MyClass { }

let a = MyClass()
let b = MyClass()
let c = MyClass()
let array = [a, b]

array.containsIdenticalObject(c) // false
array.containsIdenticalObject(b) // true

---

Update: Unfortunately – as you observed – this does not work if the array element type is a protocol:

protocol MyProtocol: AnyObject {} 
class MyClass: MyProtocol {} 
let classInstance = MyClass() 
let classArray: [MyProtocol] = [classInstance] 
classArray.containsIdenticalObject(classInstance) 
// using 'MyProtocol' as a concrete type conforming to protocol 'AnyObject' is not supported

The reason is that a protocol does not conform to itself or to a protocol that it inherits from (compare Protocol doesn't conform to itself?). The same problem would occur with your free function if you restrict the type T to class types instead of forcefully casting the elements to AnyObject:

func arrayContainsExactInstance<T : AnyObject>(array:[T], _ object:T) -> Bool

I don't know how to solve that with the current Swift 2.1, but this problem is unrelated to whether you use an extension method or a free function.

If you are willing to assume that the elements are instances of a class then you can write the extension method as

extension Array {
    func containsIdenticalObject(object: Element) -> Bool {
        guard let obj = object as? AnyObject else { return false }
        return contains { ($0 as? AnyObject) === obj }
    }
}

which is roughly what your function does (only with a conditional cast instead of a forced cast). But note that this might give unexpected results for non-class elements because some types (e.g. Int are silently converted to objects (e.g. NSNumber) where necessary.