swift - 将函数包装在闭包中以将其作为参数传递是否有任何开销

Question

在 swift 中，您可以将函数作为参数传递给接受闭包的函数。这对于避免在使用运算符时在语法上污染您的代码特别有用。例如，你可以写一个总和如下:

let values = 0 ..< 10
let sum = values.reduce(0, +)

不幸的是，当 Swift 的推理无法根据其他参数确定预期闭包的类型时，重载函数可能会导致模棱两可的情况。例如，考虑下面的代码。最后一行无法编译，因为 Swift 无法确定我指的是 + 的哪个“版本”。

func castAndCombine<T, U>(_ pair: (Any, Any), with fn: (T, T) -> U) -> U? {
  guard let first = pair.0 as? T, let second = pair.1 as? T
    else { return nil }
  return fn(first, second)
}

// The following line cannot compile.
let x = castAndCombine((1, 2), with: +)

不幸的是，没有(或者至少我不知道)任何方法来指定我指的是哪个 +。尽管如此，我想出了两个解决这个问题的办法:

1. 向函数添加一个参数以消除歧义:

func castAndCombine<T, U>(_ pair: (Any, Any), toType: T.Type, with fn: (T, T) -> U) -> U? {
  // ...
}
let x = castAndCombine((1, 2), toType: Int.self, with: +)

1. 保持函数的签名不变并使用带有显式类型注释的闭包:

func castAndCombine<T, U>(_ pair: (Any, Any), with fn: (T, T) -> U) -> U? {
  // ...
}

let x = castAndCombine((1, 2), with: { (a: Int, b: Int) in a + b })

我个人不喜欢第一种解决方案，因为我觉得它不美观且使用起来不自然。但是，我想知道第二个是否会增加任何性能开销，因为创建了一个基本上包装单个函数的闭包，而没有添加任何行为。

有谁知道这种性能开销是否确实存在和/或在任何程度上都很重要？

Answer 1

如果您使用优化进行编译，则不应有任何开销，因为编译器很可能会内联您的闭包。

您可以通过比较 Swift 编写的 LLVM 代码，用您的第一个解决方案(因为它支持两种样式)来验证这个假设。 LLVM 是编译器在创建实际机器代码之前使用的中间表示。

直接使用操作符写一个文件，即:

let x = castAndCombine((1, 2), toType: Int.self, with: +)

使用闭包写第二个文件，即:

let x = castAndCombine((1, 2), toType: Int.self, with: { (a: Int, b: Int) in a + b })

现在通过优化编译两者，要求 Swift 的编译器生成 LLVM IR。假设您的文件名为 main1.swift 和 main2.swift，您可以运行以下命令:

swift -O -emit-ir main1.swift 1>main1.ll
swift -O -emit-ir main2.swift 1>main2.ll

两个生成的文件应该是相同的。

diff main1.ll main2.ll
# No output

---

请注意，评论中建议的解决方案也不会增加任何性能开销，因为静态保证的转换不会消耗任何操作。