Extend existing (generic) swift class to be hashable

Question

I have some class that i want to put into a dictionary however that class is does not conform to Hashable i cant use it as a key in a Swift dictionary. Since its a class it can be identified by its location in memory and im happy to use that its identifier, the type itself doesnt fall into the value semantics world anyway.

Therefore i declare an extension to make it so

extension SomeGenericType : Hashable {

    public var hashValue: Int {
        return unsafeAddressOf(self).hashValue
    }

}

This seems ok, however Hashable inherhits from Equatable so i need to implement tha too, my first try:

public func ==(lhs: SomeGenericType, rhs: SomeGenericType) -> Bool {
    return unsafeAddressOf(lhs) == unsafeAddressOf(rhs)
}

Errors with

 "Reference to generic type 'SomeGenericType' requires arguments in <...>"

...fair enough so lets do that

public func ==<T : SomeGenericType >(lhs: T, rhs: T) -> Bool {
    return unsafeAddressOf(lhs) == unsafeAddressOf(rhs)
}

Now it says

 "Reference to generic type 'SomeGenericType' requires arguments in <...>"

Hmm so i can make this work for all SomeGenericType's regardless of what type it gets. Maybe we can just put AnyObject in there?

public func ==<T : SomeGenericType<AnyObject>>(lhs: T, rhs: T) -> Bool {
    return unsafeAddressOf(lhs) == unsafeAddressOf(rhs)
}

Ok now == is happy but apparantly im not implementing Hashable properly as there is now a error on my hashable extension saying:

"Type 'SomeGenericType<T>' does not conform to protocol 'Equatable'"

Ive tried fiddling with a constrained Extension on SomeGenericType but i cant seem to make a constrained extension of a type adopt another protocol, the language grammar doesnt seem to allow it, so Im in a bit of pickle here

Edit, for reference SomeGenericType is defined as follows:

class SomeGenericType<T> {

}

Ive eddited to show how SomeGenericType is implemented, the original version works when the type im extending is not generic — Luke De Feo, Oct 17 '15 at 16:58

Martin R · Answer 1 · 2016-08-28T09:57:53.703

6

The correct syntax is

public func ==<T>(lhs: SomeGenericType<T>, rhs: SomeGenericType<T>) -> Bool {
    return unsafeAddressOf(lhs) == unsafeAddressOf(rhs)
}

The operands need to be instances of SomeGenericType for the same type placeholder T.

For Swift 3, use ObjectIdentifier instead of unsafeAddressOf.

edited Aug 28 '16 at 09:57

answered Oct 17 '15 at 17:19

Martin R

529,903
94
1,240
1,382

The result of this is that i can only compare equality for two 'someGenericTypes' only if their generic types are the same, where as i cant be sure of that at compile time. Anyway the end result is to put vairous SomeGenericType (where T can be anything) into a dictionary as keys. is this even possible? Basically i want to put them in a hetragenous collection, Have i run into a wierd varient of the Self requirements issue with protocols or is there a way around this. – Luke De Feo Oct 17 '15 at 20:24
@LukeDeFeo: As far as I know, `SomeGenericType` and `SomeGenericType` are different/unrelated types. The Equatable protocol however requires an operator `func ==(lhs: Self, rhs: Self) -> Bool`, i.e. an instance is compared with another instance of the same type. – It might be possible what you want, but it gets more complicated. – Martin R Oct 17 '15 at 20:47
I under what you mean and you are right for value types clearly SomeGenericType and SomeGenericType are not equal. However I'm bending the rules a bit and defining equality based on location in memory aka reference semantics. Is there no way to express this in the swift type system or does it force you into the value semantics view of the world with when you adopt equatable. – Luke De Feo Oct 17 '15 at 20:55
@LukeDeFeo: If you want to put instances of SomeGenericType and SomeGenericType as keys into the same dictionary, what type should that dictionary have? You cannot define a dictionary of type `[SomeGenericType : Int]` without specifying T. A remotely similar problem is here: http://stackoverflow.com/questions/33189345/set-and-protocols-in-swift. – You could solve it by defining a common (non-generic) hashable superclass. – Martin R Oct 17 '15 at 21:00
@LukeDeFeo: You can define `==` as `func ==(lhs: SomeGenericType , rhs: SomeGenericType)`. Then you *can* compare different "types". But that probably won't help to put them as keys into the same dictionary. – Martin R Oct 17 '15 at 21:21

score 0 · Answer 2 · answered Jul 18 '16 at 17:47

This is an older question but I recently run into a similar problem, except I had a struct.

You might want to implement 4 different infix operator functions:

// #1
public func ==<T>(lhs: SomeGenericType<T>, rhs: SomeGenericType<T>) -> Bool {
    return lhs === rhs // it's a class right - check the reference
}

// #2
public func !=<T>(lhs: SomeGenericType<T>, rhs: SomeGenericType<T>) -> Bool {
    return !(lhs === rhs)
}

// #3
public func ==<T, U>(lhs: SomeGenericType<T>, rhs: SomeGenericType<U>) -> Bool {
    return lhs.hashValue == rhs.hashValue
}

// #4
public func !=<T, U>(lhs: SomeGenericType<T>, rhs: SomeGenericType<U>) -> Bool {
    return lhs.hashValue != rhs.hashValue
}

Problem solved? The program should use these and not the generic functions from the stdlib.

You could also check everything by it's hashValue. ;)

Extend existing (generic) swift class to be hashable

2 Answers2