Swift 的新功能

Swift 的新功能

与我们一起来了解 Swift 的更新。我们将向你展示 API 如何通过参数包和宏等功能变得更具可扩展性和表现力。我们还将带你了解互操作性方面的改进，并分享我们如何将 Swift 在性能和安全方面的优势扩展到各个领域 - 从 Foundation 到服务器上的大规模分布式程序。

章节
- 0:39 - Swift project update
- 2:44 - Using if/else and switch statements as expressions
- 3:52 - Result builders
- 4:53 - type parameter packs
- 9:34 - Swift macros
- 19:47 - Swift foundation
- 23:25 - Ownership
- 27:59 - C++ interoperability
- 32:41 - What's new in Swift Concurrency
- 38:20 - FoundationDB: A case study
资源
相关视频

WWDC23
WWDC21
- Swift 并发功能：幕后故事
下载

♪ ♪
Ben：大家好欢迎收看 “Swift 5.9 中的新功能” 我是 Ben 我和我的同事 Doug 将带你了解今年 Swift 语言的一些改进我们将介绍一些使用 Swift 简洁语法更简便地表达意图的方法一些帮助框架作者使他们的新 API 使用起来更自然的强大新功能我们还将介绍一些新方法来更好地控制底层代码的性能和安全性我们先来介绍一下 Swift 开源项目这是 Swift 很棒的更新如果没有 Swift 社区和集结在 swift.org 的语言贡献者和使用者共同努力发展该语言并支持新的创意这一切就不可能实现 Swift 遵循开放的语言进化过程新功能或重要行为改变都会在 Swift 论坛上公开提出和审查如果你想继续学习可以在 Swift 网站上找到所有语言提案的布告栏一年前我们见证了 Swift 项目治理的重大重组核心团队宣布成立语言指导小组主要负责监督 Swift 语言和标准库的发展从那之后语言指导小组监督了 40 项新语言提案我们今天会提到其中一部分
但有时单个语言提案会作为一个更广泛主题的一部分聚集在一起例如 Swift 并发的附加功能这是通过十项单独的提案的提出的为了应对这样的案例语言指导小组提出了通过构想文档将这些提案联系在一起的新方法这些文档为更大型的语言修改做出规划提案语言指导小组最早接受的提案是 Swift 宏的构想 Swift 5.9 的一项新功能我们会在本次演讲的后面谈到当然语言的进化只是 Swift 社区工作的一部分一门成功的语言需要的远不止这些它需要出色的工具、对多平台的强大支持和丰富的文档为了监督这一领域的进展核心团队将组建一个与语言指导小组并行的生态系统指导小组这个新组织是最近在 swift.org 的一篇博客文章中提出的我们期待着关于这个新小组成立的进一步公告现在我们来谈谈今年 Swift 语言的变化从在代码中以更好的方式表达自己开始 Swift 5.9 包含了可能是我们呼声最高的语言增强功能允许将 if/else 和 switch 语句用作表达式从而提供了一种整理代码的好方法
例如如果你想要在一些复杂的条件下初始化一个 let 变量你必须借助技巧比如这个难以阅读的复合三元表达式
If 表达式允许你改用更熟悉和可读性高的 if 语句链
另一个有用的地方是初始化全局变量或存储属性这里单独的表达式运行正常如果你想添加一个条件你必须把它放在一个闭包中之后会被立即执行
既然 if 语句可以是表达式你可以丢掉那些杂乱的内容留下更整洁的代码结果构造器即驱动 SwiftUI 等功能的声明性语法在今年进行了显著的改进包括优化类型检查性能、代码补全和改进错误信息
这种改进尤其针对无效代码之前有错误的结果构造器代码无法马上报错因为类型检查器会探索许多可能的无效路径
从 Swift 5.8 开始无效代码类型检查要快得多无效代码上的错误信息更加精确例如之前某些无效代码可能会在结果构造器完全不同的部分中引发误导性错误在 Swift 5.7 中当错误实际发生的时候你就会收到一个这样的错误
在最新版本中你会收到识别真正问题的更准确的编译器诊断接下来我们谈一谈对泛型系统的补充会如何对你每天使用的框架产生一些重大改进
几乎所有你写的 Swift 代码都使用了泛型类型推断允许使用这些类型而无需了解构建它们的高级功能例如标准库数组类型使用泛型来提供一个数组可以与你可能想要存储的任何类型的数据一起工作当你需要使用数组时你需要做的就是提供元素不需要为元素类型指定显式参数因为它可以从元素值中推断出来
Swift 的泛型系统通过保留类型信息实现自然的 API 这样你的代码就可以无缝在你提供的具体类型上进行操作这里是一个受 Swift 编译器自身代码库启发的例子：一个接受请求类型的 API 对其进行评估以产生一个强类型的值所以你可以请求一个布尔值并得到一个布尔值的结果
现在一些 API 不仅想抽象具体类型而且还想对你传入的参数数量进行抽象因此一个函数可能接受一个请求并返回一个结果或者接受两个请求并返回两个结果或者更多
为了支持这一点泛型系统必须与处理多个参数长度的机制一起使用这样你传入的所有类型都与你传出的类型相关联在 Swift 5.9 之前完成这种模式的唯一方法是为 API 支持的每个特定参数长度重新定义一遍但这种方法有局限性它对你能传递的参数数量强加了一个人为的上限如果你传递的参数太多就会导致编译器错误在这个例子中所有重载都不能处理超过 6 个参数但我们却传了 7 个这种重复定义的规律和它自身的限制的问题在理论上需要处理无限参数长度的 API 中普遍存在
在 Swift 5.9 中泛型系统通过对参数长度进行泛型抽象获得对该 API 模式的直接支持这是通过一个新的语言概念来实现的它可以表示“打包”在一起的多个独立的类型参数这个新概念被称为类型参数聚合使用参数聚合当前对每个固定参数长度有单独重载的 API 可以被压缩成单一的函数
evaluate 函数现在不是接受一个参数和与这个请求对应的 Result 类型而是接受任何与各自 Result 类型对应的独立请求该函数会在括号中返回每个 Result 实例括号中会是单一的值或是包含每个值的元组 evaluate 函数现在可以处理所有参数的长度没有人为限制
类型推理让使用参数聚合的 API 可以很自然地使用而不需要知道 API 正在使用聚合
调用我们的新 evaluate 函数现在可以处理任何数量的参数看起来就像调用固定长度的重载 Swift 会根据你调用函数的方式来推断每个参数的类型和总数想了解如何编写像这样的泛型库 API 请查看使用参数聚合的泛型化 API 以一种自然的方式调用泛型 API 展示了 Swift 的基本设计目标之一即通过简洁的代码进行清晰的表达
Swift 的高级语言功能使赏心悦目的 API 更容易表达你的意图
无论是通过数组或字典使用泛型还是在 SwiftUI 中设计 UI 从你在 Swift 写第一行代码开始这些高级语言功能都会有所帮助 Swift 接受渐进式展开意味着你可以准备好了再学习更高级的功能
Swift 5.9 将这种设计方法提升到了一个新的水平它为库作者提供了一个新的工具箱可以使用新的宏系统进行表达式 API 设计有请 Doug 来为大家介绍更多内容 Doug：使用宏你可以扩展语言本身的功能消除重复代码并解锁 Swift 更多表达能力让我们想一下一直存在的 assert 函数它用来检查一个条件是否为真如果条件为假 assert 函数会停止程序但当这种情况发生时你几乎得不到任何出错的信息只有文件和行号你需要增加一些日志记录或在调试器中捕获程序以进一步了解已经有人试图改进这一点了 XCTest 提供了一个 assert-equal 操作它可以分别获取两个值所以运行失败后你至少可以看到两个不相等的值但是我们仍然不知道哪个值是错的是 a、b 还是 max 的值？这种方法不适用于我们在断言中执行的各种类型的检查如果我们回到最初的断言当我们的断言失败时在源代码中有很多信息我们希望在记录中看到这段代码是什么？ a、b、c 的值是什么？ max 产生了什么？除非通过一些自定义的功能我们以前无法在 Swift 中改进这一点但宏实现了这一点
在这个例子中 “#assert” 语法正在展开名为 “assert” 的宏 # 语法可能看起来很熟悉因为 Swift 已经有一些同样拼写的内容比如 #file、 #selector 和 #warning assert 宏看起来和感觉上都和函数版本一样但因为它是一个宏所以当断言失败时它可以提供更丰富的体验现在程序显示的是失败断言的代码以及导致结果的每个值
在 Swift 中宏是 API 就像类型或函数一样你可以通过导入定义它们的模块来访问它们和许多其他 API 一样宏是以包的形式分发的这里的 assert 宏来自 power asserts 库它是一个开源的 Swift 包可以在 GitHub 上找到
如果你要查看宏包你会发现 assert 的宏声明它是用 “macro” 关键字引入的但除此之外它看起来很像一个函数有一个未标记的 Bool 参数用于检查条件如果这个宏产生一个值这个结果类型将用通常的箭头语法来写对该宏的使用将根据参数进行类型检查这意味着如果你在使用宏的过程中犯了错误比如忘记将最大值与某些内容进行比较在宏被展开之前你会立即得到一个有用的错误信息这使得 Swift 在使用宏时提供了很好的开发体验因为宏可以在类型正确的输入上操作并产生代码以可预测的方式增强你的程序大多数宏被定义为 “外部宏” 通过字符串指定宏实现的模块和类型外部宏类型是在作为编译器插件的独立程序中定义的 Swift 编译器将使用宏的源代码传递给插件该插件会产生新的源代码然后它会被整合回 Swift 程序中在这里宏正在将断言扩展为代码以捕捉各个数值以及它们在源代码中应该显示的位置你不会想自己写这些模板不过宏会为你做这些宏声明有一个额外的信息即它们的角色这里的断言宏是一个 freestanding 的表达式宏它被称为 freestanding 因为它使用了 “#” 语法并可以直接在语法上操作以产生新代码它是一个表达式宏因为它可以在任何可以产生值的地方使用新的 Foundation Predicate API 提供了一个表达式宏的好例子谓词宏让人们使用闭包以类型安全的方式编写断言产生的谓词值可以用于一些其他 API 包括 Swift 集合操作 SwiftUI 和 SwiftData 该宏本身在输入类型的集合上是泛型的它接受一个闭包参数作为函数处理这些输入参数并产生一个布尔结果输入集合是否匹配？宏会返回一个新的 Predicate 类型的实例它可以用在程序的其他地方
不过宏还有更多的应用因为我们最终写的很多重复代码都是因为我们需要为已有代码派生出衍生代码举个例子我发现我在自己的代码中经常使用枚举比如这个可以捕获相对或绝对路径的路径枚举但是我经常发现自己需要检查一个特定的情况比如从一个集合中过滤所有绝对路径当然我可以把这个 isAbsolute 检查写成一个计算属性但我迟早还得再写一个这有些无聊
宏可以帮我们生成这些重复代码 CaseDetection 是一个附加宏使用与属性包装器相同的自定义属性语法编写附加宏将其应用的声明的语法作为输入…… 这里是枚举声明本身……并将生成新代码
这个宏扩展的代码是正常的 Swift 代码编译器会将其整合到你的程序中你可以在编辑器中检查宏生成的代码对其进行调试如果你想进一步自定义它请将其复制出来等等
附加宏根据其对所附声明的增强方式被分为五种不同的角色我们刚才讨论的 CaseDetection 宏是一个“member”附加宏意味着它会在类型或扩展中创建新的成员 Peer 宏会在它们所附声明旁边添加新的声明例如为 completion-handler 版本创建一个 async 方法反之亦然
Accessor 宏可以将一个存储的属性变成一个计算的属性它可以用来对属性访问执行特定操作或者以类似于属性包装器但比其更灵活的方式抽象出实际存储附加宏可以将属性引入到一个类型的特定成员上以及添加新的协议符合性几个附加宏角色可以组合在一起以达到一些有用的效果这方面的一个重要例子是观察观察一直是 SwiftUI 的一个组成部分为了能够观察一类属性变化只需要让类型符合 ObservableObject 并将每个属性标记为 @Published 然后在你的视图中使用 ObservedObject 属性包装器这包含很多步骤错过一个可能意味着 UI 不能按预期更新我们可以利用基于宏的观察做得更好
将 Observable 宏附加到一个类上可以对其所有的存储属性进行观察不需要对每个存储的属性进行标注也不需要担心如果不这样做会发生什么因为 Observable 宏会处理这一切
Observable 宏组合了三个宏角色让我们深入了解这些角色是如何一起工作的每个宏的角色都对应于 Person 类被 Observable 宏增强的某种特定方式 member 角色引入了新的属性和方法
member 属性角色会把 @ObservationTracked 宏添加到被观察类的存储属性中这又扩展 getter 和 setter 以触发观察事件的最后 conformance 角色会引入与 Observable 协议的一致性
看起来代码很多但这都是普通的 Swift 代码它们都整齐地折叠在 Observable 宏后面
每当你需要查看任何宏是如何扩展的以更好地了解它对你的程序的影响它就在 Xcode 中触手可及
点击使用 “Expand Macro” 可以在你的编辑器中看到宏扩展后的源代码宏生成的代码中的任何错误信息都会自动显示扩展后的代码你可以用你的调试器单步进入和退出它
Swift 宏提供了一种新的工具可以实现更具表现力的 API 消除 Swift 中的重复代码帮助解锁 Swift 的表现力宏对其输入进行类型检查产生常规的 Swift 代码并在你的程序中的定义点实现整合因此它们的效果很容易推断而且如果你需要了解一个宏的作用可将其源代码扩展在你的编辑器中我们只是介绍了宏的一点知识 “扩展 Swift 宏” 将深入探讨 Swift 宏的设计回答你所有想问的问题你还可以通过 “编写 Swift 宏” 动手实现你自己的宏我迫不及待想看到 Swift 社区中出现的新的宏了
Ben：从一开始 Swift 就被设计成一种可扩展的语言 Swift 的设计强调表现力代码清晰简洁不讲究仪式易于阅读和编写利用 Swift 的强大功能如泛型和原生并发支持 SwiftUI 或 SwiftData 等框架让你快速实现你想要的结果有更多时间专注于重要的事情
尽管有这些高水平的功能 Swift 依旧很高效它是原生编译的它使用值类型和引用计数而不是垃圾收集这意味着它能够实现低内存占用
这种可扩展性意味着我们能够使 Swift 触达比以前使用 Objective-C 时更多的地方到之前你认为必须使用 C 或 C++ 的底层系统这意味着将 Swift 更清晰的代码和关键的安全保证应用到更多地方我们最近开放了通过 Swift 重写 Foundation 框架的源代码这一举措将使得 Foundation 在 Apple 和非 Apple 平台上共享同一实现但这也意味通过 Swift 重写大量的 Objective-C 和 C 代码截至 MacOS Sonoma 和 iOS 17 有全新的 Swift 支持的基本类型的实现如 Date 和 Calendar 有格式化和国际化的基本类型的实现如 Locale 和 AttributedString 以及 JSON 编码和解码的全新的 Swift 实现性能方面的优势也很明显
Calendar 计算重要日期的能力可以更好地利用 Swift 的值语义来避免临时分配从而在一些基准测试中提高了 20% 以上 FormatStyle 的日期格式化也获得了一些重大的性能升级在使用标准日期和时间模板进行格式化的测评中获得了 150% 的巨大提升更令人兴奋的是新软件包中对 JSON 解码的改进 Foundation 为 JSONDecoder 和 JSONEncoder 提供了一个全新的 Swift 实现消除了与 Objective-C 集合类型之间高代价的往返操作通过与 Swift 的 JSON 解析的紧密整合 Codable 类型初始化也提高了性能在解析测试数据的测评中新的实现要快 2 到 5 倍这些改进既有减少从旧的 Objective-C 实现到 Swift 的桥接成本也有新 Swift 实现更快的速度
让我们以一个测评为例来看看在 Ventura 中由于桥接成本从 Objective-C 中调用 enumerateDates 比从 Swift 中调用稍快在 macOS Sonoma 中从 Swift 中调用同样的功能要快 20% 部分速度的提高是因为消除了桥接成本但新函数的实现本身也更快从 Objective-C 中调用它时就可以看出这个特定的日期计算并不太复杂所以这是减少两种语言之间开销的好方法有时候当你做系统底层操作时需要更精细的控制来达到必要的性能水平 Swift 5.9 引入了一些新的功能选项帮助你实现这种程度的控制这些功能侧重于所有权概念也就是说当一个值在你的 App 中传递时代码的哪一部分“拥有”它
为了了解你什么时候可能会使用这些功能我们先来看一些示例代码这里是一个非常简单的文件描述符的包装器它可以让我们给底层的系统调用一个更好的 Swift 接口但是在这个 API 上还是有一些容易犯错的地方例如你可能会在调用 close 后尝试写入文件而且你必须小心在对象超出作用域之前总是通过调用 close 手动关闭它否则就会导致资源泄漏解决方案之一是把它变成一个带有 deinit 的类当类型离开作用域时自动关闭它
但这仍然有别的问题比如要进行额外的内存分配这通常不是一个大问题除非是在一些非常受限的系统环境中
类也有引用语义你可能会无意中在各线程间共享一个文件描述符类型导致竞赛条件或者无意中存储它
不过让我们回头看看结构版本
真的这个结构也像一个引用类型它包含一个引用真值的整数而真值是一个打开的文件对这种类型进行复制也可能导致在你的 App 中无意地共享可变的状态从而导致 bug 你需要的是抑制该结构复制的能力
Swift 类型无论是结构还是类默认都是可拷贝的在大多数情况下是正确的选择虽然过多的非必要拷贝有时会成为你代码中的瓶颈但偶尔花时间在工具中找到这些瓶颈总比经常因为编译器要求你明确这些拷贝而被困扰要好但有时这种隐式拷贝并不是你想要的特别是在对一个值进行拷贝可能导致正确性问题的时候比如我们的文件描述符包装器在 Swift 5.9 中你可以用这种新的语法来操作这种语法可以应用于结构和枚举的声明它可以抑制隐式拷贝类型的能力如果某个类型是不可复制的你就可以给它添加一个 deinit 就像可以为类所做的一样当该类型的一个值超出作用域时它会运行
不可复制类型也可以用来解决调用 close 后仍然调用其他方法的问题
close 操作可以被标记为消耗性 (consuming) 的调用一个消耗性的方法或参数会将一个值的所有权交还给所调用的方法由于我们的类型是不可复制的放弃所有权意味着你不能再使用这个值
默认情况下 Swift 中的方法会借用其参数包括其自身所以你可以调用 write 方法它借用了文件描述符用它来写出缓冲区之后值的所有权就回到了调用者那里然后你就可以调用另一个方法比如 close
但是由于 close 已经被标记为消耗性的而不是默认的借用所以那必须是它的最终用途
这意味着如果你先关闭文件然后试图调用另一个方法比如 write 你会在编译时得到一个错误信息而不是运行时失败编译器还会指出消耗性使用发生在哪里
不可复制类型是 Swift 中系统级编程的一个强大的新功能它们仍然处于发展的早期阶段以后的 Swift 版本将不可复制类型扩展到泛型代码中如果你有兴趣关注这项工作 Swift 论坛上正在积极开展讨论 Doug：Swift 成功的一个关键是它与 Objective-C 的互操作性从一开始开发者就能在他们现有的代码库中逐步采用 Swift 一次只混合一个文件或模块但我们知道很多人并不只是用 Objective-C 写代码许多 App 还具有以 C++ 实现的核心业务逻辑与之对接并不那么容易通常这意味着要增加一个额外的人工桥接层从 Swift 到 Objective-C 再到 C++ 然后一路返回 Swift 5.9 引入了 Swift 与 C++ 类型和函数直接的互动能力 C++ 互操作性的工作方式与 Objective-C 互操作性的工作方式一样将 C++ API 映射到你可以直接从 Swift 代码中使用的 Swift 对应项 C++ 是一种大型语言它有自己的概念比如类、方法和容器等等 Swift 编译器可以理解常见的 C++ 习语所以许多类型可以直接使用例如这个 Person 类型定义了一个 C++ 值类型所期望的五个特殊成员函数：复制和移动构造函数、赋值运算符和析构函数 Swift 编译器将其视为一个值类型并会在正确的时间自动调用正确的特定成员函数此外像 vector 和 map 这样的 C++ 容器也可以作为 Swift 集合访问
所有这些的结果是我们可以编写直接使用 C++ 函数和类型的简洁的 Swift 代码我们可以在 Person 实例的 vector 上进行过滤调用 C++ 成员函数并直接访问数据成员
在另一个方向从 C++ 中使用 Swift 代码的机制和在 Objective-C 中使用 Swift 代码的机制一样 Swift 编译器会产生一个“生成的头文件” 其中有包含 C++ 视图的 Swift API 不过与 Objective-C 不同的是你不需要限制自己只使用用 objc 属性标注的 Swift 类 C++ 可以直接使用大多数 Swift 类型及其完整的 API 包括属性、方法和初始化定式不需要任何桥接开销这里我们可以看到 C++ 是如何利用我们的 Point 结构的在包含生成的头文件之后 C++ 可以调用 Swift 初始化方法来创建 Point 实例调用 mutating 方法并访问存储和计算的属性所有这些都不需要对 Swift 代码本身做任何改动
Swift 的 C++ 互操作性使得整合 Swift 与现有 C++ 代码库变得前所未有的简单许多 C++ 习语可以直接在 Swift 中表达通常会自动表达但偶尔也需要一些标注来表明所需的语义 Swift API 可以直接从 C++ 中访问不需要标注或改变代码这使得在使用任何 C、C++ 和 Objective-C 混合的代码库中逐步采用 Swift 成为可能
C++ 互操作性是一个不断发展的过程由 C++ 互操作性工作组指导想要了解更多信息请查看演讲“混合 Swift 和 C++” 或加入我们在 Swift 论坛上的讨论
语言层面的互操作性确实很重要但你也必须能够构建你的代码而要用 Xcode 或 Swift Package Manager 取代你现有的构建系统才能开始使用 Swift 这和重写大量代码一样都是很大的障碍所以我们与 CMake 社区合作在 CMake 中改进对 Swift 的支持你可以通过声明 Swift 是项目的语言之一并将 Swift 文件放入目标中将 Swift 代码整合到你的 CMake 构建中
更重要的是你可以在一个目标中混合使用 C++ 和 Swift 而 CMake 将确保分别编译这两种语言并为这两种语言链接所有适当的支持库和运行时这意味着你今天就可以开始在你的跨平台 C++ 项目中逐个文件或逐个目标的采用 Swift 我们还提供了一个包含 CMake 项目的示例库其中包含 Swift 和 C++/Swift 混合目标包括使用桥接和生成的头文件以帮助你入门
几年前我们在 Swift 中引入了一个新的并发模型该模型基于 async/await、结构化并发和 actor 等构建模块 Swift 的并发模型是一个抽象模型可以适应不同的环境和库这个抽象模型有两个主要部分：task 和 actor task 代表一个顺序工作的单位在概念上可以在任何地方运行只要程序中有 “await” task 就可以暂停 task 能够继续后就可以恢复运行
actor 是一种同步机制提供对隔离状态的互斥访问从外部进入一个 actor 需要一个“await” 因为它可能会暂停 task
task 和 actor 被整合到抽象语言模型中但在该模型中它们可以用不同的方式实现以适应不同的环境 task 是在全局并发池上执行的全局并发池如何决定安排工作取决于环境对于 Apple 的平台 Dispatch 库为整个操作系统提供了优化的调度并为每个平台进行了广泛的调整在更受限制的环境中多线程调度程序开销可能无法被接受在这里 Swift 的并发模型是通过单线程合作队列实现的同样的 Swift 代码在两种环境下都能工作因为抽象模型足够灵活可以映射到不同的运行时环境
此外与基于回调的库的互操作性从一开始就内置于 Swift 的 async/await 支持中 withCheckedContinuation 操作允许暂停 task 并在稍后响应回调时恢复它这让我们能够与现有的管理任务的库整合
Swift 并发运行时中的 actor 标准实现是在 actor 上执行的无锁的 task 队列但这不是唯一可能的实现在一个更受限制的环境中可能没有原子操作这样就可以使用另一种并发原语如自旋锁如果该环境是单线程的就不需要同步但不管怎样 actor 模型都会为程序维护抽象的并发模型你还可以把同样的代码带到多线程的环境中在 Swift 5.9 中自定义 actor 执行器允许特定 actor 实现自己的同步机制这使得 actor 更加灵活可以适应现有环境我们来举个例子这里我们考虑一个管理数据库连接的 actor Swift 确保了对这个 actor 的存储的互斥访问所以不会有任何对数据库的并发访问不过如果你需要对同步的具体方式进行更多的控制呢？例如如果你想为你的数据库连接使用一个特定的调度队列也许是因为这个队列是与其他没有采用 actor 的代码共享的那怎么办？有了自定义 actor 执行器你就可以做到了
在这里我们给 actor 添加了一个串行调度队列并实现了 unownedExecutor 属性产生了与该调度队列相对应的执行器有了这个变化我们的 actor 实例的所有同步都将通过该队列发生
当你从 actor 外部对 pruneOldEntries 的调用进行 “await” 时它将在相应的队列上执行一个 dispatch-async 这让你对单个 actor 如何提供同步有了更多的控制甚至可以让你将一个 actor 与其他还没有使用 actor 的代码同步有可能是因为它是用 Objective-C 或 C++ 写的
通过调度队列实现 actor 的同步是因为调度队列符合新的 SerialExecutor 协议你可以通过定义一个符合该协议的新类型来提供你自己的同步机制以便与 actor 一起使用该协议只有少数核心操作：检查代码是否已经在执行器的上下文中执行例如我们是否在主线程上运行？
提取对执行器的无主引用以允许对其进行访问而不需要过多的引用计数流量还有最核心的操作：enqueue 它需要取得 “job” 执行器的所有权 job 是异步任务的一部分需要在执行器上同步运行 enqueue 被调用时执行器有责任在没有其他代码在串行执行器上运行的时候运行该 job 例如调度队列的 enqueue 会在该队列上调用派发 async
Swift Concurrency 已经使用了几年其由 task 和 actor 组成的抽象模型涵盖了大量的并发编程任务抽象模型本身相当灵活使其能够适应不同的执行环境从 iPhone 到 Apple Watch 再到服务器等它还允许在关键点上进行定制使其能够与尚未完全采用 Swift Concurrency 的代码进行互操作了解更多信息请查看我们的“幕后”演讲以及“超越基础的结构化并发” 我想用以下的案例研究来总结一下 Swift 的运行环境与我们习惯看到的 iOS 或 MacOS App 非常不同 FoundationDB 是一个分布式数据库它为在商用硬件上运行的非常大的键值存储提供可扩展的解决方案并支持各种平台包括 macOS、Linux 和 Windows FoundationDB 是一个开源项目有一个用 C++ 编写的大型代码库该代码是高度异步的有自己的分布式 actor 和运行时为测试目的提供至关重要的确定性模拟环境 FoundationDB 希望对他们的代码库进行现代化改造并发现 Swift 在性能、安全性和代码简洁性方面是个不错的选择完全重写是巨大而冒险的工作相反我们利用了 Swift 的互操作性来整合到现有的代码库中例如这里是 FoundationDB 的 “主数据” actor 的 C++ 实现的一部分
内容很多但你不需要理解所有这些 C++ 不过我想指出该代码的几个关键方面首先 C++ 没有 async/await 所以 FoundationDB 有他们自己的类似预处理器的方法来模拟它
像许多 C++ 代码库一样他们实现了自己的 C++ Future 类型来管理异步任务它们与显式消息传递配对以发送对请求的响应注意发送回复与从函数中返回的仔细配对最后 FoundationDB 有自己的引用计数的智能指针来帮助自动管理内存我们可以在 Swift 中更简洁地实现这些
这就好多了这个函数可以直接作为 Swift 的一个同步函数来实现我们有一个正常的返回类型和正常的返回语句来提供对这个请求的响应所以你会一直保持同步我们有 “await” 来表示暂停点其方式与所有其他 Swift 异步代码相同这段 Swift 代码与 C++ 的 Future 类型相适应使用 continuation 进行改编
我们在这里使用了一些 C++ 的类型 C++ 中的 MasterData 类型使用的是引用计数的智能指针通过在 C++ 中标注该类型 Swift 编译器可以像使用其他类一样使用该类型自动为我们管理引用计数
其他类型如请求和回复类型是在 Swift 中直接使用的 C++ 值类型而且互操作性是双向的这个异步函数以及由 Swift concurrency 模型引入的所有工作都可以在 FoundationDB 现有的确定性运行时上运行因此我们可以获得我们想要的 Swift 好处与现有的 C++ 对接以实现逐步采用
在这部分中我们已经讨论了很多内容我们描述了参数聚合和宏等功能这些功能使 API 更具表现力可以帮助你更快地编写更好的代码我们谈到了 Swift 在性能敏感代码中的使用以及引入不可复制类型来提供资源管理而不需要引用计数的开销然后我们深入探讨了 C++ 的互操作性它为在 Swift 中使用 C++ API 提供了支持反之亦然让 Swift 的好处更容易地惠及你的更多代码
最后我们谈到了 Swift 灵活的并发模型如何适应不同设备和语言的种种环境使并发变得更容易和安全参数聚合、宏、不可复制类型以及 Swift 5.9 中的所有其他语言增强功能都是通过 Swift Evolution 过程公开设计和开发的而社区反馈对塑造这些功能至关重要 Swift 5.9 是整个 Swift 社区成员无数次贡献的结晶他们开展了积极的设计讨论、错误报告、拉动请求、教育内容等等感谢你让 Swift 5.9 成为一个伟大的版本 ♪ ♪

