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

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

---

请注意，cmets 中建议的解决方案也不会增加任何性能开销，因为静态保证强制转换不会花费任何操作。

Answer 2

您可以将+ 转换为所需的类型，而不是创建closure 来消除类型的歧义：

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)
}

// Add two Ints by concatenating them as Strings    
func +(_ lhs: Int, _ rhs: Int) -> String {
    return "\(lhs)\(rhs)"
}

if let x = castAndCombine((1, 2), with: (+) as (Int, Int) -> String) {
    print(x)
}

12

if let x = castAndCombine((1, 2), with: (+) as (Int, Int) -> Int) {
    print(x)
}

3