Manually select overloaded functions

[wowbagger (冀卓疌)]

@xwu

Firstly, you can work around it with simple forwarding functions:

func foo<T: Hashable>(bar: T) { print("Hashable") }
func foo<T: Comparable>(bar: T) { print("Comparable") }

func foo1<T: Hashable>(bar: T) { foo(bar: bar) }
func foo2<T: Comparable>(bar: T) { foo(bar: bar) }

foo1(bar: 3.14) // "Hashable"
foo2(bar: 3.14) // "Comparable"

I feel this is kind of like cheating. It also makes function overloading somewhat unnecessary. If the overloaded functions are forwarded like this, why not just not overload them in the first place?

@xwu

This reveals the second way in which you can select the overload in the current version of Swift:

func someHashable<T: Hashable>(_ x: T) -> some Hashable { x }
func someComparable<T: Comparable>(_ x: T) -> some Comparable { x }

foo(bar: someHashable(3.14))   // "Hashable"
foo(bar: someComparable(3.14)) // "Comparable"

This is just typecasting with extra steps, and using opaque types to work around generics seems like an overkill.

I apologize if I come across as criticizing these 2 approaches. It's not my intention. They are solid workarounds to the problem I posted. And I didn't know the 2nd way existed. Thank you for showing me it. However, they are really awkward, not swifty.

@xwu

In the fullness of time, the way to write this will be:

foo(bar: 3.14 as some Hashable)
foo(bar: 3.14 as some Comparable)

Why does 3.14 have to be cast as an opaque type? And why is a typecasting necessary? If the user is allowed to tell the compiler exactly which function to call, wouldn't it just eliminate the need for typecasting in this kind of situation, and be more efficient at both compile and run time?