A protocol allowing comparison between untyped values

AnyEquatable.swift

// swift 4.1

protocol AnyEquatable {
    func isEqual(to value: Any) -> Bool
}

extension AnyEquatable where Self: Equatable {
    func isEqual(to value: Any) -> Bool {
        guard let value = value as? Self else {
            return false
        }
        
        return value == self
    }
}

extension Int: AnyEquatable {}
extension Bool: AnyEquatable {}
extension Double: AnyEquatable {}
extension String: AnyEquatable {}

extension AnyHashable: AnyEquatable {
    func isEqual(to value: Any) -> Bool {
        guard let base = base as? AnyEquatable else {
            return false
        }
        
        return base.isEqual(to: value)
    }
}

extension Array: AnyEquatable where Element: Any {
    func isEqual(to value: Any) -> Bool {
        guard let value = value as? [Element], value.startIndex == startIndex, value.endIndex == endIndex else {
            return false
        }
        
        var i = startIndex
        
        while i != endIndex {
            guard let lhv = self[i] as? AnyEquatable, lhv.isEqual(to: value[i]) else {
                return false
            }
            
            i = index(after: i)
        }
        
        return true
    }
}

extension Dictionary: AnyEquatable where Value: Any {
    func isEqual(to value: Any) -> Bool {
        guard let value = value as? [Key: Value], value.keys == keys else {
            return false
        }
        
        for key in keys {
            switch (self[key], value[key]) {
            case (.none, .none):
                continue
                
            case let (.some(lhv as AnyEquatable), .some(rhv)):
                guard lhv.isEqual(to: rhv) else {
                    return false
                }
                
            default:
                return false
            }
        }
        
        return true
    }
}

let v1: [Int: Any] = [0: AnyHashable(2)]
let v2: [Int: Any] = [0: 2]

print(v1.isEqual(to: v2))