更新部分内容到 Swift 5.7 (#1200)

* 更新内容到 Swift 5.7 * 更新内容到 Swift 5.7 * 更新内容到 Swift 5.7 * update to Swift version 5.7 * 更新内容到 Swift 5.7 * 更新内容到 Swift 5.7 * 修正部分术语 * 更新内容到 Swift 5.7 * 更新内容到 Swift 5.7 * 标题格式修改 * 修改了部分用词 * 修改了代码块格式 * 修改了代码段及行内代码格式 * 修改了代码段及行内代码样式 * 按照排版要求重新修改了部分格式 * Delete 02_Lexical_Structure.md * Delete 03_Types.md * Delete 04_Expressions.md * Delete 05_Statements.md * Delete 07_Attributes.md * Delete 10_Summary_of_the_Grammar.md * 根据排版指南修改了部分格式 * 根据排版指南修改了部分格式 * Update source/03_language_reference/02_Lexical_Structure.md Co-authored-by: Jie Liang <lj925184928@gmail.com>
2022-09-10 21:00:58 +08:00
parent df35244821
commit 77b5caff91
20 changed files with 1092 additions and 723 deletions
--- a/source/03_language_reference/02_Lexical_Structure.md
+++ b/source/03_language_reference/02_Lexical_Structure.md
--- a/source/03_language_reference/03_Types.md
+++ b/source/03_language_reference/03_Types.md
@ -164,7 +164,9 @@ var operation: (Int, Int) -> Int                // 正确

 如果一个函数类型包涵多个箭头（->），那么函数类型将从右向左进行组合。例如，函数类型 `(Int) -> (Int) -> Int` 可以理解为 `(Int) -> ((Int) -> Int)`，也就是说，该函数传入 `Int`，并返回另一个传入并返回 `Int` 的函数。

-函数类型若要抛出或重抛错误就必须使用 `throws` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数的子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](./06_Declarations.md#throwing-functions-and-methods) 和 [重抛函数与方法](./06_Declarations.md#rethrowing-functions-and-methods)。
+使用函数类型的函数若要抛出或重抛错误就必须使用 `throws` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数的子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](./06_Declarations.md#throwing-functions-and-methods) 和 [重抛函数与方法](./06_Declarations.md#rethrowing-functions-and-methods)。
+
+异步函数的函数类型必须使用 `async` 关键字来标记。 `async` 关键字也是函数类型的一部分，且同步函数是异步函数的子类型。因此，在使用异步函数的地方也可以使用同步函数。异步函数的相关描述见章节 [异步函数和方法](Declarations.xhtml#ID647)。

 ### 对非逃逸闭包的限制 {#Restrictions for Nonescaping Closures}
 当非逃逸闭包函数是形参时，不能存储在属性、变量或任何 `Any` 类型的常量中，因为这可能导致值的逃逸。  
@ -195,7 +197,7 @@ func takesTwoFunctions(first: (Any) -> Void, second: (Any) -> Void) {
 > 

 #### function-type {#function-type}
-> *函数类型* → [特性列表](./07_Attributes.md#attributes)<sub>可选</sub> [函数类型子句](#function-type-argument-clause) **throws**<sub>可选</sub> **->** [类型](#type)
+> *函数类型* → [特性列表](./07_Attributes.md#attributes)<sub>可选</sub> [函数类型子句](#function-type-argument-clause) **async**<sub>可选</sub>**throws**<sub>可选</sub> **->** [类型](#type)

 #### function-type-argument-clause {#function-type-argument-clause}
 > *函数类型子句* → **(**  **)**  
@ -539,7 +541,7 @@ print(type(of: z.f()))
 > 

 #### type-inheritance-list {#type-inheritance-list}
-> *类型继承列表* → [类型标识符](#type-identifier) | [类型标识符](#type-identifier) **,** [类型继承列表](#type-inheritance-list)
+> *类型继承列表* → [属性](./07_Attributes.md#attributes)<sub>可选</sub> [类型标识符](#type-identifier) | [属性](./07_Attributes.md#attributes)<sub>可选</sub>  [类型标识符](#type-identifier) **,** [类型继承列表](#type-inheritance-list)

 ## 类型推断

--- a/source/03_language_reference/04_Expressions.md
+++ b/source/03_language_reference/04_Expressions.md
@ -1,13 +1,13 @@
 # 表达式（Expressions）

-Swift 中存在四种表达式：前缀表达式，二元表达式，基本表达式和后缀表达式。表达式在返回一个值的同时还可以引发副作用。
+Swift 中存在四种表达式：前缀表达式，中缀表达式，基本表达式和后缀表达式。表达式在返回一个值的同时还可以引发副作用。

-通过前缀表达式和二元表达式可以对简单表达式使用各种运算符。基本表达式从概念上讲是最简单的一种表达式，它是一种访问值的方式。后缀表达式则允许你建立复杂的表达式，例如函数调用和成员访问。每种表达式都在下面有详细论述。
+通过前缀表达式和中缀表达式可以对简单表达式使用各种运算符。基本表达式从概念上讲是最简单的一种表达式，它是一种访问值的方式。后缀表达式则允许你建立复杂的表达式，例如函数调用和成员访问。每种表达式都在下面有详细论述。

 > 表达式语法

 #### expression {#expression}
-> *表达式* → [try 运算符](#try-operator)<sub>可选</sub>  [await 运算符](#await-operator)<sub>可选</sub>  [前缀表达式](#prefix-expression) [二元表达式列表](#binary-expressions)<sub>可选</sub>
+> *表达式* → [try 运算符](#try-operator)<sub>可选</sub>  [await 运算符](#await-operator)<sub>可选</sub>  [前缀表达式](#prefix-expression) [中缀表达式列表](#infix-expressions)<sub>可选</sub>

 #### expression-list {#expression-list}

@ -62,7 +62,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表

 强制 try 表达式的返回值是该*表达式*的值。如果该*表达式*抛出了错误，将会引发运行时错误。

-在二元运算符左侧的表达式被标记上 `try`、`try?` 或者 `try!` 时，这个运算符对整个二元表达式都产生作用。也就是说，你可以使用括号来明确运算符的作用范围。
+在中缀运算符左侧的表达式被标记上 `try`、`try?` 或者 `try!` 时，这个运算符对整个中缀表达式都产生作用。也就是说，你可以使用括号来明确运算符的作用范围。

 ```swift
 // try 对两个函数调用都产生作用
@ -75,7 +75,7 @@ sum = try (someThrowingFunction() + anotherThrowingFunction())
 sum = (try someThrowingFunction()) + anotherThrowingFunction() 
 ```

-`try` 表达式不能出现在二元运算符的的右侧，除非二元运算符是赋值运算符或者 `try` 表达式是被圆括号括起来的。
+`try` 表达式不能出现在中缀运算符的的右侧，除非中缀运算符是赋值运算符或者 `try` 表达式是被圆括号括起来的。

 如果表达式中同时包含 `try` 和 `await` 运算符，`try` 运算符必须在前面。

@ -99,7 +99,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction()

 `await` 表达式只能在异步的上下文中出现，比如传入 `async(priority:operation:)` 函数的尾随闭包中。它不能在 `defer` 语句的闭包中，或者在同步函数的自动闭包中出现。

-在二元运算符左侧的表达式被标记上 `await` 运算符时，这个运算符对整个二元表达式都产生作用。也就是说，你可以使用括号来明确运算符的作用范围。
+在中缀运算符左侧的表达式被标记上 `await` 运算符时，这个运算符对整个中缀表达式都产生作用。也就是说，你可以使用括号来明确运算符的作用范围。

 ```swift
 // await 对两个函数调用都产生作用
@ -112,7 +112,7 @@ sum = await (someAsyncFunction() + anotherAsyncFunction())
 sum = (await someAsyncFunction()) + anotherAsyncFunction()
 ```

-`await` 表达式不能出现在二元运算符的的右侧，除非二元运算符是赋值运算符或者 `await` 表达式是被圆括号括起来的。
+`await` 表达式不能出现在中缀运算符的的右侧，除非中缀运算符是赋值运算符或者 `await` 表达式是被圆括号括起来的。

 如果表达式中同时包含 `try` 和 `await` 运算符，`try` 运算符必须在前面。

@ -122,11 +122,11 @@ sum = (await someAsyncFunction()) + anotherAsyncFunction()
 > *await 运算符*  → **await** 


-## 二元表达式 {#binary-expressions}
+## 中缀表达式 {#infix-expressions}

-*二元表达式*由中缀运算符和左右参数表达式组成。形式如下：
+*中缀表达式*由中缀运算符和左右参数表达式组成。形式如下：

-> `左侧参数` `二元运算符` `右侧参数`
+> `左侧参数` `中缀运算符` `右侧参数`

 关于这些运算符的更多信息，请参阅 [基本运算符](../02_language_guide/02_Basic_Operators.md) 和 [高级运算符](../02_language_guide/27_Advanced_Operators.md)。

@ -134,22 +134,22 @@ sum = (await someAsyncFunction()) + anotherAsyncFunction()

 > 注意
 > 
-> 在解析时，一个二元表达式将作为一个扁平列表表示，然后根据运算符的优先级，再进一步进行组合。例如，`2 + 3 * 5` 首先被看作具有五个元素的列表，即 `2`、`+`、`3`、`*`、`5`，随后根据运算符优先级组合为 `(2 + (3 * 5))`。
+> 在解析时，一个中缀表达式将作为一个扁平列表表示，然后根据运算符的优先级，再进一步进行组合。例如，`2 + 3 * 5` 首先被看作具有五个元素的列表，即 `2`、`+`、`3`、`*`、`5`，随后根据运算符优先级组合为 `(2 + (3 * 5))`。


-#### binary-expression {#binary-expression}
-> 二元表达式语法
+#### infix-expression {#infix-expression}
+> 中置表达式语法
 > 
-> *二元表达式* → [二元运算符](./02_Lexical_Structure.md#binary-operator) [前缀表达式](#prefix-expression)
+> *中置表达式* → [中置运算符](./02_Lexical_Structure.md#infix-operator) [前缀表达式](#prefix-expression)
 > 
-> *二元表达式* → [赋值运算符](#assignment-operator) [try 运算符](#try-operator)<sub>可选</sub> [前缀表达式](#prefix-expression)
+> *中置表达式* → [赋值运算符](#assignment-operator) [try 运算符](#try-operator)<sub>可选</sub> [前缀表达式](#prefix-expression)
 > 
-> *二元表达式* → [条件运算符](#conditional-operator) [try 运算符](#try-operator)<sub>可选</sub> [前缀表达式](#prefix-expression)
+> *中置表达式* → [条件运算符](#conditional-operator) [try 运算符](#try-operator)<sub>可选</sub> [前缀表达式](#prefix-expression)
 > 
-> *二元表达式* → [类型转换运算符](#type-casting-operator)
+> *中置表达式* → [类型转换运算符](#type-casting-operator)

-#### binary-expressions {#binary-expressions}
-> *二元表达式列表* → [二元表达式](#binary-expression) [二元表达式列表](#binary-expressions)<sub>可选</sub>
+#### infix-expressions {#infix-expressions}
+> *中置表达式列表* → [中置表达式](#infix-expression) [中置表达式列表](#infix-expressions)<sub>可选</sub>

 ### 赋值表达式 {#assignment-operator}
 赋值表达式会为某个给定的表达式赋值，形式如下；
@ -235,7 +235,7 @@ f(x as Any)
 > *类型转换运算符* → **as** **!** [类型](./03_Types.md#type)

 ## 基本表达式 {#primary-expressions}
-*基本表达式*是最基本的表达式。它们可以单独使用，也可以跟前缀表达式、二元表达式、后缀表达式组合使用。
+*基本表达式*是最基本的表达式。它们可以单独使用，也可以跟前缀表达式、中置表达式、后缀表达式组合使用。

 > 基本表达式语法

@ -461,6 +461,16 @@ struct Point {

 闭包的参数声明形式跟函数一样，请参阅 [函数声明](./06_Declarations.md#function-declaration)。

+在闭包表达式中写入 `throws` 或 `async` 将显式地将闭包标记为丢掷或异步的。
+
+```swift
+{ (parameters) async throws -> return type in
+	statements
+}
+```
+
+如果闭包的主体中含有 try 表达式，则认为该闭包会引发异常。同理，若闭包主体含有 await 表达式，则认为该闭包是异步的。
+
 闭包还有几种特殊的形式，能让闭包使用起来更加简洁：

 - 闭包可以省略它的参数和返回值的类型。如果省略了参数名和所有的类型，也要省略 `in` 关键字。如果被省略的类型无法被编译器推断，那么就会导致编译错误。
@ -555,11 +565,11 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
 >
 > ####  closure-expression {#closure-expression}
 >
-> *闭包表达式* → **{** [闭包签名](#closure-signature)<sub>可选</sub> [语句](#statements) **}**
+> *闭包表达式* → **{** [特性](#attribute)<sub>可选</sub> [闭包签名](#closure-signature)<sub>可选</sub> [语句](#statements) **}**
 >
 > ####  closure-signature {#closure-signature}
 >
-> *闭包签名* → [捕获列表](#capture-list)<sub>可选</sub> [闭包形参子句](#closure-parameter-clause) **throws**<sub>可选</sub> [函数结果](./06_Declarations.md#function-result)<sub>可选</sub> **in** 
+> *闭包签名* → [捕获列表](#capture-list)<sub>可选</sub> [闭包形参子句](#closure-parameter-clause)  **async**<sub>可选</sub> **throws**<sub>可选</sub> [函数结果](./06_Declarations.md#function-result)<sub>可选</sub> **in** 
 >
 > *闭包签名* → [捕获列表](#capture-list) **in**
 >
@ -1255,6 +1265,23 @@ let x = [10, 3, 20, 15, 4]
    .map { $0 * 100 }
 ```

+你可以将这种多行链式语法与编译器控制语句结合，以控制调用每个方法的时间。例如，以下代码在 iOS 上应用了不同的过滤规则：
+
+```swift
+let numbers = [10, 20, 33, 43, 50]
+#if os(iOS)
+.filter { $0 < 40}
+#else
+.filter {$0 > 25}
+#endif
+```
+
+在 `#if`、`#endif` 和其它编译指令之间的条件编译块可以包含一个隐式成员表达式，后跟零个或多个后缀，以形成一个后缀表达式。这些条件编译块还可以包含另一个条件编译块，或者这些表达式和块的组合体。
+
+除了顶级代码（top-level code）以外，你还可以在任何能编写显式成员表达式的地方使用上述语法。
+
+在条件编译块中，编译指令 `#if` 的分支必须包含至少一个表达式，其它分支可以为空。
+
 > 显式成员表达式语法

 #### explicit-member-expression {#explicit-member-expression}
@ -1262,7 +1289,9 @@ let x = [10, 3, 20, 15, 4]
 > 
 > *显式成员表达式* → [后缀表达式](#postfix-expression) **.** [标识符](./02_Lexical_Structure.md#identifier) [泛型实参子句](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub><br/>
 > 
-> *显式成员表达式* → [后缀表达式](#postfix-expression) **.** [标识符](./02_Lexical_Structure.md#identifier) **(** [参数名称](#argument-names) **)**
+> *显式成员表达式* → [后缀表达式](#postfix-expression) **.** [标识符](./02_Lexical_Structure.md#identifier) **(** [参数名称](#argument-names) **)**
+
+> *显示成员表达式* → [后缀表达式](#postfix-expression) [条件编译块](#conditional-compilation-block)

 #### argument-names {#argument-names}
 > *参数名称* → [参数名](#argument-name) [参数名称](#argument-names)<sub>可选</sub><br/>
--- a/source/03_language_reference/05_Statements.md
+++ b/source/03_language_reference/05_Statements.md
@ -105,7 +105,7 @@ while condition {
 > *case 条件* → **case** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)

 #### optional-binding-condition {#optional-binding-condition}
-> *可选绑定条件* →  **let** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) | **var**  [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)
+> *可选绑定条件* →  **let** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)<sub>可选</sub> | **var**  [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)<sub>可选</sub>

 ### Repeat-While 语句 {#repeat-while-statements}
 `repeat-while` 语句至少执行一次代码块，之后只要循环条件为真，就会重复执行代码块。
@ -635,7 +635,7 @@ print("Compiled with the Swift 5 compiler or later in a Swift mode earlier than
 // 打印 "Compiled with the Swift 5 compiler or later in a Swift mode earlier than 5"
 ```

-`canImport()` 条件传入的实参是模块的名字，这个模块可能并不是每个平台上都存在的。使用它可以检测是否可以导入这个模块，但实际上并没有导入。如果模块存在就返回 `true`，否则返回 `false` 。
+`canImport()` 条件传入的实参是模块的名字，这个模块可能并不是每个平台上都存在的。该模块的命名可以包含 `.` 符号。使用它可以检测是否可以导入这个模块，但实际上并没有导入。如果模块存在就返回 `true`，否则返回 `false` 。

 `targetEnvironment()` 条件在特殊环境编译时会返回 `true`，否则返回 `false` 。

@ -663,6 +663,7 @@ statements to compile if both compilation conditions are false
 >
 > 即使没有被编译，上面编译配置中的每个语句仍然会被解析。然而，唯一的例外是编译配置语句中包含 `swift()` 或 `compiler()` 条件：这时仅当编译器版本和语言版本匹配时，语句才会被解析。这种设定能确保旧的编译器不会尝试去解析新 Swift 版本的语法。

+关于在条件编译块中如何包装显式成员表达式，请参见 [显式成员表达式](#Expressions.xhtml#ID400) 章节。

 #### build-config-statement {#build-config-statement}
 > 条件编译代码块语法
@ -821,7 +822,8 @@ if #available(platform name version, ..., *) {

 #### availability-condition {#availability-condition}
 > *可用性条件* → **#available** **(** [可用性参数列表](#availability-arguments) **)**
-
+>
+> *可用性条件* → **#unavaliable** **（** [可用性参数列表](#availability-arguments) **)**
 #### availability-arguments {#availability-arguments}
 > *可用性参数列表* → [可用性参数](#availability-argument) | [可用性参数](#availability-argument) **,** [可用性参数列表](#availability-arguments)

--- a/source/03_language_reference/06_Declarations.md
+++ b/source/03_language_reference/06_Declarations.md
@ -630,6 +630,10 @@ func 函数名称(参数列表) async -> 返回类型 {

 `async` 关键字是函数类型中的一部分。同步函数是异步函数的子类型。所以，你可以在使用异步函数的地方，使用同步函数。同步方法可以重写异步方法，且同步方法可以满足对异步方法的协议要求。

+你可以根据函数是否异步来重写函数。在调用点，上下文决定了应用哪种函数进行重写：异步上下文使用异步函数；同步上下文使用同步函数。
+
+异步方法无法重写同步方法，异步方法也无法满足同步方法的协议要求。反过来说，同步方法可以重写异步方法，并且同步方法可以满足异步方法的协议要求。
+
 ### 永不返回的函数 {#functions-that-never-return}
 Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。

@ -1307,7 +1311,7 @@ convenience init(参数列表) {
 > 如果使用 `required` 声明修饰符标记一个构造器，在子类中重写这种构造器时，无需使用 `override` 修饰符。
 > 

-就像函数和方法，构造器也可以抛出或者重抛错误，你可以在构造器参数列表的圆括号之后使用 `throws` 或 `rethrows` 关键字来表明相应的抛出行为。
+就像函数和方法，构造器也可以抛出或者重抛错误，你可以在构造器参数列表的圆括号之后使用 `throws` 或 `rethrows` 关键字来表明相应的抛出行为。同样，构造器也可以是异步的，你可以使用 `async` 关键字来表明这一点。

 关于在不同类型中声明构造器的例子，请参阅 [构造过程](../02_language_guide/14_Initialization.md)。

@ -1350,7 +1354,6 @@ if let actualInstance = SomeStruct(input: "Hello") {

 更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../02_language_guide/14_Initialization.md#failable-initializers)。

-
 #### grammer-of-an-initializer-declaration {#grammer-of-an-initializer-declaration}
 > 构造器声明语法
 > 
--- a/source/03_language_reference/07_Attributes.md
+++ b/source/03_language_reference/07_Attributes.md
@ -685,6 +685,12 @@ struct ArrayBuilder {

 编译生成可执行程序的 Swift 代码最多只能拥有一个顶级代码入口，请参阅[顶级代码](../03_language_reference/06_Declarations.md#top-level-code)。

+### `unchecked` {#unchecked}
+
+该特性用于协议类型，将其作为已采用协议的类型声明列表的一部分，以关闭该协议要求的强制执行。
+
+仅支持 [Sendable](https://developer.apple.com/documentation/swift/sendable) 协议。
+
 ### `usableFromInline` {#usablefrominline}

 该特性用于函数、方法、计算属性、下标、构造器或析构器的声明，以在同一模块中允许该符号用于内联代码的声明。声明必须具有 `internal` 访问级别修饰符。被标记为 `usableFromInline` 的结构体或类它们属性的类型只能是被标记为 public 或者 `usableFromInline` 的类型。被标记为 `usableFromInline` 的枚举，它 case 的真实值或者关联类型只能是被标记为 public 或者 `usableFromInline` 的类型。
@ -733,6 +739,14 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特

 在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行。这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 特性声明的函数类型中访问属性和方法时需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures)。

+### `Sendable` {#Sendable}
+
+在函数类型上使用该特性以指示该函数是闭包或可发送的。在函数类型上使用该特性与使非函数类型符合 `Sendable` 协议具有相同的意义。
+
+当一个函数或闭包被用在需要可发送值的情况，且该函数或闭包满足可发送的要求，则可以在该函数或闭包上推断此特性。
+
+可发送函数类型是对应的不可发送函数类型的一个子类型。
+
 ## Switch Case 特性 {#switch-case-attributes}

 你只能在 switch cases 语句中使用 switch case 特性。
--- a/source/03_language_reference/10_Summary_of_the_Grammar.md
+++ b/source/03_language_reference/10_Summary_of_the_Grammar.md
@ -7,6 +7,8 @@
 > *空白字符*  → [空白字符项](./02_Lexical_Structure.md#whitespace-item) [空白字符](./02_Lexical_Structure.md#whitespace)<sub>可选</sub>
 >
 > *空白字符项*  → [换行符](./02_Lexical_Structure.md#line-break)
+>
+> *空白字符项* → [内联空间](./02_Lexical_Structure.md#ginline-space)
 >
 > *空白字符项*   → [注释](./02_Lexical_Structure.md#comment)
 >
@ -108,7 +110,7 @@

 > 字面量语法
 >
-> *字面量* → [数值型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串字面量](./02_Lexical_Structure.md#string-literal) | [布尔字面量](./02_Lexical_Structure.md#boolean-literal) | [空字面量](./02_Lexical_Structure.md#nil-literal)
+> *字面量* → [数值型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串字面量](./02_Lexical_Structure.md#string-literal) | [正则表达式字面量](./02_Lexical_Structure.md#regular-expression-literal)  | [布尔字面量](./02_Lexical_Structure.md#boolean-literal) | [空字面量](./02_Lexical_Structure.md#nil-literal)
 >
 > *数值型字面量* → **-**<sub>可选</sub>[整形字面量](./02_Lexical_Structure.md#integer-literal) | **-**<sub>可选</sub>[浮点型字面量](./02_Lexical_Structure.md#floating-point-literal)
 >
@ -243,6 +245,19 @@
 >
 > *转义换行符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) [空白](./02_Lexical_Structure.md#whitespace)<sub>可选</sub> [换行符](./02_Lexical_Structure.md#line-break)

+<!-- -->
+
+> 正则表达式字面量语法
+> 
+> *正则表达式字面量* → [正则表达式字面量开分隔定界符](./02_Lexical_Structure.md#regular-expression-literal-opening-delimiter) [正则表达式](./02_Lexical_Structure.md#regular-expression) [正则表达式字面量闭分隔定界符](./02_Lexical_Structure.md#regular-expression-literal-closing-delimiter)
+> 
+> *正则表达式* → 任何正则表达式
+> 
+> *正则表达式字面量开分隔定界符* → [正则表达式扩展分隔符](./02_Lexical_Structure.md#grammar_extended-regular-expression-literal-delimiter)<sub>可选</sub> **/**
+> 
+> *正则表达式字面量闭分割定界符* → **/** [正则表达式扩展分隔符](./02_Lexical_Structure.md#grammar_extended-regular-expression-literal-delimiter)<sub>可选</sub>
+> 
+> *正则表达式扩展分隔符* → **#** [正则表达式扩展分隔符](./02_Lexical_Structure.md#grammar_extended-regular-expression-literal-delimiter)<sub>可选</sub>

 <!-- -->

@ -329,11 +344,15 @@
 >
 > *类型* → [隐式解析可选类型](./03_Types.md#implicitly-unwrapped-optional-type)
 >
-> *类型* → [协议合成类型](./03_Types.md#protocol-composition-type)
+> *类型* → [协议合成类型](./03_Types.md#protocol-composition-type)
+>
+> *类型* → [隐含类型](./03_Types.md#opaque-type)
+>
+> *类型* → [元类型](./03_Types.md#metatype-type)
 >
-> *类型* → **Any**
+> *类型* → [任意类型](./03_Types.md#any-type)
 >
-> *类型* → **Self**
+> *类型* → [自身类型](./03_Types.md#self-type)
 >
 > *类型* → **（** [type](./03_Types.md#metatype-type) **）**

@ -368,7 +387,7 @@

 > 函数类型语法
 >
-> *函数类型* → [类型](./03_Types.md#type)  **throws**<sub>可选</sub>**->** [类型](./03_Types.md#type)
+> *函数类型* → [类型](./03_Types.md#type) [函数类型子句](.03/Types.md#function-type-argument-clause) **async**<sub>可选</sub> **throws**<sub>可选</sub>**->** [类型](./03_Types.md#type)
 >
 > *函数类型* → [类型](./03_Types.md#)  **rethrows** **->** [类型](./03_Types.md#)
 > 
@ -427,7 +446,7 @@
 >
 > *类型继承从句* → **:** [类型继承集](./03_Types.md#type-inheritance-list)
 >
-> *类型继承集* → [类型标识符](./03_Types.md#type-identifier) | [类型标识符](./03_Types.md#type-identifier) **,** [类型继承集](./03_Types.md#type-inheritance-list)
+> *类型继承集* → [特性](./07_Attributes.md#attributes)<sub>可选</sub> [类型标识符](./03_Types.md#type-identifier) | [特性](./07_Attributes.md#attributes)<sub>可选</sub> [类型标识符](./03_Types.md#type-identifier) **,** [类型继承集](./03_Types.md#type-inheritance-list)
 >
 > *类条件* → **class**

@ -460,17 +479,23 @@

 <!-- -->

-> 二元表达式语法
+> await 表达式语法
+>
+> *await 操作符* → **await**
+
+<!-- -->
+
+> 中缀表达式语法
 >
-> *二元表达式* → [二元运算符](./02_Lexical_Structure.md#binary-operator) [前缀表达式](./04_Expressions.md#prefix-expression)
+> *中缀表达式* → [中缀运算符](./02_Lexical_Structure.md#infix-operator) [前缀表达式](./04_Expressions.md#prefix-expression)
 >
-> *二元表达式* → [赋值操作符](./06_Declarations.md#class-declaration) [try 运算符](./04_Expressions.md#try-operator)<sub>可选</sub> [前缀表达式](./04_Expressions.md#prefix-expression)
+> *中缀表达式* → [赋值操作符](./06_Declarations.md#class-declaration) [try 运算符](./04_Expressions.md#try-operator)<sub>可选</sub> [前缀表达式](./04_Expressions.md#prefix-expression)
 >
-> *二元表达式* → [条件运算符](./04_Expressions.md#conditional-operator) [try 运算符](./04_Expressions.md#try-operator)<sub>可选</sub> [前缀表达式](./04_Expressions.md#prefix-expression)
+> *中缀表达式* → [条件运算符](./04_Expressions.md#conditional-operator) [try 运算符](./04_Expressions.md#try-operator)<sub>可选</sub> [前缀表达式](./04_Expressions.md#prefix-expression)
 >
-> *二元表达式* → [类型转换运算符](./04_Expressions.md#type-casting-operator)
+> *中缀表达式* → [类型转换运算符](./04_Expressions.md#type-casting-operator)
 >
-> *二元表达式* → [二元表达式](./04_Expressions.md#binary-expression) [二元表达式列表](./04_Expressions.md#binary-expressions)<sub>可选</sub>
+> *中缀表达式* → [中缀表达式](./04_Expressions.md#infix-expression) [中缀表达式列表](./04_Expressions.md#infix-expressions)<sub>可选</sub>
 >

 <!-- -->
@ -588,7 +613,7 @@
 > *闭包表达式* → **{** [闭包签名](./04_Expressions.md#closure-signature)<sub>可选</sub> [语句](./04_Expressions.md#statements) **}**
 >
 >
-> 闭包签名* → [参数子句](./04_Expressions.md#parameter-clause) [函数结果](./06_Declarations.md#function-result)<sub>可选</sub> **in**
+> *闭包签名* → [捕获列表](./04_Expressions.md#capture-list) [参数子句](./04_Expressions.md#parameter-clause) **async**<sub>可选</sub> **throws**<sub>可选</sub> [函数结果](./06_Declarations.md#function-result)<sub>可选</sub> **in**
 > 
 > *闭包签名* → [标识符列表](./04_Expressions.md#identifier-list) [函数结果](./06_Declarations.md#function-result)<sub>可选</sub> **in**
 > 
@ -655,7 +680,7 @@
 > *key-path 组件* →  [标识符](./02_Lexical_Structure.md#identifier) [多个 key-path 后缀](./04_Expressions.md#key-path-postfixes)<sub>可选<sub> | [多个 key-path 后缀](./04_Expressions.md#key-path-postfixes)
 > *多个 key-path 后缀* →  [key-path 后缀](./04_Expressions.md#key-path-postfix) [多个 key-path 后缀](./04_Expressions.md#key-path-postfixes)<sub>可选<sub> key-path-postfixes {./04_Expressions.md#key-path-postfixes}
 > 
-> *key-path 后缀* → **?** | **!** | **self** | **\[** [函数调用参数表](./04_Expressions.md#function-call-argument-list) **\]** 
+> *key-path 后缀* → **?** | **!** | **self** | **[** [函数调用参数表](./04_Expressions.md#function-call-argument-list) **]** 
 > 


@ -734,12 +759,14 @@

 > 显式成员表达式语法
 >
-> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [十进制数字]    (02_Lexical_Structure.md#decimal-digit)
+> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [十进制数字](02_Lexical_Structure.md#decimal-digit)
 > 
 > *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符](02_Lexical_Structure.md#identifier) [泛型实参子句](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub><br/>
 > 
-> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符]    (02_Lexical_Structure.md#identifier) **(** [参数名称](./04_Expressions.md#argument-names) **)**
-> 
+> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符](02_Lexical_Structure.md#identifier) **(** [参数名称](./04_Expressions.md#argument-names) **)**
+>
+> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [条件编译块](./05_Statements.md#conditional-compilation-block)
+>
 > *参数名称* → [参数名](./04_Expressions.md#argument-name) [参数名称](./04_Expressions.md#argument-names)<sub>可选</sub><br/>
 > 
 > *参数名* → [标识符](./02_Lexical_Structure.md#identifier) **:**
@ -821,12 +848,13 @@
 >
 > *while 语句* → **while** [条件集](./05_Statements.md#condition-list) [代码块](./06_Declarations.md#code-block)
 >
-> *条件集* → [条件](./05_Statements.md#condition) | [条件](./05_Statements.md#condition) **,** [条件集](./05_Statements.md#condition-list)
+> *条件集* → [条件](./05_Statements.md#condition) | [条件](./05_Statements.md#condition) **,** [条件集](./05_Statements.md#condition-list)
+> 
 > *条件* → [表达式](./04_Expressions.md#expression) | [可用性条件](./05_Statements.md#availability-condition) | [case 条件](./05_Statements.md#case-condition) | [可选绑定条件](./05_Statements.md#optional-binding-condition)
 >
 > *case 条件* → **case** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)
 >
-> *可选绑定条件* → **let** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) | **var** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)
+> *可选绑定条件* → **let** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)<sub>可选</sub> | **var** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)<sub>可选</sub>
 >

 <!-- -->
@ -978,7 +1006,7 @@
 >
 > *catch 子句集* → [catch 子句](./05_Statements.md#catch-clause) [catch 子句集](05_Statements.md#catch-clauses)<sub>可选</sub>
 >
-> *catch 子句* → **catch** [catch 模式列表]()<sub>可选</sub>  [代码块](./06_Declarations.md#code-block)<sub>可选</sub>
+> *catch 子句* → **catch** [catch 模式列表](./05_Statements.md#catch-pattern-list)<sub>可选</sub>  [代码块](./06_Declarations.md#code-block)<sub>可选</sub>
 > 
 > *catch 模式列表* → [catch 模式](./05_Statements.md#catch-pattern) | [catch 模式](./05_Statements.md#catch-pattern) ，[catch 模式列表](./05_Statements.md#catch-pattern-list)
 > 
@ -1120,6 +1148,8 @@
 > *声明* → [结构体声明](./06_Declarations.md#struct-declaration)
 >
 > *声明* → [类声明](./06_Declarations.md#class-declaration)
+>
+> *声明* → [actor 声明](./06_Declarations.md#actor-declaration)
 >
 > *声明* → [协议声明](./06_Declarations.md#protocol-declaration)
 >
@ -1249,10 +1279,10 @@
 >
 > *函数名* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02_Lexical_Structure.md#operator)
 >
-> *函数签名* → [参数子句](./06_Declarations.md#parameter-clause) **throws**<sub>可选</sub> [函数结果](./06_Declarations.md#function-result)<sub>可选</sub>
+> *函数签名* → [参数子句](./06_Declarations.md#parameter-clause) **async**<sub>可选</sub> **throws**<sub>可选</sub> [函数结果](./06_Declarations.md#function-result)<sub>可选</sub>
 >

-> *函数签名* → [参数子句](./06_Declarations.md#parameter-clause) **rethrows** [函数结果](./06_Declarations.md#function-result)<sub>可选</sub>
+> *函数签名* → [参数子句](./06_Declarations.md#parameter-clause) **async**<sub>可选</sub> **rethrows** [函数结果](./06_Declarations.md#function-result)<sub>可选</sub>
 >
 > *函数结果* → **->** [特性](./07_Attributes.md#attributes)<sub>可选</sub> [类型](./03_Types.md#type)
 >
@ -1516,6 +1546,8 @@
 > *声明修饰符* → [访问级别修饰符](./07_Attributes.md#access-level-modifier)
 >
 > *声明修饰符* → [可变性修饰符](./07_Attributes.md#mutation-modifier)
+> 
+> *声明修饰符* → [actor 隔离修饰符](./06_Deeclarations.md#actor-isolation-modifier)
 >
 > *声明修饰符集* → [声明修饰符](./06_Declarations.md#declaration-modifier) [声明修饰符集](./06_Declarations.md#declaration-modifiers)<sub>可选</sub>
 >
@ -1531,6 +1563,8 @@
 >
 > *可变性修饰符* → **mutating** | **nonmutating**
 >  
+> *actor 隔离修饰符* → **nonisolated**
+>

 ## 属性 {#attributes}