Swift@自动闭包参数包装提供了显式闭包

Question

考虑以下功能：

func whatever(foo: @autoclosure () -> Int) {
  let x = foo()
  print(x)
}

当然，我们可以像这样调用它：

whatever(foo: 5)
// prints: 5

但是，提供显式闭包参数会导致编译器抱怨：

whatever(foo: { 5 })
// Error: Function produces expected type 'Int'; did you mean to call it with '()'?

这是您的意图吗？阅读@自动闭包的留档时，我没有找到关于参数是否始终被包装的语句，即使在提供闭包时也是如此。我对@自动闭包的理解是：
接受闭包参数。如果参数不是闭包，但与闭包返回的类型相同，则包装它。
然而，我看到的行为是：无论如何都要包装参数。

一个更详细的例子使这在我看来很奇怪：

struct Defaults {

  static var dispatcher: Defaults = ...

  subscript<T>(setting: Setting<T>) -> T { ... }

  struct Setting<T> {
    let key: String
    let defaultValue: () -> T

    init(key: String, defaultValue: @escaping @autoclosure () -> T) {
      self.key = key
      self.defaultValue = defaultValue
    }
  }
}

extension Defaults.Setting {
  static var nickname: Defaults.Setting<String> {
    return Defaults.Setting(key: "__nickname", defaultValue: "Angela Merkel")
  }
}

//  Usage:
Defaults.dispatcher[.nickname] = "Emmanuel Macron"

现在假设我想散列设置值的键：

extension Defaults.Setting {
  var withHashedKey: Defaults.Setting<T> {
    return Defaults.Setting(key: key.md5(), defaultValue: defaultValue)
    // Error: Cannot convert return expression of type 'Defaults.Setting<() -> T>' to return type 'Defaults.Setting<T>'
  }
}

为了澄清：defaultValue的类型是（）-

extension Defaults.Setting {
  init(key: String, defaultValue: @escaping () -> T) {
    self.init(key: key, defaultValue: defaultValue)
  }
}

真正令人望而生畏的是，我可以简单地使用< code>@autoclosure参数转发到< code>init,它就工作了。< br>
是我遗漏了什么，还是Swift的设计无法为< code>@autoclosure参数提供闭包变量？

Answer 1

Swift 期望您将一个生成 Int 的表达式传递给 whatever（foo：），Swift 会将该表达式包装在类型 （） 的闭包中 -

func whatever(foo: @autoclosure () -> Int) {
    let x = foo()
    print(x)
}

当你这样称呼它：

func whatever(foo: {5})

您传递的表达式将导致（）-

func whatever(foo: {5}())

请注意，由于 Swift 将 {5}（） 包装在闭包中，因此在调用 whatever（foo：） 之前不会对其进行评估，但实际上调用会延迟，直到您评估 let x = foo（）。

你可以通过在操场上运行来验证这一点:

func whatever(foo: @autoclosure () -> Int) {
    print("inside whatever")
    let x = foo()
    print(x)
    let y = foo()
    print(y)
}

whatever(foo: { print("hi"); return 3 }())

输出:

inside whatever
hi
3
hi
3

如果你想要任何东西（foo：也可以取一个（）-

func whatever(foo: @autoclosure () -> Int) {
    print("autoclosure whatever")
    let x = foo()
    print(x)
}

func whatever(foo: () -> Int) {
    print("closure whatever")
    whatever(foo: foo())

}

whatever(foo: { print("two"); return 6 })
whatever(foo: { print("two"); return 6 }())

输出:

closure whatever
autoclosure whatever
two
6
autoclosure whatever
two
6