Swift 错误：无法将类型“B -> (A) -> ()”的值转换为预期的参数类型“(A) -> Void”

Question

我有一个 Swift 程序会产生我无法理解的编译器错误。它归结为以下代码片段。

A 类是一个辅助类，在初始化时提供了一个稍后将调用的处理函数。这个函数有一个A 对象作为参数。

B 类初始化一个 A 类型的对象，并有一个函数 f 应该用作处理程序。或者，可以提供一个匿名代码块（闭包）。

class A {
    init(_: (A) -> Void) {}
}

class B {
    let a = A(f)
    func f(a: A) {}
}

这会产生以下编译器消息：

error: cannot convert value of type 'B -> (A) -> ()' to expected argument type '(A) -> Void'
let a = A(f)
          ^

Void 和 () 是等价的，我想。

我什至不理解带有双 -> 的类型表达式。这是什么类型的？

谁能解释这里出了什么问题？还有，怎么做才对？

Answer 1

您不能在初始化实例属性（如a）时引用实例方法（如f），因为该实例正是我们正在创建的对象。一种解决方案是声明您的实例属性lazy，如下所示：

class A {
    init(_: (A) -> Void) {}
}

class B {
    func f(a: A) {}
    lazy var a : A = A(self.f)
}

这是合法的，因为lazy 保证a 的初始化程序在稍后 创建实例 之前不会被评估。请注意，self 在这种情况下是绝对需要的（通常我建议您始终在可以使用的地方使用它）。

另一种解决方案是将a 声明为A!（使其具有初始值，即nil）并稍后“真正地”初始化它。例如：

class A {
    init(_: (A) -> Void) {}
}

class B {
    func f(a: A) {}
    var a : A!
    init() {
        self.a = A(self.f)
    }
}

Answer 2

@matt 为我指明了正确的方向——非常感谢。他的解决方案是这里的a1 变体：

class B {
    func f(a: A) {}
    lazy var a1 : A = A(self.f)       // ok
    lazy var a2 : A = A(f)            // error
    lazy var a3     = A(self.f)       // error
    lazy var a4     = A(f)            // error
}

有趣的是，所有其他变体a2、a3、a4 都不工作。 a2 和 a4 产生原始 “无法转换值” 错误，a3 说 “使用未解析的标识符 'self'”。

lazy 解决方案的缺点是 a 现在是 var 而不是常量。我通过在初始化期间分配常量值找到了另一种方法：

class B {
    let a: A
    init() {
        a = A() { (A) -> Void in … }  // ok
    }
}

有趣的是，这个 only 适用于闭包。代码

class B {
    let a: A
    init() {
        a = A(f)                      // error
    }
    func f(a: A) { … }
}

给编译器错误“在所有存储的属性被初始化之前在方法调用'f'中使用'self'”。

尽管如此，即使在闭包变体中，self 也无法使用，因为它尚未完全初始化。