3:06 - Hard-to-read compound ternary expression

let bullet =
    isRoot && (count == 0 || !willExpand) ? ""
        : count == 0    ? "- "
        : maxDepth <= 0 ? "▹ " : "▿ "

3:19 - Familiar and readable chain of if statements

let bullet =
    if isRoot && (count == 0 || !willExpand) { "" }
    else if count == 0 { "- " }
    else if maxDepth <= 0 { "▹ " }
    else { "▿ " }

3:30 - Initializing a global variable or stored property
```
let attributedName = AttributedString(markdown: displayName)
```

3:46 - In 5.9, if statements can be an expression

let attributedName = 
				if let displayName, !displayName.isEmpty {
            AttributedString(markdown: displayName)
        } else {
            "Untitled"
        }

4:31 - In Swift 5.7, errors may appear in a different place

struct ContentView: View {
    enum Destination { case one, two }

    var body: some View {
        List {
            NavigationLink(value: .one) { // The issue actually occurs here
                Text("one")
            }
            NavigationLink(value: .two) {
                Text("two")
            }
        }.navigationDestination(for: Destination.self) {
            $0.view // Error occurs here in 5.7
        }
    }
}

4:47 - In Swift 5.9, you now receive a more accurate compiler diagnostic

struct ContentView: View {
    enum Destination { case one, two }

