再探 Swift 宏 - 优势与本质

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

1

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

1.1

函数

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 源文件根部声明的全局变量
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 语句。
• 函数体内可以定义另一个函数。

1.2

类型

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

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Foo {

  // `bar` 是私有的
  private var bar: Int

  func print() {
    // `bar` 仅可以在 `Foo` 的类型块中访问.
    print(bar)
  }

}

let foo = Foo()
// `print` 可以通过点语法访问
foo.print()

1.3

模块

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

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 在 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()

1.4

总结

2

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

2.1

编译时转换和验证

swift
1
2
3
4
5
6
7
8
9
10
11
import SwiftUI

// 颜色类型扩展
extension Color {

  public init(_ hex: UInt)

}

// 使用例子
Color(0xFFEEAA)

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

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

2.2

提供超越函数的行为

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

swift
1
2
3
4
5
6
func foo(_ bar: Int?) {
  guard let bar else {
    return
  }
  print(bar)
}

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
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
1
2
3
4
5
func foo(_ bar: Int?) {
  #unwrap(bar) {
    print(bar)
  }
}

swift
1
2
3
4
5
6
7
8
func foo(_ bar: Int?) {
  // #unwrap 宏展开开始
  guard let bar = bar else {
    return
  }
  print(bar)
  // #unwrap 宏展开结束
}

2.3

提供超越类型的行为

swift
1
2
3
4
5
6
7
struct User {

  var name: String

  var avatar: URL

}

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct User {

  var name: String

  var avatar: URL

  var avatarsInDifferentScales: [Int : URL]

  var userID: String

  var socialMedias: [String]

  var brief: String

  // ...

}

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@COW
struct User {

  var name: String

  var avatar: URL

  var avatarsInDifferentScales: [Int : URL]

  var userID: String

  var socialMedias: [String]

  var brief: String

  // ...

}

swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
@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 宏展开结束
  }

}

3

结论

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

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

4

资源

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

• @COW 宏的生产级实现：