Swift：泛型重载，定义"more specialized"

Question

在下面的例子中，为什么 foo(f) 调用不明确？我知道第二个重载也适用于 P == ()，但为什么第一个不被认为更专业，因此更好的匹配？

func foo<R>(_ f: () -> R) { print("r") }
func foo<P, R>(_ f: (P) -> R) { print("pr") }

let f: () -> Int = { 42 }
foo(f)   //  "Ambiguous use of 'foo'"

Answer 1

我会说你的问题是你没有告诉编译器 P == ()

在 playground 中尝试以下代码：

Void.self == (Void).self // true
Void() == () // true
(Void)() == () // true
(Void) == () // Cannot convert value of type '(Void).Type' to expected argument type '()'

Foo<Int>.self == (() -> Int).self // false
(() -> Int).self == ((Void) -> Int).self // false
Foo<Int>.self == ((Void) -> Int).self // true

由于(Void)无法转换为()，我估计编译器无法理解foo<R>(_ f: () -> R)实际上是foo<P, R>(_ f: (P) -> R)的特化。

我建议您为您的函数类型创建 generic type aliases 以帮助编译器理解您在做什么，例如。 :

typealias Bar<P, R> = (P) -> R
typealias Foo<R> = Bar<Void, R>

现在您可以像这样定义您的函数了：

func foo<R>(_ f: Foo<R>) { print("r") } // Note that this does not trigger a warning.
func foo<P, R>(_ f: Bar<P, R>) { print("pr") }

然后将它们与您想要的任何闭包一起使用：

let f: () -> Int = { 42 }
foo(f)   // prints "r"
let b: (Int) -> Int = { [=13=] }
foo(b) // prints "pr"
let s: (String) -> Double = { _ in 0.0 }
foo(s) // prints "pr"

但实际上你可以只写：

func foo<R>(_ f: (()) -> R) { print("r") }
func foo<P, R>(_ f: (P) -> R) { print("pr") }

甚至：

func foo<R>(_ f: (Void) -> R) { print("r") } // triggers warning :
// When calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
func foo<P, R>(_ f: (P) -> R) { print("pr") }

你会得到相同的结果。

Swift：泛型重载，定义"more specialized"

Swift: generic overloads, definition of "more specialized"

swift

generics

overload-resolution