    var body: some View {
        List {
            NavigationLink(value: .one) { //In 5.9, Errors provide a more accurate diagnostic
                Text("one")
            }
            NavigationLink(value: .two) {
                Text("two")
            }
        }.navigationDestination(for: Destination.self) {
            $0.view // Error occurs here in 5.7
        }
    }
}

5:47 - An API that takes a request type and evaluates it to produce a strongly typed value

struct Request<Result> { ... }

struct RequestEvaluator {
    func evaluate<Result>(_ request: Request<Result>) -> Result
}

func evaluate(_ request: Request<Bool>) -> Bool {
    return RequestEvaluator().evaluate(request)
}

6:03 - APIs that abstract over concrete types and varying number of arguments

let value = RequestEvaluator().evaluate(request)

let (x, y) = RequestEvaluator().evaluate(r1, r2)

let (x, y, z) = RequestEvaluator().evaluate(r1, r2, r3)

6:35 - Writing multiple overloads for the evaluate function

func evaluate<Result>(_:) -> (Result)

func evaluate<R1, R2>(_:_:) -> (R1, R2)

func evaluate<R1, R2, R3>(_:_:_:) -> (R1, R2, R3)

func evaluate<R1, R2, R3, R4>(_:_:_:_:)-> (R1, R2, R3, R4)

