Swift 中的 @autoclosure

萌面大道發表於2019-03-04

由於種種原因，掘金等第三方平臺部落格不再保證能夠同步更新，歡迎移步 GitHub：github.com/kingcos/Per…。謝謝！

Date	Notes	Swift	Xcode	Source Code
2018-04-05	更新並明確原始碼所用版本	4.1	9.3	Swift 4.1 Release
2018-01-13	首次提交	4.0.3	9.2	-

您可以在 github.com/kingcos/Per… 中看到更多更新的博文，謝謝您的關注。

What

Closures are self-contained blocks of functionality that can be passed around and used in your code. Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.

— The Swift Programming Language (Swift 4.1)

閉包（Closure）在 Swift 等許多語言中普遍存在。熟悉 Objective-C 的同學一定對 Block 不陌生。兩者其實是比較類似的，相較於 Block，閉包的寫法簡化了許多，也十分靈活。

在 Swift 中，@ 開頭通常代表著屬性（Attribute）。@autoclosure 屬於型別屬性（Type Attribute），意味著其可以對型別（Type）作出一些限定。

How

自動（Auto-）

@autoclosure 名稱中即明確了這是一種「自動」閉包，即可以讓返回該引數型別的閉包作為引數；
其只可以修飾作為引數的閉包型別，但該閉包不能有引數，否則會報錯：「error: argument type of @autoclosure parameter must be '()'」。

