Is it possible to make a Heterogeneous Set in Swift?

Question

Consider this example:

protocol Observable: Hashable {
    // ...
}

struct People: Observable {
    var name: String
    var age: Double

    var hashValue: Int {
        // ...
    }

    static func ==(lhs: People, rhs: People) -> Bool {
        // ,,,
    }
}

struct Color: Observable {
    var red: Double, green: Double, blue: Double

    var hashValue: Int {
        // ...
    }

    static func ==(lhs: Color, rhs: Color) -> Bool {
        // ...
    }
}

var observers: Set<Observable> = [] // Not allowed by the compiler

People and Color are both conform to Observable protocol which also inherit from Hashable protocol. I want to store these inside the observers set.

using 'Observable' as a concrete type conforming to protocol 
'Hashable' is not supported

Is it possible to do heterogenous Set in Swift?

"It works if I do this using Array", I got the following error: `error: protocol 'Observable' can only be used as a generic constraint because it has Self or associated type requirements var observers: Array = []` — Ahmad F, Aug 13 '17 at 06:29
@AhmadF you're right, sorry about that. I edited the question. But how to make Heterogenous Set anyway? — Edward Anthony, Aug 13 '17 at 06:32
@LeoDabus because I want to limit the elements only for object / struct that conforms to `Observable` protocol. — Edward Anthony, Aug 13 '17 at 06:34
Possible duplicate of [Set and protocols in Swift](https://stackoverflow.com/questions/33189345/set-and-protocols-in-swift). — Martin R, Aug 13 '17 at 06:50
As discussed in WWDC 2015 (Protocol-Oriented Programming in Swift), by using `Self`, the compiler is going to force us to make it Homogenous Array, and for this example, this is really restrictive. Is there really no way? — Edward Anthony, Aug 13 '17 at 06:51
The problem is (as in the linked Q&A) that you can compare two People or two Colors, but you cannot compare a People with a Color. — Martin R, Aug 13 '17 at 06:55

Edward Anthony · Accepted Answer · 2017-08-13T13:42:16.360

There is a way to make it possible. (Inspired by Apple's implementation)

Before we begin, this is what we want to build.

protocol Observer: Hashable {
    associatedtype Sender: Observable

    func valueDidChangeInSender(_ sender: Sender, keypath: String, newValue: Any)
}

The source of this problem is the use of Self that force the array to be Homogenous. You can see it here:

The most important change is that it stop the protocol from being usable as a type.

That makes us can't do:

var observers: [Observer] = [] // Observer is not usable as a type.

Therefore, we need another way to make it work.

We don't do

var observers: [AnyHashable] = []

Because AnyHashable will not constrain the object to conform Observer protocol. Instead, we can wrap the Observer object in the AnyObserver wrapper like this:

var observers: [AnyObserver] = []
observers.append(AnyObserver(yourObject))

This will make sure the value of AnyObserver struct conforms to Observer protocol.

According to WWDC 2015: Protocol-Oriented Programming in Swift, we can make a bridge with isEqual(_:) method so we can compare two Any. This way the object doesn't have to conform to Equatable Protocol.

protocol AnyObserverBox {
    var hashValue: Int { get }
    var base: Any { get }

    func unbox<T: Hashable>() -> T

    func isEqual(to other: AnyObserverBox) -> Bool
}

After that, we make the box that conforms to AnyObserverBox.

struct HashableBox<Base: Hashable>: AnyObserverBox {
    let _base: Base

    init(_ base: Base) {
        _base = base
    }

    var base: Any {
        return _base
    }

    var hashValue: Int {
        return _base.hashValue
    }

    func unbox<T: Hashable>() -> T {
        return (self as AnyObserverBox as! HashableBox<T>)._base
    }

    func isEqual(to other: AnyObserverBox) -> Bool {
        return _base == other.unbox()
    }
}

This box contains the actual value of the AnyObserver that we will create later.

Finally we make the AnyObserver.

struct AnyObserver {
    private var box: AnyObserverBox

    public var base: Any {
        return box.base
    }

    public init<T>(_ base: T) where T: Observer {
        box = HashableBox<T>(base)
    }
}

extension AnyObserver: Hashable {
    static func ==(lhs: AnyObserver, rhs: AnyObserver) -> Bool {
        // Hey! We can do a comparison without Equatable protocol.
        return lhs.box.isEqual(to: rhs.box)
    }

    var hashValue: Int {
        return box.hashValue
    }
}

With all of that in place, we can do:

var observers: [AnyObserver] = []
observers.append(AnyObserver(yourObject))

This is the same technique as shown in https://stackoverflow.com/q/43263352/2976878, a type eraser (might as well close as dupe in that case?). Although note that your current implementation will crash when attempting to use `==` on two `AnyObserver` instances with different base types as you're force casting to `HashableBox`. You should use conditional casting there (i.e `as?` and return a `T?`). — Hamish, Aug 13 '17 at 09:33
I used the same technique as Apple `AnyHashable` showed in Swift open source. I didn't mean to copy your answer as I didn't see your answer when creating this. You're right it will crash, thanks for the feedback. — Edward Anthony, Aug 13 '17 at 10:15
I wasn't saying you copied my answer (far from it; as you point out, your implementation is based on Swift's `AnyHashable` implementation using a protocol to do the type erasing, whereas mine uses closures) :) I was just saying that they're both valid ways to type erase the underlying concrete type of a `Hashable` instance that conforms to a given protocol (probably could've phrased my first comment better). — Hamish, Aug 13 '17 at 10:17

Ahmad F · Answer 2 · 2017-08-13T07:11:56.520

Actually, you cannot declare a Set -or even an array- of type Observable, that's because at some level Observable represents a generic protocol:

Observable -> Hashable -> Equatable:

which contains:

public static func ==(lhs: Self, rhs: Self) -> Bool

That's the reason why of the inability of using it in Heterogenous way. Furthermore, you can't declare an existential type:

var object: Observable?
// error: protocol 'Observable' can only be used as a generic constraint
// because it has Self or associated type requirements

If you are wondering what's the reason of this constraint, I assume that it is logical to compare tow People or tow Color, but not comparing People with Color.

So, what can we do?

As a workaround, you could let your set to be a set of AnyHashable structure (as @Leo mentioned in the comment):

The AnyHashable type forwards equality comparisons and hashing operations to an underlying hashable value, hiding its specific underlying type.

As follows:

let people = People(name: "name", age: 101)
let color = Color(red: 101, green: 101, blue: 101)

var observers: Set<AnyHashable> = []

observers.insert(people)
observers.insert(color)

for (index, element) in observers.enumerated() {
    if element is People {
        print("\(index): people")
    }
}

that would be legal.

That breaks the constraint that the Set should only contain Object that conform to `Observable` protocol. The closest thing would be make a new struct named `AnyObservable` that conforms to `Observable` protocol. — Edward Anthony, Aug 13 '17 at 07:09

Is it possible to make a Heterogeneous Set in Swift?

2 Answers2