"Ambiguous use of" and constrained generic functions - swift

Question

I have a set of functions that extract values from a dictionary, where the dictionary's value type is Any (it comes from JSON data, and I don't have control over the value types):
func get<T>(_ dict: [String: Any], key: String) throws -> T {
// cast the value for the key to a T, and return
}
func get<T: RawRepresentable>(_ dict: [String: Any], key: String) throws -> T {
// cast the value for the key to a T.RawValue, init a T, and return
}
This works fine. The first function can cast a value of a scalar type and return it, while the second can convert a raw value for an enum type into the higher-level Swift type.
If I add a third variant, the compiler becomes unhappy and I get a lot of "ambiguous use of" errors, flagging all three functions as candidates:
func get<T: RawRepresentable>(_ dict: [String: Any], key: String) throws -> T where T.RawValue == Double {
// try to extract the value as an Double, init a T, and return
// if that fails, extract as an Int, cast to a Double, init a T, and return
}
The idea with this function is that a double value might appear without its decimal, and actually be an Int in the dictionary, but it needs to be a Double in strongly-typed Swift-land.
Why is the compiler able to resolve the ambiguity without the third variant, but considers all three as equally valid candidates when it exists?
Edit: here is a playground that illustrates the problem.
enum E: Error {
case error
}
func get<T>(_ dict: [String: Any], key: String) throws -> T {
guard let value = dict[key] as? T else { throw E.error }
return value
}
func get<T: RawRepresentable>(_ dict: [String: Any], key: String) throws -> T {
guard let rawValue = dict[key] as? T.RawValue else { throw E.error }
return T(rawValue: rawValue)!
}
func get<T: RawRepresentable>(_ dict: [String: Any], key: String) throws -> T where T.RawValue == Double {
if let doubleValue = dict[key] as? Double {
return T(rawValue: doubleValue)!
} else if let intValue = dict[key] as? Int {
return T(rawValue: Double(intValue))!
}
throw E.error
}
struct Wrapped: RawRepresentable {
typealias RawValue = Double
var rawValue: Double
init?(rawValue: Double) {
self.rawValue = rawValue
}
}
let dict: [String: Any] = ["int": 1, "double": 1.1]
let int: Int = try! get(dict, key: "int")
let double: Double = try! get(dict, key: "double")
let wrapped: Wrapped = try! get(dict, key: "int")
This produces a compile error (ambiguous use of get(_:key:)). Commenting out the third specialization of get<T> resolves the compiler error, but results in a runtime error because the integer value of the key int can't be cast using as? into a Double. Changing the key to double resolves that, but doesn't address the problem I was trying to solve.
I should note that this is now an academic question for me, since I've changed my parsing approach to use Codable and it handles parsing both floating point and integer values into Float/Double types in Swift.