func logIfTrue(_ predicate: () -> Bool) {
    if predicate() {
        print(#function)
    }
}

// logIfTrue(predicate: () -> Bool)
logIfTrue { 1 < 2 }

func logIfTrueWithAutoclosure(_ predicate: @autoclosure () -> Bool) {
    if predicate() {
        print(#function)
    }
}

// logIfTrueWithAutoclosure(predicate: Bool)
logIfTrueWithAutoclosure(1 < 2)

// OUTPUT:
// logIfTrue
// logIfTrueWithAutoclosure
複製程式碼

延遲呼叫（Delay Evaluation）

Swift 中的閉包會被延遲呼叫，即只有在真正被呼叫時，才被執行；
延遲呼叫特性有利於非必須執行且運算開銷較大的程式碼；
該特性非 @autoclosure 獨有，但通常搭配使用。

var array = [1, 2, 3, 4, 5]

array.removeLast()
print(array.count)

var closureVar = { array.removeLast() }
print(array.count)

closureVar()
print(array.count)

// OUTPUT:
// 4
// 4
// 3
複製程式碼

@escaping

當閉包的真正執行時機可能要在其所在函式返回（Return）之後時，通常使用 @escaping，可以用於處理一些耗時操作的回撥；
@autoclosure 與 @escaping 是可以相容的，放置順序可以顛倒。

func doWith(_ completion: () -> Void) {
    completion()
}

func doWithAutoclosureAndEscaping(_ escaper: @autoclosure @escaping () -> Void) {
    doWith {
        escaper()
    }
}

func doWithEscapingAndAutoclosure(_ escaper: @escaping @autoclosure () -> Void) {
    doWith {
        escaper()
    }
}
複製程式碼

Source Code

Test Cases

$SWIFT_SOURCE_CODE_PATH/test/attr/attr_autoclosure.swift

inout 與 @autoclosure 不相容，且沒有實際意義；
@autoclosure 不適用於函式的可變引數（Variadic Parameters）。

Use Cases

$SWIFT_SOURCE_CODE_PATH/stdlib/public/core/

短路（Short Circuit）運算子

// Bool.swift
extension Bool {
  @_inlineable // FIXME(sil-serialize-all)
  @_transparent
  @inline(__always)
  public static func && (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows
      -> Bool {
    return lhs ? try rhs() : false
  }

  @_inlineable // FIXME(sil-serialize-all)
  @_transparent
  @inline(__always)
  public static func || (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows
      -> Bool {
    return lhs ? true : try rhs()
  }
}

// Optional.swift
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T)
    rethrows -> T {
  switch optional {
  case .some(let value):
    return value
  case .none:
    return try defaultValue()
  }
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?)
    rethrows -> T? {
  switch optional {
  case .some(let value):
    return value
  case .none:
    return try defaultValue()
  }
}
複製程式碼

Swift 中的 &&、|| 以及 ?? 屬於短路運算子，即當表示式左邊的結果已經可以決定整個運算子的返回值時（運算子的本質也是函式），右邊便沒有必要運算。利用了 @autoclosure 使得運算子右邊可以為閉包，再憑藉 Delay Evaluation 特性保證了「短路」。

var flag = 0
var age: Int? = nil

func getAgeA() -> Int? {
    flag += 10
    return 20
}

func getAgeB() -> Int? {
    flag += 100
    return nil
}

age ?? getAgeA() ?? getAgeB()
print(flag)

// OUTPUT:
// 10
複製程式碼

斷言（Assert）

斷言相關的方法將某些引數設定為閉包型別，並標註了 @autoclosure，一是可以直接將閉包直接作為引數；二是當 Release 模式時，Closure 沒有必要執行，即可節省開銷（XCTest 和 Dispatch 中的部分方法同理）。

// AssertCommon.swift
@_inlineable // FIXME(sil-serialize-all)
public // COMPILER_INTRINSIC
func _undefined<T>(
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file, line: UInt = #line
) -> T {
  _assertionFailure("Fatal error", message(), file: file, line: line, flags: 0)
}

// Assert.swift
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func assert(
  _ condition: @autoclosure () -> Bool,
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file, line: UInt = #line
) {
  // Only assert in debug mode.
  // 在 Debug 模式且條件不成立，斷言失敗
  if _isDebugAssertConfiguration() {
    if !_branchHint(condition(), expected: true) {
      _assertionFailure("Assertion failed", message(), file: file, line: line,
        flags: _fatalErrorFlags())
    }
  }
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func precondition(
  _ condition: @autoclosure () -> Bool,
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file, line: UInt = #line
) {
  // Only check in debug and release mode.  In release mode just trap.
  if _isDebugAssertConfiguration() {
    if !_branchHint(condition(), expected: true) {
      _assertionFailure("Precondition failed", message(), file: file, line: line,
        flags: _fatalErrorFlags())
    }
  } else if _isReleaseAssertConfiguration() {
    let error = !condition()
    Builtin.condfail(error._value)
  }
}

@_inlineable // FIXME(sil-serialize-all)
@inline(__always)
public func assertionFailure(
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file, line: UInt = #line
) {
  if _isDebugAssertConfiguration() {
    _assertionFailure("Fatal error", message(), file: file, line: line,
      flags: _fatalErrorFlags())
  }
  else if _isFastAssertConfiguration() {
    _conditionallyUnreachable()
  }
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func preconditionFailure(
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file, line: UInt = #line
) -> Never {
  // Only check in debug and release mode.  In release mode just trap.
  if _isDebugAssertConfiguration() {
    _assertionFailure("Fatal error", message(), file: file, line: line,
      flags: _fatalErrorFlags())
  } else if _isReleaseAssertConfiguration() {
    Builtin.int_trap()
  }
  _conditionallyUnreachable()
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func fatalError(
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file, line: UInt = #line
) -> Never {
  _assertionFailure("Fatal error", message(), file: file, line: line,
    flags: _fatalErrorFlags())
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func _precondition(
  _ condition: @autoclosure () -> Bool, _ message: StaticString = StaticString(),
  file: StaticString = #file, line: UInt = #line
) {
  // Only check in debug and release mode. In release mode just trap.
  if _isDebugAssertConfiguration() {
    if !_branchHint(condition(), expected: true) {
      _fatalErrorMessage("Fatal error", message, file: file, line: line,
        flags: _fatalErrorFlags())
    }
  } else if _isReleaseAssertConfiguration() {
    let error = !condition()
    Builtin.condfail(error._value)
  }
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func _debugPrecondition(
  _ condition: @autoclosure () -> Bool, _ message: StaticString = StaticString(),
  file: StaticString = #file, line: UInt = #line
) {
  // Only check in debug mode.
  if _isDebugAssertConfiguration() {
    if !_branchHint(condition(), expected: true) {
      _fatalErrorMessage("Fatal error", message, file: file, line: line,
        flags: _fatalErrorFlags())
    }
  }
}

@_inlineable // FIXME(sil-serialize-all)
@_transparent
public func _sanityCheck(
  _ condition: @autoclosure () -> Bool, _ message: StaticString = StaticString(),
  file: StaticString = #file, line: UInt = #line
) {
#if INTERNAL_CHECKS_ENABLED
  if !_branchHint(condition(), expected: true) {
    _fatalErrorMessage("Fatal error", message, file: file, line: line,
      flags: _fatalErrorFlags())
  }
#endif
}
複製程式碼

Summary

It’s common to call functions that take autoclosures, but it’s not common to implement that kind of function.

NOTE

Overusing autoclosures can make your code hard to understand. The context and function name should make it clear that evaluation is being deferred.

— The Swift Programming Language (Swift 4.1)

通常，開發者並無必要去實現帶有 @autoclosure 的函式，如果確有必要，也需要做到明確、清晰。

Extension

COMPILER_INTRINSIC

The compiler intrinsic which is called to lookup a string in a table of static string case values.（筆者譯：編譯器內建，即在一個靜態字串值表中查詢一個字串。）

— $SWIFT_SOURCE_CODE_PATH/stdlib/public/core/StringSwitch.swift

In computer software, in compiler theory, an intrinsic function (or builtin function) is a function (subroutine) available for use in a given programming language which implementation is handled specially by the compiler. Typically, it may substitute a sequence of automatically generated instructions for the original function call, similar to an inline function. Unlike an inline function, the compiler has an intimate knowledge of an intrinsic function and can thus better integrate and optimize it for a given situation.（筆者譯：在計算機軟體領域，編譯器理論中，內建函式（或稱內建函式）是在給定程式語言中可以被編譯器所專門處理的的函式（子程式）。通常，它可以用一系列自動生成的指令代替原來的函式呼叫，類似於行內函數。與行內函數不同的是，編譯器更加了解內建函式，因此可以更好地整合和優化特定情況。）。

— WikiPedia

COMPILER_INTRINSIC 代表其為編譯器的內建函式。

也歡迎您關注我的微博 @萌面大道V

Reference

Swift中的反射
2018-03-25
Swift反射
Swift 4 中的字串
2018-08-09
Swift字串
Swift 中的屬性
2018-09-18
Swift
Swift中的模式匹配
2018-08-14
Swift模式
KeyPath在Swift中的妙用
2019-03-03
Swift
Swift 中的訪問控制
2018-04-09
Swift
理解 Swift 中的 @inlinable （譯）
2022-06-03
Swift
[譯] Swift 中的動態特性
2018-11-27
Swift
[譯]Swift 中的型別擦除
2019-03-04
Swift型別
[譯] Swift 中強大的模式匹配
2019-03-01
Swift模式
swift中Class和Struct的區別
2019-03-18
SwiftStruct
淺談Swift中的函式式
2019-04-11
Swift函式
Swift 中的 String 和 Substring 如何工作
2019-03-02
Swift
[譯] Swift 中的惰性序列及其原理
2018-10-13
Swift
(譯文)swift中的監聽者
2018-05-13
Swift
Swift中安全優雅的使用UserDefaults
2018-05-17
Swift
[譯] Swift 模組中的 API 汙染
2019-04-18
SwiftAPI
Swift 中單例模式的替換
2019-02-20
Swift單例模式
淺談 Swift 中的屬性（Property
2021-09-09
Swift
Swift 中的 JSON 反序列化
2022-07-15
SwiftJSON
Swift 5.7 中的 any 和 some (譯)
2022-06-27
Swift
Swift 中 Substrings 與 String
2018-03-21
Swift
關於Swift中的指標的那些事
2019-01-02
Swift指標
從 Swift 中的序列到型別擦除
2019-02-27
Swift型別
[譯]Swift 中的通用資料來源
2019-02-26
Swift
深入理解Swift中的Class和Struct
2019-02-13
SwiftStruct
Swift中的面向協議程式設計
2018-05-03
Swift協議程式設計
[譯] Swift 中的記憶體洩漏
2018-05-27
Swift記憶體
Swift中依賴注入的解耦策略
2019-05-05
Swift依賴注入解耦
Swift中Result型別的強大功能
2019-04-19
Swift型別
Swift view 中獲取ViewController
2018-10-18
SwiftViewController
Swift中自定義運算子
2021-07-20
Swift
理解 Swift 中的元型別：.Type 與 .self
2019-03-04
Swift型別
關於Swift中Properties的一些理解
2019-02-26
Swift
Swift3、4中的@objc、@objcMembers和dynamic
2019-04-17
SwiftOBJ
在你的 Swift 應用中建立或修改 URL
2018-10-15
Swift
02-Swift4 中 Private 的使用範圍
2018-05-03
Swift
Swift中Class和Struct異同
2018-10-17
SwiftStruct