Swift: different objects with same properties: hash value

My current approach is to use one of the properties' hash value as the hash value for the class, and the

== <T> (lhs: ClassA<T>, rhs: ClassA<T>) -> Bool

function is done by comparing the hash value

That's not how the == and hashValue relationship works – don't do this. What if you get a hash collision? Two different instances with different properties could compare equal.

You should instead implement == to actually compare the properties of two instances. == should return true if two given instances have equivalent properties. The hashValues of two instances should be equivalent if they compare equal with ==.

Now, it might well be the case that you cannot do this comparison unless T is Equatable. One solution to this is to not conform ClassA to Equatable, but instead just overload == for when T is Equatable, such as:

func == <T : Equatable>(lhs: ClassA<T>, rhs: ClassA<T>) -> Bool {
    // stub: do comparison logic
}

You can now just use Sequence's contains(where:) method in conjunction with the == overload in order to check if a given instance is in the array:

var array = [ClassA("foo")] // assuming ClassA has an init(_: T) and a suitable ==
                            // implementation to compare that value

let someInstanceToFind = ClassA("foo")
print(array.contains { $0 == someInstanceToFind }) // true

And if you want ClassA to have a hashValue, then simply write an extension that defines a hashValue when T is Hashable:

extension ClassA where T : Hashable {
    var hashValue: Int {
        return 0 // to do: implement hashValue logic
    }
}

Unfortunately, this does mean that ClassA won't explicitly conform to Hashable when T does – but it will have a hashValue and == implementation. SE-0143: Conditional conformances will change this by allowing explicit conformance to protocols if a given where clause if satisfied, but this is yet to be implemented.

If you need explicit conformance to Hashable (such as for using instances of your class in a Set or as Dictionary keys) – then one solution is to create a wrapper type:

struct HashableClassA<T : Hashable> : Hashable {

    var base: ClassA<T>

    init(_ base: ClassA<T>) {
        self.base = base
    }

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

    var hashValue: Int {
        return base.hashValue
    }
}

Now you just have to wrap ClassA<T> instances in a HashableClassA instance before adding to a Set or Dictionary.

Just realized there is a simple way for achieving the Equatable in

contains()

method: use

return lhs === rhs

in the == function such that objects are compared directly. It's working in this way now.