Overload wrapped function with generic in Swift - ios

Question

First example
func foo<T>(_ t: T) -> String {
return bar(t)
}
func bar<T>(_ t: T) -> String {
return "Other"
}
func bar<T: StringProtocol>(_ t: T) -> String {
return "String"
}
foo("") // "Other" // Why not "String"?
bar("") // "String"
bar(1) // "Other"
Second example (more complex)
First example can be resolved by type checking, but in this example it is impossible.
func foo<T>(_ t: (T) -> String) -> String {
return bar(t)
}
func bar<T>(_ t: (T) -> String) -> String {
return "Other"
}
func bar<T: StringProtocol>(_ t: (T) -> String) -> String {
return "String"
}
foo { (string: String) -> String in return "" } // Other // Why not "String"?
bar { (string: String) -> String in return "" } // String
bar { (int: Int) -> String in return "" } // Other
Overloads are resolved statically. Since T inside foo() is unconstrained, it picks the overload of bar() with an unconstrained T. Is there any workaround?

Answer 1

As per current Swift implementation, the function which is more specialized, meaning it has constraints who are a superset of the constraints of the other overloaded function; overloading will pick the more specialized function.
So, I can't think of better alternative than making foo conform to StringProtocol.
Regarding why there is not a better hack around, I would like to quote from Swift documentation which talks about how nested or more specialized generic type should be resolved.:
This amounts to run-time overload resolution, which may be desirable,
but also has downsides, such as the potential for run-time failures
due to ambiguities and the cost of performing such an expensive
operation at these call sites. Of course, that cost could be mitigated
in hot generic functions via the specialization mentioned above.
Our current proposal for this is to decide statically which function
is called (based on similar partial-ordering rules as used in C++),
and avoid run-time overload resolution. If this proves onerous, we can
revisit the decision later.

Answer 2

Talking of work around.
You can do it as follows.
func foo<T>(_ t: T) -> String {
if let str = t as? String {
return bar(str)
}
return bar(t)
}
func bar<T>(_ t: T) -> String {
return "Other"
}
func bar<T: StringProtocol>(_ t: T) -> String {
return "String"
}
Again speaking of work around.
func foo<T>(_ t: #escaping (T) -> String) -> String {
if let clsr = t as? (String) -> String {
return bar(clsr)
}
return bar(t)
}
func bar<T>(_ t: (T) -> String) -> String {
return "Other"
}
func bar<T: StringProtocol>(_ t: (T) -> String) -> String {
return "String"
}