func evaluate<R1, R2, R3, R4, R5>(_:_:_:_:_:) -> (R1, R2, R3, R4, R5)

func evaluate<R1, R2, R3, R4, R5, R6>(_:_:_:_:_:_:) -> (R1, R2, R3, R4, R5, R6)

6:47 - Overloads create an arbitrary upper bound for the number of arguments

//This will cause a compiler error "Extra argument in call"
let results = evaluator.evaluate(r1, r2, r3, r4, r5, r6, r7)

7:12 - Individual type parameter
```
<each Result>
```

7:36 - Collapsing the same set of overloads into one single evaluate function

func evaluate<each Result>(_: repeat Request<each Result>) -> (repeat each Result)

8:21 - Calling updated evaluate function looks identical to calling an overload

struct Request<Result> { ... }

struct RequestEvaluator {
    func evaluate<each Result>(_: repeat Request<each Result>) -> (repeat each Result)
}

let results = RequestEvaluator.evaluate(r1, r2, r3)

10:01 - It isn't clear why an assert function fails
```
assert(max(a, b) == c)
```

10:20 - XCTest provides an assert-equal operation

XCAssertEqual(max(a, b), c) //XCTAssertEqual failed: ("10") is not equal to ("17")

11:02 - Assert as a macro
```
#assert(max(a, b) == c)
```
11:42 - Macros are distributed as packages
```
import PowerAssert
#assert(max(a, b) == c)
```
12:07 - Macro declaration for assert
```
public macro assert(_ condition: Bool)
```

