• 消除重复代码
• 让繁琐的事情变得简单
• 以软件包的形式与其他开发者分享

现有代码重用手段解决了什么问题？

函数

swift
// 源文件根部声明的全局变量
var bar: Int = 0
//   ^
//   |
//   +---------------------------------------------------+
func foo() {                                          // |
  func getHexDescription(for index: Int) -> String {  // |
    return "0x" + String(index, radix: 16)            // |
  }                                                   // |
  for i in 0..<100 {                                  // |
    // for 循环体内部声明的局部变量                           |
    let bar = getHexDescription(for: i)               // |
//       ^                                               |
//       |                                               |
//       +--------- +                                    |
//                  |                                    |
    print("bar = \(bar)")                             // |
  }                                                   // |
// +-----------------------------------------------------+
// |
  bar += 1
}

• 变量只能在控制结构的代码块内访问。
• 控制结构可以用更具表达力的方式，例如使用 if ... else ... 而不仅仅是简单的 if 语句。
• 可以通过更高级的控制结构消除 goto 语句。
• 函数体内可以定义另一个函数。

类型

• 在类型定义块内可以访问类型成员，如变量和函数所声明的。
• 引入点符号语法来访问类型块之外的成员。
• 引入访问控制以保护类型中特定范围内的成员。

swift
struct Foo {
  // `bar` 是私有的
  private var bar: Int
  func print() {
    // `bar` 仅可以在 `Foo` 的类型块中访问.
    print(bar)
  }
}
let foo = Foo()
// `print` 可以通过点语法访问
foo.print()

模块

• 模块成员，如变量、函数和类型，可以在模块内部访问。
• 当不同模块中的名称冲突时，引入点号表示法来访问模块外部的成员。
• 引入访问控制来保护模块内部特定范围的成员。

swift
// 在 Foo 模块中
private var name = "foo"
public var version: String {
  return "1.0"
}
public func foo() {
  print(name)
}
// 在 Bar 模块中
private var name = "bar"
public var version: String {
  return "2.0"
}
public func bar() {
  print(name)
}
// 在 app 中
import Foo
import Bar
print(Foo.version)
foo()
bar()

总结

Swift 宏在哪些方面表现出色？

编译时转换和验证

swift
import SwiftUI
// 颜色类型扩展
extension Color {
  public init(_ hex: UInt)
}
// 使用例子
Color(0xFFEEAA)

swift
// 无效颜色. 只有 5 个十六进制码
Color(0xFFEEA)

swift
#Color(0xFFEEAA) // 可以编译
// #Color 宏展开开始
SwiftUI.Color(red: 1, green: 0.93, blue: 0.67)
// #Color 宏展开结束
#Color(0xFFEEA) // 无效 RGB，无法编译

提供超越函数的行为

swift
func foo(_ bar: Int?) {
  print(bar!)
}

swift
func foo(_ bar: Int?) {
  guard let bar else {
    return
  }
  print(bar)
}

swift
func guard<T>(_ value: T?) -> T {
  guard let value else {
    // 这个 return 无法使得 `foo` 也 return.
    // 此外，这个函数也无法通过编译
    return
  }
  return value
}
func foo(_ bar: Int?) {
  let bar = guard(bar)
  print(bar)
}

swift
func foo(_ bar: Int?) {
  #unwrap(bar) {
    print(bar)
  }
}

swift
func foo(_ bar: Int?) {
  // #unwrap 宏展开开始
  guard let bar = bar else {
    return
  }
  print(bar)
  // #unwrap 宏展开结束
}

提供超越类型的行为

swift
struct User {
  var name: String
  var avatar: URL
}

swift
struct User {
  var name: String
  var avatar: URL
  var avatarsInDifferentScales: [Int : URL]
  var userID: String
  var socialMedias: [String]
  var brief: String
  // ...
}

swift
struct User {
  // 聚合了原本的结构体属性的堆存储容器类型
  private class Storage {
    var name: String
    // 其他属性 ...
  }
  // 堆存储容器实例
  private var _storage: Storage
  init(name: String, ...) {
    self._storage = Storage(name: name, ...)
  }
  // 提供写入时复制行为
  private func makeStorageUniqueIfNeeded() {
    if !isKnownUniquelyReferenced(&_storage) {
      _storage = Storage(name: name, ...)
    }
  }
  // 结构体中被重写的属性
  var name: String {
    get { return _storage.name }
    set {
      makeStorageUniqueIfNeeded()
      _storage.name = newValue
    }
  }
  // 其他被重写的属性 ...
}

swift
@COW
struct User {
  var name: String
  var avatar: URL
  var avatarsInDifferentScales: [Int : URL]
  var userID: String
  var socialMedias: [String]
  var brief: String
  // ...
}

swift
@COW
struct User {
  // @COW 宏展开开始
  private class Storage {
    var name: String
    // 其他属性 ...
  }
  private var _$storage: Storage
  private func makeStorageUniqueIfNeeded() {
    if !isKnownUniquelyReferenced(&_$storage) {
      _$storage = Storage(name: name, ...)
    }
  }
  init(name: String, ...) {
    self._$storage = Storage(name: name, ...)
  }
  // @COW 宏展开结束
  // @COW 宏展开开始
  @COWIncluded(storage: _$storage)
  // @COW 宏展开结束
  var name: String {
    // @COWIncluded 宏展开开始
    get { return _$storage.name }
    set {
      makeStorageUniqueIfNeeded()
      _$storage.name = newValue
    }
    // @COWIncluded 宏展开结束
  }
}

结论

• Swift 宏是另一种封装形式，它不会带来任何新的运行时能力。
• Swift 宏通过在编译时转换程序员的代码来生成代码。这意味着我们也可以将编译时验证整合进去。
• 与 Swift 中现有的代码重用特性不同， Swift 宏默认情况下不会保护其宏展开内容免受应用点现有内容的影响。另外，它也可以改变应用点语义。宏作者在实现 Swift 宏时应该注意潜在的陷阱和问题。具体而言：

  • 对于 freestanding Swift macro，它们不仅可以影响应用点的控制流，还可以共享词法作用域。
  • 对于 attached Swift macro，它们不仅可以为类型扩展成员，还可以为属性提供 accessor。宏展开内容也共享扩展点的「命名空间」。此外，accessor macro 还可以通过添加 get、set 或其他文档中未记录的 accessor（如 _read、_modify、unsafeAddressor 和 unsafeMutableAddressor）将存储属性转换为计算属性。

资源

• 一个实现了 #Color 和 #unwrap 宏的 playground 项目（需要git checkout strengths-and-essence）

• @COW 宏的生产级实现：