Swift @autoclosure 使用

今天看了 Apple 博客的一篇文章 Building assert() in Swift, Part 1: Lazy Evaluation - Swift Blog - Apple Developer 很是受益，记录下来。

先了解一个知识点：NDEBUG 宏是 Standard C 中定义的宏，专门用来控制 assert() 的行为。如果定义了这个宏，则 assert 不会起作用。

#ifdef NDEBUG
#define assert(e)  ((void)0)
#else
#define assert(e)  \
    ((void) ((e) ? ((void)0) : __assert (#e, __FILE__, __LINE__)))
#define __assert(e, file, line) \
    ((void)printf ("%s:%u: failed assertion `%s'\n", file, line, e), abort())
#endif

Apple 在 Swift 中实现 assert() 断言函数时，遇到最大的挑战是没有一个明确的方式去做到：一个函数接收一个没有运行的表达式（When implementing assert() in Swift, the first challenge we encounter is that there is no obvious way for a function to accept an expression without evaluating it.）

func assert(x : Bool) {
    #if !NDEBUG
    /* noop */
    #endif
}

也就是说使用 assert() 这个方法的时候，someExpensiveComputation() 这个耗时的计算方法也执行完毕了才和 42 作比较：

assert(someExpensiveComputation() != 42)

需求：事实上，我们希望，当调用 assert() 函数时，assert() 函数进入 #if 分支这个 someExpensiveComputation() 才执行，然后和 42 作判断得到 Bool，如果没有进入 #if 分支，即使我们调用了 assert() 函数，someExpensiveComputation() 函数也不要执行，从而提高性能。

这个时候，可以把 assert() 函数的参数改成闭包：

func assert(_ predicate: () -> Bool) {
    #if !NDEBUG
    if !predicate() {
        abort()
    }
    #endif
}

此时调用，上面的需求也就解决了，当执行 assert() 函数的时候，如果没进 #if 分支，someExpensiveComputation() 就不会执行：

// 完整写法
assert { () -> Bool in
    return someExpensiveComputation() != 42
}

// 隐藏闭包参数和 in 的写法
assert({ someExpensiveComputation() != 42 })

// 尾随闭包写法
assert { someExpensiveComputation() != 42 } // 1️⃣

然后这个时候，Apple 说这种调用语法不够棒（unfortunate calling syntax），虽然我觉得还 OK 。我们可以通过使用 Swift 的 @autoclosure 属性来解决这个 unfortunate calling syntax：

func assert(_ predicate: @autoclosure () -> Bool) {
    #if !NDEBUG
    if !predicate() {
        abort()
    }
    #endif
}

// 调用：
assert(someExpensiveComputation() != 42) // 2️⃣

@autoclosure 做的事情就是把⼀句表达式⾃动地封装成⼀个闭包 (closure)，Swift 会把 someExpensiveComputation() != 42 这个表达式自动转换为 () -> Bool，这样我们调用函数的时候写法就很 Nice 了。

比较一下：

assert { someExpensiveComputation() != 42 } // 尾随闭包
assert(someExpensiveComputation() != 42) // @autoclosure 自动封装闭包

可能很多人还是觉得尾随闭包那种写法也很 Nice 啊（我也是这样认为），但是 @autoclosure 用在 逻辑与 等符号就很 Nice 了：

func &&(lhs: BooleanType, rhs: @autoclosure () -> BooleanType) -> Bool {
    return lhs.boolValue ? rhs().boolValue : false
}

// 用法
if isCool && haveMoney() {
    print("Wow 高富帅！")
}

另外，我在《Swifter》这本书看到 ?? 这个用法：

var level: Int?
var startLevel = 1
var currentLevel = level ?? startLevel

大家觉得好像也没有什么神奇的，不就是当 level 非 nil 的时候返回 level 解包后的值，当 level 是 nil 的时候返回 startLevel 的值嘛。

作者猜测 ?? 的实现如下：

func ??(optional: T?, defaultValue: @autoclosure () -> T) -> T {
    switch optional {
    case .Some(let value):
        return value
    case .None:
        return defaultValue()
    }
}

为什么 defaultValue 不直接使用 T 而是使用闭包呢？这时因为如果我们直接使用 T 的话，那么意味着在 ?? 操作符真正取值之前，必须准备好这个默认值 ，如果这个默认值是需要通过一系列复杂的计算得到的话，那就有点浪费了：

• 因为如果 optional != nil 的话，实际上 defaultValue 这个默认值是用不上的，而是直接返回 optional 解包好的值的；为了避免这种无谓的开销，可以讲默认值的计算推迟到 optional = nil 之后。
• 喔，原来设计语言要考虑得那么多的呀