Solving http://inessential.com/2015/06/21/swift_protocols_question

gistfile1.swift

// One note before we start: if the inhabitants of Value are a closed set,
// then making Value an enum is going to be a clearer model than using a
// protocol like this. I'm assuming you need to be able to retroactively add
// new members of Value.

// Can't use Equatable directly because of its Self requirement.
protocol HeteroEquatable {
    func isEqualTo(_ value: HeteroEquatable) -> Bool
}

func ==(lhs: HeteroEquatable, rhs: HeteroEquatable) -> Bool {
    return lhs.isEqualTo(rhs)
}

protocol Smashable {
    func smash(with value: HeteroEquatable) -> HeteroEquatable
}

extension Int: HeteroEquatable { }

extension HeteroEquatable where Self: Equatable {
    func isEqualTo(_ value: HeteroEquatable) -> Bool {
        guard let value = value as? Self else {
            return false
        }
        
        return self == value
    }
}

struct Test: Smashable {
    func smash(with value: HeteroEquatable) -> HeteroEquatable {
        return 3 // This is free to return a different adopter of Value
    }
}

let result = Test().smash(with: 3)
print(result == 3) // can still ==

Why is the indirection of the Value protocol necessary?