今天看了 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 ??<T>(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之后。 - 喔，原来设计语言要考虑得那么多的呀 👏