12:26 - Uses are type checked against the parameters

import PowerAssert
#assert(max(a, b)) //Type 'Int' cannot be a used as a boolean; test for '!= 0' instead

12:52 - A macro definition

public macro assert(_ condition: Bool) = #externalMacro(
    module: “PowerAssertPlugin”,
    type: “PowerAssertMacro"
)

13:11 - Swift compiler passes the source code for the use of the macro
```
#assert(a == b)
```

13:14 - Compiler plugin produces new source code, which is integrated back into the Swift program

PowerAssert.Assertion(
    "#assert(a == b)"
) {
    $0.capture(a, column: 8) == $0.capture(b, column: 13)
}

13:33 - Macro declarations include roles

// Freestanding macro roles

@freestanding(expression)
public macro assert(_ condition: Bool) = #externalMacro(
    module: “PowerAssertPlugin”,
    type: “PowerAssertMacro"
)

13:53 - New Foundation Predicate APIs uses a `@freestanding(expression)` macro role

let pred = #Predicate<Person> {
    $0.favoriteColor == .blue
}

let blueLovers = people.filter(pred)

14:14 - Predicate expression macro

// Predicate expression macro

@freestanding(expression) 
public macro Predicate<each Input>(
    _ body: (repeat each Input) -> Bool
) -> Predicate<repeat each Input>

