为什么 Swift 不允许在接受协议的参数中使用符合协议的类型？

Question

鉴于此示例代码：

private protocol P {}
final private class X {
    private func j(j: (P) -> Void) -> Void {}
    private func jj<Z: P>(jj: (Z) -> Void) -> Void {
        j(j: jj)
    }
}

XCode 9.1 中的 Swift 4 在 j(j: jj) 行给出了这个编译器错误：

无法将“(Z) -> Void”类型的值转换为预期的参数类型 ‘(P) -> 虚空’。

为什么？

注意，在我看来它不应该给出这个错误，因为类型约束<Z: P> 要求 Z 绝对必须符合协议 P。所以，绝对没有理由convert 从 Z 到 P，因为 Z 已经符合 P。

对我来说似乎是一个编译器错误......

Answer 1

编译器是正确的——(Z) -> Void 不是(P) -> Void。为了说明为什么会这样，让我们​​定义以下一致性：

extension String : P {}
extension Int : P {}

现在让我们用Int 代替Z：

final private class X {

  func j(j: (P) -> Void) {
    j("foob")
  }

  func jj(jj: (Int) -> Void) {
    // error: Cannot convert value of type '(Int) -> Void' to expected argument
    // type '(P) -> Void'
    j(j: jj)
  }
}

我们不能将(Int) -> Void 传递给(P) -> Void。为什么？那么(P) -> Void 接受任何符合P 的东西——例如，我们可以传入String。但是我们传递给j 的函数实际上是一个(Int) -> Void，所以我们试图将一个String 传递给一个Int 参数，这显然是不合理的。

如果我们把泛型放回去，应该仍然很清楚为什么这不起作用：

final private class X {

  func j(j: (P) -> Void) {
    j("foob")
  }

  func jj<Z : P>(jj: (Z) -> Void) {
    // error: Cannot convert value of type '(Z) -> Void' to expected argument
    // type '(P) -> Void'
    j(j: jj)
  }
}

X().jj { (i: Int) in
  print(i) // What are we printing here? A String gets passed in the above implementation..
}

(P) -> Void 是一个函数可以处理 any P 符合参数。然而(Z) -> Void 是一个函数，它只能处理一个特定 符合P 的具体类型参数（例如我们上面的例子中的Int）。将其键入为可以处理 any P 符合参数的函数将是一个谎言。

用更专业的方式说，(Z) -> Void 不是(P) -> Void 的子类型。函数的参数类型为contravariant，这意味着(U) -> Void 是
(V) -> Void 的子类型当且仅当V 是U 的子类型。但是P 不是Z : P 的子类型——Z 是一个占位符，它在运行时被替换为符合P（也是其子类型）的具体类型。

当我们考虑相反的情况时，更有趣的部分出现了；也就是说，将(P) -> Void 传递给(Z) -> Void。虽然占位符Z : P 只能由P 的具体子类型来满足，但我们不能用P 替换Z，因为protocols don't conform to themselves。