14:48 - Example of a commonly used enum

enum Path {
    case relative(String)
    case absolute(String)
}

15:01 - Checking a specific case, like when filtering all absolute paths
```
let absPaths = paths.filter { $0.isAbsolute }
```

15:09 - Write an `isAbsolute` check as a computer property...

extension Path {
    var isAbsolute: Bool {
        if case .absolute = self { true }
        else { false }
    }
}

15:12 - ...And another for `isRelative`

extension Path {
    var isRelative: Bool {
        if case .relative = self { true }
        else { false }
    }
}

15:17 - Augmenting the enum with an attached macro

@CaseDetection
enum Path {
    case relative(String)
    case absolute(String)
}

let absPaths = paths.filter { $0.isAbsolute }

15:36 - Macro-expanded code is normal Swift code

enum Path {
    case relative(String)
    case absolute(String)
  
    //Expanded @CaseDetection macro integrated into the program.
    var isAbsolute: Bool {
        if case .absolute = self { true }
        else { false }
    }

    var isRelative: Bool {
        if case .relative = self { true }
        else { false }
    }
}

16:57 - Observation in SwiftUI prior to 5.9

// Observation in SwiftUI

final class Person: ObservableObject {
    @Published var name: String
    @Published var age: Int
    @Published var isFavorite: Bool
}

struct ContentView: View {
    @ObservedObject var person: Person
    
    var body: some View {
        Text("Hello, \(person.name)")
    }
}

17:25 - Observation now

// Observation in SwiftUI

@Observable final class Person {
    var name: String
    var age: Int
    var isFavorite: Bool
}

struct ContentView: View {
    var person: Person
    
    var body: some View {
        Text("Hello, \(person.name)")
    }
}

17:42 - Observable macro works with 3 macro roles

@attached(member, names: ...)
@attached(memberAttribute)
@attached(conformance)
public macro Observable() = #externalMacro(...).

17:52 - Unexpanded macro

@Observable final class Person {
    var name: String
    var age: Int
    var isFavorite: Bool
}

18:05 - Expanded member attribute role

@Observable final class Person {
    var name: String
    var age: Int
    var isFavorite: Bool
  
		internal let _$observationRegistrar = ObservationRegistrar<Person>()
    internal func access<Member>(
        keyPath: KeyPath<Person, Member>
    ) {
        _$observationRegistrar.access(self, keyPath: keyPath)
    }
    internal func withMutation<Member, T>(
        keyPath: KeyPath<Person, Member>,
        _ mutation: () throws -> T
    ) rethrows -> T {
        try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
    }
}

18:12 - Member attribute role adds `@ObservationTracked` to stored properties

@Observable final class Person {
    @ObservationTracked var name: String
    @ObservationTracked var age: Int
    @ObservationTracked var isFavorite: Bool
  
		internal let _$observationRegistrar = ObservationRegistrar<Person>()
    internal func access<Member>(
        keyPath: KeyPath<Person, Member>
    ) {
        _$observationRegistrar.access(self, keyPath: keyPath)
    }
    internal func withMutation<Member, T>(
        keyPath: KeyPath<Person, Member>,
        _ mutation: () throws -> T
    ) rethrows -> T {
        try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
    }
}

18:16 - The @ObservationTracked macro adds getters and setters to stored properties

@Observable final class Person {
    @ObservationTracked var name: String { get { … } set { … } }
    @ObservationTracked var age: Int { get { … } set { … } }
    @ObservationTracked var isFavorite: Bool { get { … } set { … } }
  
		internal let _$observationRegistrar = ObservationRegistrar<Person>()
    internal func access<Member>(
        keyPath: KeyPath<Person, Member>
    ) {
        _$observationRegistrar.access(self, keyPath: keyPath)
    }
    internal func withMutation<Member, T>(
        keyPath: KeyPath<Person, Member>,
        _ mutation: () throws -> T
    ) rethrows -> T {
        try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
    }
}

18:33 - All that Swift code is folded away in the @Observable macro

@Observable final class Person {
    var name: String
    var age: Int
    var isFavorite: Bool
}

23:59 - A wrapper for a file descriptor

struct FileDescriptor {
    private var fd: CInt
  
    init(descriptor: CInt) { self.fd = descriptor }

    func write(buffer: [UInt8]) throws {
        let written = buffer.withUnsafeBufferPointer {
            Darwin.write(fd, $0.baseAddress, $0.count)
        }
        // ...
    }
  
    func close() {
        Darwin.close(fd)
    }
}

24:30 - The same FileDescriptor wrapper as a class

class FileDescriptor {
    private var fd: CInt
  
    init(descriptor: CInt) { self.fd = descriptor }

    func write(buffer: [UInt8]) throws {
        let written = buffer.withUnsafeBufferPointer {
            Darwin.write(fd, $0.baseAddress, $0.count)
        }
        // ...
    }
  
    func close() {
        Darwin.close(fd)
    }
    deinit {
        self.close(fd)
    }
}

25:05 - Going back to the struct

struct FileDescriptor {
    private var fd: CInt
  
    init(descriptor: CInt) { self.fd = descriptor }

    func write(buffer: [UInt8]) throws {
        let written = buffer.withUnsafeBufferPointer {
            Darwin.write(fd, $0.baseAddress, $0.count)
        }
        // ...
    }
  
    func close() {
        Darwin.close(fd)
    }
}

26:06 - Using Copyable in the FileDescriptor struct

struct FileDescriptor: ~Copyable {
    private var fd: CInt
  
    init(descriptor: CInt) { self.fd = descriptor }

    func write(buffer: [UInt8]) throws {
        let written = buffer.withUnsafeBufferPointer {
            Darwin.write(fd, $0.baseAddress, $0.count)
        }
        // ...
    }
  
    func close() {
        Darwin.close(fd)
    }
  
    deinit {
        Darwin.close(fd)
    }
}

26:35 - `close()` can also be marked as consuming

struct FileDescriptor {
    private var fd: CInt
  
    init(descriptor: CInt) { self.fd = descriptor }

    func write(buffer: [UInt8]) throws {
        let written = buffer.withUnsafeBufferPointer {
            Darwin.write(fd, $0.baseAddress, $0.count)
        }
        // ...
    }
  
    consuming func close() {
        Darwin.close(fd)
    }
  
    deinit {
        Darwin.close(fd)
    }
}

26:53 - When `close()` is called, it must be the final use

let file = FileDescriptor(fd: descriptor)
file.write(buffer: data)
file.close()

27:20 - Compiler errors instead of runtime failures

let file = FileDescriptor(fd: descriptor)
file.close() // Compiler will indicate where the consuming use is
file.write(buffer: data) // Compiler error: 'file' used after consuming

28:52 - Using C++ from Swift

// Person.h
struct Person {
    Person(const Person &);
    Person(Person &&);
    Person &operator=(const Person &);
    Person &operator=(Person &&);
    ~Person();
  
    std::string name;
    unsigned getAge() const;
};
std::vector<Person> everyone();

// Client.swift
func greetAdults() {
    for person in everyone().filter { $0.getAge() >= 18 } {
        print("Hello, \(person.name)!")
    }
}

29:51 - Using Swift from C++

// Geometry.swift
struct LabeledPoint {
    var x = 0.0, y = 0.0
    var label: String = “origin”
    mutating func moveBy(x deltaX: Double, y deltaY: Double) { … }
    var magnitude: Double { … }
}

// C++ client
#include <Geometry-Swift.h>

void test() {
    Point origin = Point()
    Point unit = Point::init(1.0, 1.0, “unit”)
    unit.moveBy(2, -2)
    std::cout << unit.label << “ moved to “ << unit.magnitude() << std::endl;
}

35:30 - An actor that manages a database connection

// Custom actor executors

actor MyConnection {
    private var database: UnsafeMutablePointer<sqlite3>
  
    init(filename: String) throws { … }
  
    func pruneOldEntries() { … }
    func fetchEntry<Entry>(named: String, type: Entry.Type) -> Entry? { … }
}

await connection.pruneOldEntries()

35:58 - MyConnection with a serial dispatch queue and a custom executor

actor MyConnection {
  private var database: UnsafeMutablePointer<sqlite3>
  private let queue: DispatchSerialQueue
  
  nonisolated var unownedExecutor: UnownedSerialExecutor { queue.asUnownedSerialExecutor() }

  init(filename: String, queue: DispatchSerialQueue) throws { … }
  
  func pruneOldEntries() { … }
  func fetchEntry<Entry>(named: String, type: Entry.Type) -> Entry? { … }
}

await connection.pruneOldEntries()

36:44 - Dispatch queues conform to SerialExecutor protocol

// Executor protocols

protocol Executor: AnyObject, Sendable {
    func enqueue(_ job: consuming ExecutorJob)
}

protocol SerialExecutor: Executor {
    func asUnownedSerialExecutor() -> UnownedSerialExecutor
    func isSameExclusiveExecutionContext(other executor: Self) -> Bool
}

extension DispatchSerialQueue: SerialExecutor { … }

39:22 - C++ implementation of FoundationDB's "master data" actor

// C++ implementation of FoundationDB’s “master data” actor

ACTOR Future<Void> getVersion(Reference<MasterData> self, GetCommitVersionRequest req) {
  	state std::map<UID, CommitProxyVersionReplies>::iterator proxyItr = self->lastCommitProxyVersionReplies.find(req.requestingProxy);
  	++self->getCommitVersionRequests;

  	if (proxyItr == self->lastCommitProxyVersionReplies.end()) {
      	req.reply.send(Never());
    	  return Void();
  	}
  	wait(proxyItr->second.latestRequestNum.whenAtLeast(req.requestNum - 1));
  
  	auto itr = proxyItr->second.replies.find(req.requestNum);
  	if (itr != proxyItr->second.replies.end()) {
    		req.reply.send(itr->second);
    		return Void();
  	}

  	// ...
}

40:18 - Swift implementation of FoundationDB's "master data" actor

// Swift implementation of FoundationDB’s “master data” actor
func getVersion(
    myself: MasterData, req: GetCommitVersionRequest
) async -> GetCommitVersionReply? {
    myself.getCommitVersionRequests += 1

    guard let lastVersionReplies = lastCommitProxyVersionReplies[req.requestingProxy] else {
        return nil
    }

    // ...
    var latestRequestNum = try await lastVersionReplies.latestRequestNum
          .atLeast(VersionMetricHandle.ValueType(req.requestNum - UInt64(1)))

    if let lastReply = lastVersionReplies.replies[req.requestNum] {
        return lastReply
    }
}

正在查找特定内容？在上方输入一个主题，就能直接跳转到相应的精彩内容。

提交你查询的内容时出现错误。请检查互联网连接，然后再试一次。

章节

资源

相关视频

WWDC23

WWDC21