andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix chapter 3 relative links

Browse Source
This commit is contained in:
Jie Liang
2019-03-26 23:25:08 -05:00
parent f65cd95306
commit 5fca0fa704
10 changed files with 313 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/chapter3/01_About_the_Language_Reference.md
View File

@ -20,14 +20,14 @@ Swift 语言相对较小，这是由于 Swift 代码中常用的类型、函数
> getter-setter 方法块语法 > getter-setter 方法块语法
> >
> *getter-setter 方法块* → { [*getter 子句*](./05_Declarations.md#getter-clause) [*setter 子句*](./05_Declarations.md#setter-clause)<sub>可选</sub> } | { [*setter 子句*](./05_Declarations.md#setter-clause) [*getter 子句*](./05_Declarations.md#getter-clause) } > *getter-setter 方法块* → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06_Declarations.md#setter-clause)<sub>可选</sub> } | { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06_Declarations.md#getter-clause) }
> >
这个定义表明，一个 getter-setter 方法块可以由一个 getter 分句后跟一个可选的 setter 分句构成，然后用大括号括起来，或者由一个 setter 分句后跟一个 getter 分句构成，然后用大括号括起来。上述的语法产式等价于下面的两个语法产式, ： 这个定义表明，一个 getter-setter 方法块可以由一个 getter 分句后跟一个可选的 setter 分句构成，然后用大括号括起来，或者由一个 setter 分句后跟一个 getter 分句构成，然后用大括号括起来。上述的语法产式等价于下面的两个语法产式, ：
> getter-setter 方法块语法 > getter-setter 方法块语法
> >
> getter-setter 方法块 → { [*getter 子句*](./05_Declarations.md#getter-clause) [*setter 子句*](./05_Declarations.md#setter-clause)<sub>可选</sub> } > getter-setter 方法块 → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06_Declarations.md#setter-clause)<sub>可选</sub> }
> >
> getter-setter 方法块 → { [*setter 子句*](./05_Declarations.md#setter-clause) [*getter 子句*](./05_Declarations.md#getter-clause) } > getter-setter 方法块 → { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06_Declarations.md#getter-clause) }
> >

8
source/chapter3/02_Lexical_Structure.md
View File

@ -52,7 +52,7 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言
> *多行注释内容项* → 任何 Unicode 标量值， 除了 `/*` 或者 `*/` > *多行注释内容项* → 任何 Unicode 标量值， 除了 `/*` 或者 `*/`
> >
注释可以包含额外的格式和标记，正如 [*Markup Formatting Reference*](./https://developer.apple.com/library/prerelease/ios/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.md#//apple_ref/doc/uid/TP40016497) 所述。 注释可以包含额外的格式和标记，正如 [*Markup Formatting Reference*](https://developer.apple.com/library/archive/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html) 所述。
<a id="identifiers"></a> <a id="identifiers"></a>
## 标识符 ## 标识符
@ -374,7 +374,7 @@ true // 布尔值字面量
let x = 3; "1 2 \(x)" let x = 3; "1 2 \(x)"
``` ```
字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.md) 以及 [*字符串结构参考*](./https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_String_Structure/index.md#//apple_ref/doc/uid/TP40015181)。 字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.md) 以及 [*字符串结构参考*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_String_Structure/index.md#//apple_ref/doc/uid/TP40015181)。
用 `＋` 操作符连接的字符型字面量是在编译时进行连接的。比如下面的 `textA` 和 `textB` 是完全一样的，`textA` 没有任何运行时的连接操作。 用 `＋` 操作符连接的字符型字面量是在编译时进行连接的。比如下面的 `textA` 和 `textB` 是完全一样的，`textA` 没有任何运行时的连接操作。
@ -428,7 +428,7 @@ let textB = "Hello world"
<a id="operators"></a> <a id="operators"></a>
## 运算符 ## 运算符
Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/25_Advanced_Operators.md) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。
自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及印刷符号（Dingbats）之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及印刷符号（Dingbats）之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。
@ -454,7 +454,7 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基
在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。 在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。
要学习如何自定义运算符，请参考 [自定义运算符](../chapter2/25_Advanced_Operators.md#custom_operators) 和 [运算符声明](./05_Declarations.md#operator_declaration)。要学习如何重载运算符，请参考 [运算符函数](../chapter2/25_Advanced_Operators.md#operator_functions)。 要学习如何自定义运算符，请参考 [自定义运算符](../chapter2/26_Advanced_Operators.md#custom_operators) 和 [运算符声明](./06_Declarations.md#operator_declaration)。要学习如何重载运算符，请参考 [运算符函数](../chapter2/26_Advanced_Operators.md#operator_functions)。
> 运算符语法 > 运算符语法
> >

16
source/chapter3/03_Types.md
View File

@ -17,7 +17,7 @@
Swift 语言存在两种类型：命名型类型和复合型类型。命名型类型是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类 `MyClass` 的实例拥有类型 `MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。 Swift 语言存在两种类型：命名型类型和复合型类型。命名型类型是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类 `MyClass` 的实例拥有类型 `MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。
那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../chapter2/21_Extensions.md) 和 [扩展声明](./05_Declarations.md#extension_declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。 那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../chapter2/20_Extensions.md) 和 [扩展声明](./06_Declarations.md#extension_declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。
复合型类型是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型 `(Int, (Int, Int))` 包含两个元素：第一个是命名型类型 `Int`，第二个是另一个复合型类型 `(Int, Int)`。 复合型类型是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型 `(Int, (Int, Int))` 包含两个元素：第一个是命名型类型 `Int`，第二个是另一个复合型类型 `(Int, Int)`。
@ -70,7 +70,7 @@ func someFunction(a: Int) { /* ... */ }
> 类型注解语法 > 类型注解语法
> >
<a name="type-annotation"></a> <a name="type-annotation"></a>
> *类型注解* → **:** [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **输入输出参数**<sub>可选</sub> [*类型*](#type) > *类型注解* → **:** [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **输入输出参数**<sub>可选</sub> [*类型*](#type)
> >
<a name="type_identifier"></a> <a name="type_identifier"></a>
@ -96,7 +96,7 @@ var someValue: ExampleModule.MyType
> 类型标识符语法 > 类型标识符语法
> >
<a name="type-identifier"></a> <a name="type-identifier"></a>
> *类型标识符* → [*类型名称*](./#type-name) [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic_argument_clause)<sub>可选</sub> | [*类型名称*](./#type-name) [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic_argument_clause)<sub>可选</sub> **.** [*类型标识符*](#type-identifier) > *类型标识符* → [*类型名称*](#type-name) [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic_argument_clause)<sub>可选</sub> | [*类型名称*](#type-name) [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic_argument_clause)<sub>可选</sub> **.** [*类型标识符*](#type-identifier)
> >
<a name="type-name"></a> <a name="type-name"></a>
> *类型名称* → [*标识符*](./02_Lexical_Structure.md#identifier) > *类型名称* → [*标识符*](./02_Lexical_Structure.md#identifier)
@ -188,7 +188,7 @@ var operation: (Int, Int) -> Int // 正确
如果一个函数类型包涵多个箭头（->），那么函数类型将从右向左进行组合。例如，函数类型 `Int -> Int -> Int` 可以理解为 `Int -> (Int -> Int)`，也就是说，该函数类型的参数为 `Int` 类型，其返回类型是一个参数类型为 `Int`，返回类型为 `Int` 的函数类型。 如果一个函数类型包涵多个箭头（->），那么函数类型将从右向左进行组合。例如，函数类型 `Int -> Int -> Int` 可以理解为 `Int -> (Int -> Int)`，也就是说，该函数类型的参数为 `Int` 类型，其返回类型是一个参数类型为 `Int`，返回类型为 `Int` 的函数类型。
> >
函数类型若要抛出错误就必须使用 `throws` 关键字来标记，若要重抛错误则必须使用 `rethrows` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](./05_Declarations.md#throwing_functions_and_methods) 和 [重抛函数与方法](./05_Declarations.md#rethrowing_functions_and_methods)。 函数类型若要抛出错误就必须使用 `throws` 关键字来标记，若要重抛错误则必须使用 `rethrows` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](./06_Declarations.md#throwing_functions_and_methods) 和 [重抛函数与方法](./06_Declarations.md#rethrowing_functions_and_methods)。
<a name="Restrictions for Nonescaping Closures"></a> <a name="Restrictions for Nonescaping Closures"></a>
### 对非逃逸闭包的限制 ### 对非逃逸闭包的限制
@ -220,9 +220,9 @@ func takesTwoFunctions(first: (Any) -> Void, second: (Any) -> Void) {
> 函数类型语法 > 函数类型语法
> >
<a name="function-type"></a> <a name="function-type"></a>
> *函数类型* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*函数类型子句*](#function-type-argument-clause) **throws**<sub>可选</sub> **->** [*类型*](#type) > *函数类型* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*函数类型子句*](#function-type-argument-clause) **throws**<sub>可选</sub> **->** [*类型*](#type)
> >
> *函数类型* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*函数类型子句*](#function-type-argument-clause) **rethrows­** **->** [*类型*](#type) > *函数类型* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*函数类型子句*](#function-type-argument-clause) **rethrows­** **->** [*类型*](#type)
> >
<a name="function-type-argument-clause"></a> <a name="function-type-argument-clause"></a>
> *函数类型子句* → (­)­ > *函数类型子句* → (­)­
@ -233,7 +233,7 @@ func takesTwoFunctions(first: (Any) -> Void, second: (Any) -> Void) {
> *函数类型参数列表* → [*函数类型参数*](function-type-argument) | [*函数类型参数*](function-type-argument)， [*函数类型参数列表*](#function-type-argument-list) > *函数类型参数列表* → [*函数类型参数*](function-type-argument) | [*函数类型参数*](function-type-argument)， [*函数类型参数列表*](#function-type-argument-list)
> >
<a name="function-type-argument"></a> <a name="function-type-argument"></a>
> *函数类型参数* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **输入输出参数**<sub>可选</sub> [*类型*](#type) | [*参数标签*](#argument-label) [*类型注解*](#type-annotation) > *函数类型参数* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **输入输出参数**<sub>可选</sub> [*类型*](#type) | [*参数标签*](#argument-label) [*类型注解*](#type-annotation)
> >
<a name="argument-label"></a> <a name="argument-label"></a>
> *参数标签* → [*标识符*](./02_Lexical_Structure.md#identifier) > *参数标签* → [*标识符*](./02_Lexical_Structure.md#identifier)
@ -456,7 +456,7 @@ let anotherInstance = metatype.init(string: "some string")
类可以继承单个超类，采纳任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要采纳的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，请参阅 [继承](../chapter2/13_Inheritance.md)。 类可以继承单个超类，采纳任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要采纳的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，请参阅 [继承](../chapter2/13_Inheritance.md)。
其它命名型类型可能只继承或采纳一系列协议。协议类型可以继承自任意数量的其他协议。当一个协议类型继承自其它协议时，其它协议中定义的要求会被整合在一起，然后从当前协议继承的任意类型必须符合所有这些条件。正如在 [协议声明](./05_Declarations.md#protocol_declaration) 中所讨论的那样，可以把 `class` 关键字放到协议类型的类型继承子句的首位，这样就可以声明一个类类型专属协议。 其它命名型类型可能只继承或采纳一系列协议。协议类型可以继承自任意数量的其他协议。当一个协议类型继承自其它协议时，其它协议中定义的要求会被整合在一起，然后从当前协议继承的任意类型必须符合所有这些条件。正如在 [协议声明](./06_Declarations.md#protocol_declaration) 中所讨论的那样，可以把 `class` 关键字放到协议类型的类型继承子句的首位，这样就可以声明一个类类型专属协议。
枚举定义中的类型继承子句可以是一系列协议，或是枚举的原始值类型的命名型类型。在枚举定义中使用类型继承子句来指定原始值类型的例子，请参阅 [原始值](../chapter2/08_Enumerations.md#raw_values)。 枚举定义中的类型继承子句可以是一系列协议，或是枚举的原始值类型的命名型类型。在枚举定义中使用类型继承子句来指定原始值类型的例子，请参阅 [原始值](../chapter2/08_Enumerations.md#raw_values)。

34
source/chapter3/04_Expressions.md
View File

@ -18,9 +18,9 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表
前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数，表达式则紧随其后。 前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数，表达式则紧随其后。
关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/25_Advanced_Operators.md)。 关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md)。
关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Swift Standard Library Operators Reference*](./https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_StandardLibrary_Operators/index.md#//apple_ref/doc/uid/TP40016054)。 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Operators Declarations*](https://developer.apple.com/documentation/swift/swift_standard_library/operator_declarations)。
除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。
@ -67,7 +67,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
`try` 表达式不能出现在二进制运算符的的右侧，除非二进制运算符是赋值运算符或者 `try` 表达式是被圆括号括起来的。 `try` 表达式不能出现在二进制运算符的的右侧，除非二进制运算符是赋值运算符或者 `try` 表达式是被圆括号括起来的。
关于 `try`、`try?` 和 `try!` 的更多信息，以及该如何使用的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.md)。 关于 `try`、`try?` 和 `try!` 的更多信息，以及该如何使用的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md)。
> Try 表达式语法 > Try 表达式语法
> >
<a name="try-operator"></a> <a name="try-operator"></a>
@ -180,13 +180,13 @@ f(x as Any)
// 打印“Function for Any” // 打印“Function for Any”
``` ```
桥接可将 Swift 标准库中的类型（例如 `String`）作为一个与之相关的 Foundation 类型（例如 `NSString`）来使用，而不需要新建一个实例。关于桥接的更多信息，请参阅 [*Using Swift with Cocoa and Objective-C (Swift4.1)*](./https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.md#//apple_ref/doc/uid/TP40014216) 中的 [Working with Cocoa Data Types](./https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/WorkingWithCocoaDataTypes.md#//apple_ref/doc/uid/TP40014216-CH6)。 桥接可将 Swift 标准库中的类型（例如 `String`）作为一个与之相关的 Foundation 类型（例如 `NSString`）来使用，而不需要新建一个实例。关于桥接的更多信息，请参阅 [*Working with Foundation Types*](https://developer.apple.com/documentation/swift/imported_c_and_objective-c_apis/working_with_foundation_types)。
`as?` 运算符有条件地执行类型转换，返回目标类型的可选值。在运行时，如果转换成功，返回的可选值将包含转换后的值，否则返回 `nil`。如果在编译时就能确定转换一定会成功或是失败，则会导致编译报错。 `as?` 运算符有条件地执行类型转换，返回目标类型的可选值。在运行时，如果转换成功，返回的可选值将包含转换后的值，否则返回 `nil`。如果在编译时就能确定转换一定会成功或是失败，则会导致编译报错。
`as!` 运算符执行强制类型转换，返回目标类型的非可选值。如果转换失败，则会导致运行时错误。表达式 `x as! T` 效果等同于 `(x as? T)!`。 `as!` 运算符执行强制类型转换，返回目标类型的非可选值。如果转换失败，则会导致运行时错误。表达式 `x as! T` 效果等同于 `(x as? T)!`。
关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/19_Type_Casting.md)。 关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/18_Type_Casting.md)。
<a name="type-casting-operator"></a> <a name="type-casting-operator"></a>
> 类型转换运算符语法 > 类型转换运算符语法
@ -208,7 +208,7 @@ f(x as Any)
> 基本表达式语法 > 基本表达式语法
> >
<a name="primary-expression"></a> <a name="primary-expression"></a>
> *基本表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型实参子句*](./08_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub> > *基本表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub>
> >
> *基本表达式* → [*字面量表达式*](#literal-expression) > *基本表达式* → [*字面量表达式*](#literal-expression)
> >
@ -427,7 +427,7 @@ struct Point {
} }
``` ```
闭包的参数声明形式跟函数一样，请参阅 [函数声明](./05_Declarations.md#function_declaration)。 闭包的参数声明形式跟函数一样，请参阅 [函数声明](./06_Declarations.md#function_declaration)。
闭包还有几种特殊的形式，能让闭包使用起来更加简洁： 闭包还有几种特殊的形式，能让闭包使用起来更加简洁：
@ -532,13 +532,13 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
> <a name="closure-signature"></a> > <a name="closure-signature"></a>
> >
> >
> 闭包签名* → [*参数子句*](./#parameter-clause) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in** > 闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**
> >
> *闭包签名* → [*标识符列表*](./#identifier-list) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in** > *闭包签名* → [*标识符列表*](#identifier-list) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**
> >
> *闭包签名* → [*捕获列表*](./#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](./05_Declarations.md#function-result)<sub>可选</sub> **in** > *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](./06_Declarations.md#function-result)<sub>可选</sub> **in**
> >
> *闭包签名* → [*捕获列表*](./#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](./05_Declarations.md#function-result)<sub>可选</sub> **in** > *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](./06_Declarations.md#function-result)<sub>可选</sub> **in**
> >
> *闭包签名* → [*捕获列表*](#capture-list) **in** > *闭包签名* → [*捕获列表*](#capture-list) **in**
> >
@ -927,7 +927,7 @@ print(keyPath == c.getSomeKeyPath())
<a name="postfix-expression"></a> <a name="postfix-expression"></a>
> *后缀表达式* → [*基本表达式*](#primary-expression) > *后缀表达式* → [*基本表达式*](#primary-expression)
> >
> *后缀表达式* → [*后缀表达式*](./#postfix-expression) [*后缀运算符*](02_Lexical_Structure.md#postfix-operator) > *后缀表达式* → [*后缀表达式*](#postfix-expression) [*后缀运算符*](02_Lexical_Structure.md#postfix-operator)
> >
> *后缀表达式* → [*函数调用表达式*](#function-call-expression) > *后缀表达式* → [*函数调用表达式*](#function-call-expression)
> >
@ -996,7 +996,7 @@ myData.someMethod {$0 == 13}
> >
> <a name="function-call-argument"></a> > <a name="function-call-argument"></a>
> >
> *函数调用参数* → [表达式](./#expression) | [标识符](02_Lexical_Structure.md#identifier) **:** [*表达式*](#expression) > *函数调用参数* → [表达式](#expression) | [标识符](02_Lexical_Structure.md#identifier) **:** [*表达式*](#expression)
> >
> *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02_Lexical_Structure.md#identifier) **:** [*运算符*](./02_Lexical_Structure.md#operator) > *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02_Lexical_Structure.md#identifier) **:** [*运算符*](./02_Lexical_Structure.md#operator)
> >
@ -1117,11 +1117,11 @@ let x = [10, 3, 20, 15, 4]
> 显式成员表达式语法 > 显式成员表达式语法
> >
<a name="explicit-member-expression"></a> <a name="explicit-member-expression"></a>
> *显式成员表达式* → [*后缀表达式*](./#postfix-expression) **.** [*十进制数字*] (02_Lexical_Structure.md#decimal-digit) > *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*] (02_Lexical_Structure.md#decimal-digit)
> >
> *显式成员表达式* → [*后缀表达式*](./#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](./08_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub><br/> > *显式成员表达式* → [*后缀表达式*](#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) **)**
> >
<a name="argument-names"></a> <a name="argument-names"></a>
> *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)<sub>可选</sub><br/> > *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)<sub>可选</sub><br/>
@ -1161,7 +1161,7 @@ let x = [10, 3, 20, 15, 4]
要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。 要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。
关于下标的声明，请参阅 [协议下标声明](./05_Declarations.md#protocol_subscript_declaration)。 关于下标的声明，请参阅 [协议下标声明](./06_Declarations.md#protocol_subscript_declaration)。
> 下标表达式语法 > 下标表达式语法
> >

35
source/chapter3/05_Statements.md
View File

@ -12,7 +12,7 @@
<a name="statement"></a> <a name="statement"></a>
> *语句* → [*表达式*](./04_Expressions.md#expression) **;**<sub>可选</sub> > *语句* → [*表达式*](./04_Expressions.md#expression) **;**<sub>可选</sub>
> >
> *语句* → [*声明*](./05_Declarations.md#declaration) **;**<sub>可选</sub> > *语句* → [*声明*](./06_Declarations.md#declaration) **;**<sub>可选</sub>
> >
> *语句* → [*循环语句*](#loop-statement) **;**<sub>可选</sub> > *语句* → [*循环语句*](#loop-statement) **;**<sub>可选</sub>
> >
@ -69,7 +69,7 @@ for item in collection {
> >
> >
<a name="for-in-statement"></a> <a name="for-in-statement"></a>
> *for-in 语句* → **for** **case**<sub>可选</sub> [*模式*](./07_Patterns.md#pattern) **in** [*表达式*](./04_Expressions.md#expression) [*where 子句*](./#where-clause)<sub>可选</sub> [*代码块*](05_Declarations.md#code-block) > *for-in 语句* → **for** **case**<sub>可选</sub> [*模式*](./08_Patterns.md#pattern) **in** [*表达式*](./04_Expressions.md#expression) [*where 子句*](#where-clause)<sub>可选</sub> [*代码块*](05_Declarations.md#code-block)
> >
<a name="while_statements"></a> <a name="while_statements"></a>
@ -98,7 +98,7 @@ while condition {
> >
> >
<a name="while-statement"></a> <a name="while-statement"></a>
> *while 语句* → **while** [*条件子句*](./#condition-clause) [*代码块*](05_Declarations.md#code-block) > *while 语句* → **while** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block)
> >
<a name="condition-clause"></a> <a name="condition-clause"></a>
@ -109,10 +109,10 @@ while condition {
> >
> >
<a name="case-condition"></a> <a name="case-condition"></a>
> *case 条件* → **case** [*模式*](./07_Patterns.md#pattern) [*构造器*](./05_Declarations.md#initializer) > *case 条件* → **case** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer)
> >
<a name="optional-binding-condition"></a> <a name="optional-binding-condition"></a>
> *可选绑定条件* → **let** [*模式*](./07_Patterns.md#pattern) [*构造器*](./05_Declarations.md#initializer) | **var** [*模式*](./07_Patterns.md#pattern) [*构造器*](./05_Declarations.md#initializer) > *可选绑定条件* → **let** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) | **var** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer)
> >
<a name="repeat-while_statements"></a> <a name="repeat-while_statements"></a>
@ -141,7 +141,7 @@ repeat {
> >
> >
<a name="repeat-while-statement"></a> <a name="repeat-while-statement"></a>
> *repeat-while 语句* → **repeat** [*代码块*](./05_Declarations.md#code-block) **while** [*表达式*](./04_Expressions.md#expression) > *repeat-while 语句* → **repeat** [*代码块*](./06_Declarations.md#code-block) **while** [*表达式*](./04_Expressions.md#expression)
> >
<a name="branch_statements"></a> <a name="branch_statements"></a>
@ -205,10 +205,10 @@ if condition 1 {
> >
> >
<a name="if-statement"></a> <a name="if-statement"></a>
> *if 语句* → **if** [*条件子句*](./#condition-clause) [*代码块*](05_Declarations.md#code-block) [*else 子句*](#else-clause)<sub>可选</sub> > *if 语句* → **if** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) [*else 子句*](#else-clause)<sub>可选</sub>
> >
<a name="else-clause"></a> <a name="else-clause"></a>
> *else 子句* → **else** [*代码块*](./05_Declarations.md#code-block) | **else** [*if 语句*](#if-statement) > *else 子句* → **else** [*代码块*](./06_Declarations.md#code-block) | **else** [*if 语句*](#if-statement)
> >
<a name="guard_statements"></a> <a name="guard_statements"></a>
@ -235,13 +235,13 @@ guard condition else {
* `continue` * `continue`
* `throw` * `throw`
关于控制转移语句，请参阅 [控制转移语句](./#control_transfer_statements)。关于 `Never` 返回类型的函数，请参阅 [永不返回的函数](05_Declarations.md#rethrowing_functions_and_methods)。 关于控制转移语句，请参阅 [控制转移语句](#control_transfer_statements)。关于 `Never` 返回类型的函数，请参阅 [永不返回的函数](05_Declarations.md#rethrowing_functions_and_methods)。
> guard 语句语法 > guard 语句语法
> >
> >
<a name="guard-statement"></a> <a name="guard-statement"></a>
> *guard 语句* → **guard** [*条件子句*](./#condition-clause) **else** [*代码块*] (05_Declarations.md#code-block) > *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*] (05_Declarations.md#code-block)
> >
<a name="switch_statements"></a> <a name="switch_statements"></a>
@ -285,6 +285,7 @@ case let (x, y) where x == y:
在 Swift 中，`switch` 语句中控制表达式的每一个可能的值都必须至少有一个 `case` 与之对应。在某些无法面面俱到的情况下（例如，表达式的类型是 `Int`），你可以使用 `default` 分支满足该要求。 在 Swift 中，`switch` 语句中控制表达式的每一个可能的值都必须至少有一个 `case` 与之对应。在某些无法面面俱到的情况下（例如，表达式的类型是 `Int`），你可以使用 `default` 分支满足该要求。
<a name="future-case"></a>
#### 对未来枚举的 `case` 进行 `switch` #### 对未来枚举的 `case` 进行 `switch`
非冻结枚举（`nonfronzen enumeration`）是一种特殊的枚举类型，它可能在未来会增加新的枚举 `case`，即使这时候你已经编译并且发布了你的应用，所以在 switch 非冻结枚举前需要深思熟虑。当一个库的作者们把一个枚举标记为非冻结的，这意味着他们保留了增加新的枚举 `case` 的权利，并且任何和这个枚举交互的代码都要在不需要重新编译的条件下能够处理那些未来可能新加入的 `case` 。只有那些标准库，比如用 Swift 实现的苹果的一些框架，C 以及 Objective-C 代码才能够声明非冻结枚举。你在 Swift 中声明的枚举不能是非冻结的。 非冻结枚举（`nonfronzen enumeration`）是一种特殊的枚举类型，它可能在未来会增加新的枚举 `case`，即使这时候你已经编译并且发布了你的应用，所以在 switch 非冻结枚举前需要深思熟虑。当一个库的作者们把一个枚举标记为非冻结的，这意味着他们保留了增加新的枚举 `case` 的权利，并且任何和这个枚举交互的代码都要在不需要重新编译的条件下能够处理那些未来可能新加入的 `case` 。只有那些标准库，比如用 Swift 实现的苹果的一些框架，C 以及 Objective-C 代码才能够声明非冻结枚举。你在 Swift 中声明的枚举不能是非冻结的。
@ -329,7 +330,7 @@ case .suppressed:
> *case 标签* → [*属性*](#switch-case-attributes-label)<sub>可选</sub> **case** [*case 项列表*](#case-item-list) **:** > *case 标签* → [*属性*](#switch-case-attributes-label)<sub>可选</sub> **case** [*case 项列表*](#case-item-list) **:**
> >
<a name="case-item-list"></a> <a name="case-item-list"></a>
> *case 项列表* → [*模式*](./07_Patterns.md#pattern) [*where 子句*](./#where-clause)<sub>可选</sub> | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)<sub>可选</sub> **,** [*case 项列表*](#case-item-list) > *case 项列表* → [*模式*](./08_Patterns.md#pattern) [*where 子句*](#where-clause)<sub>可选</sub> | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)<sub>可选</sub> **,** [*case 项列表*](#case-item-list)
> >
<a name="default-label"></a> <a name="default-label"></a>
> *default 标签* → [*属性*](#switch-case-attributes-label)<sub>可选</sub> **default** **:** > *default 标签* → [*属性*](#switch-case-attributes-label)<sub>可选</sub> **default** **:**
@ -491,7 +492,7 @@ case .suppressed:
> 注意 > 注意
> >
> >
> 正如 [可失败构造器](./05_Declarations.md#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 > 正如 [可失败构造器](./06_Declarations.md#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。
> >
而只写 `return` 时，仅仅是从该函数或方法中返回，而不返回任何值（也就是说，函数或方法的返回类型为 `Void` 或者说 `()`）。 而只写 `return` 时，仅仅是从该函数或方法中返回，而不返回任何值（也就是说，函数或方法的返回类型为 `Void` 或者说 `()`）。
@ -517,7 +518,7 @@ case .suppressed:
表达式的结果必须符合 `ErrorType` 协议。 表达式的结果必须符合 `ErrorType` 协议。
关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../chapter2/18_Error_Handling.md#propagating_errors_using_throwing_functions)。 关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../chapter2/17_Error_Handling.md#propagating_errors_using_throwing_functions)。
> throw 语句语法 > throw 语句语法
> >
@ -561,7 +562,7 @@ f()
> >
> >
<a name="defer-statement"></a> <a name="defer-statement"></a>
> *延迟语句* → **defer** [*代码块*](./05_Declarations.md#code-block) > *延迟语句* → **defer** [*代码块*](./06_Declarations.md#code-block)
> >
<a name="do_statements"></a> <a name="do_statements"></a>
@ -586,7 +587,7 @@ do {
如同 `switch` 语句，编译器会判断 `catch` 子句是否有遗漏。如果 `catch` 子句没有遗漏，则认为错误已被处理。否则，错误会自动传递到外围作用域，被某个 `catch` 子句处理掉或者被用 `throws` 关键字声明的抛出函数继续向外抛出。 如同 `switch` 语句，编译器会判断 `catch` 子句是否有遗漏。如果 `catch` 子句没有遗漏，则认为错误已被处理。否则，错误会自动传递到外围作用域，被某个 `catch` 子句处理掉或者被用 `throws` 关键字声明的抛出函数继续向外抛出。
为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](./07_Patterns.md)。 为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](./08_Patterns.md)。
关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md#handling_errors)。 关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md#handling_errors)。
@ -594,13 +595,13 @@ do {
> >
> >
<a name="do-statement"></a> <a name="do-statement"></a>
> *do 语句* → **do** [*代码块*](./05_Declarations.md#code-block) [*多条 catch 子句*](#catch-clauses)<sub>可选</sub> > *do 语句* → **do** [*代码块*](./06_Declarations.md#code-block) [*多条 catch 子句*](#catch-clauses)<sub>可选</sub>
> >
<a name="catch-clauses"></a> <a name="catch-clauses"></a>
> *多条 catch 子句* → [*catch 子句*](#catch-clause) [*多条 catch 子句*](#catch-clauses)<sub>可选</sub> > *多条 catch 子句* → [*catch 子句*](#catch-clause) [*多条 catch 子句*](#catch-clauses)<sub>可选</sub>
> >
<a name="catch-clause"></a> <a name="catch-clause"></a>
> *catch 子句* → **catch** [*模式*](./07_Patterns.md#pattern)<sub>可选</sub> [*where 子句*](./#where-clause)<sub>可选</sub> [*代码块*](05_Declarations.md#code-block) > *catch 子句* → **catch** [*模式*](./08_Patterns.md#pattern)<sub>可选</sub> [*where 子句*](#where-clause)<sub>可选</sub> [*代码块*](05_Declarations.md#code-block)
> >
<a name="compiler_control_statements"></a> <a name="compiler_control_statements"></a>

148
source/chapter3/06_Declarations.md
View File

@ -50,7 +50,7 @@ Swift 的源文件中的顶级代码（top-level code）由零个或多个语句
> 顶级声明语法 > 顶级声明语法
> >
> *顶级声明* → [*多条语句*](./10_Statements.md#statements)<sub>可选</sub> > *顶级声明* → [*多条语句*](./05_Statements.md#statements)<sub>可选</sub>
> >
<a name="code_blocks"></a> <a name="code_blocks"></a>
@ -70,7 +70,7 @@ Swift 的源文件中的顶级代码（top-level code）由零个或多个语句
> >
> <a name="code-block"></a> > <a name="code-block"></a>
> >
> *代码块* → **{** [*多条语句*](./10_Statements.md#statements)<sub>可选</sub> **}** > *代码块* → **{** [*多条语句*](./05_Statements.md#statements)<sub>可选</sub> **}**
> >
<a name="import_declaration"></a> <a name="import_declaration"></a>
@ -94,7 +94,7 @@ import 模块.子模块
> >
> <a name="import-declaration"></a> > <a name="import-declaration"></a>
> >
> *导入声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **import** [*导入类型*](#import-kind)<sub>可选</sub> [*导入路径*](#import-path) > *导入声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **import** [*导入类型*](#import-kind)<sub>可选</sub> [*导入路径*](#import-path)
> >
> <a name="import-kind"></a> > <a name="import-kind"></a>
> >
@ -148,7 +148,7 @@ print("The second number is \(secondNumber).")
> >
> <a name="constant-declaration"></a> > <a name="constant-declaration"></a>
> >
> *常量声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **let** [*模式构造器列表*](pattern-initializer-list) > *常量声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **let** [*模式构造器列表*](pattern-initializer-list)
> >
> <a name="pattern-initializer-list"></a> > <a name="pattern-initializer-list"></a>
> >
@ -156,7 +156,7 @@ print("The second number is \(secondNumber).")
> >
> <a name="pattern-initializer"></a> > <a name="pattern-initializer"></a>
> >
> *模式构造器* → [*模式*](./07_Patterns.md#pattern) [*构造器*](#initializer)<sub>可选</sub> > *模式构造器* → [*模式*](./08_Patterns.md#pattern) [*构造器*](#initializer)<sub>可选</sub>
> >
> <a name="initializer"></a> > <a name="initializer"></a>
> >
@ -270,19 +270,19 @@ var 变量名称: 类型 = 表达式 {
<a name="variable-declaration"></a> <a name="variable-declaration"></a>
> *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list) > *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list)
> >
> *变量声明* → [*变量声明头*](./#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*代码块*](#code-block) > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*代码块*](#code-block)
> >
> *变量声明* → [*变量声明头*](./#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 代码块*](#getter-setter-block) > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 代码块*](#getter-setter-block)
> >
> *变量声明* → [*变量声明头*](./#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block)
> >
> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet 代码块*](#willSet-didSet-block) > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet 代码块*](#willSet-didSet-block)
> >
> *变量声明* → [*变量声明头*](./#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*构造器*](#initializer)<sub>可选</sub> [*willSet-didSet 代码块*](#willSet-didSet-block) > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*构造器*](#initializer)<sub>可选</sub> [*willSet-didSet 代码块*](#willSet-didSet-block)
> >
<a name="variable-declaration-head"></a> <a name="variable-declaration-head"></a>
> *变量声明头* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **var** > *变量声明头* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **var**
> >
> <a name="variable-name"></a> > <a name="variable-name"></a>
> >
@ -298,11 +298,11 @@ var 变量名称: 类型 = 表达式 {
> >
> <a name="getter-clause"></a> > <a name="getter-clause"></a>
> >
> *getter 子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **get** [*代码块*](#code-block) > *getter 子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **get** [*代码块*](#code-block)
> >
> <a name="setter-clause"></a> > <a name="setter-clause"></a>
> >
> *setter 子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **set** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block) > *setter 子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **set** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block)
> >
> <a name="setter-name"></a> > <a name="setter-name"></a>
> >
@ -316,11 +316,11 @@ var 变量名称: 类型 = 表达式 {
> >
> <a name="getter-keyword-clause"></a> > <a name="getter-keyword-clause"></a>
> >
> *getter 关键字子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **get** > *getter 关键字子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **get**
> >
> <a name="setter-keyword-clause"></a> > <a name="setter-keyword-clause"></a>
> >
> *setter 关键字子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **set** > *setter 关键字子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **set**
> >
<a name="willSet-didSet-block"></a> <a name="willSet-didSet-block"></a>
@ -330,11 +330,11 @@ var 变量名称: 类型 = 表达式 {
> >
> <a name="willSet-clause"></a> > <a name="willSet-clause"></a>
> >
> *willSet 子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **willSet** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block) > *willSet 子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **willSet** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block)
> >
> <a name="didSet-clause"></a> > <a name="didSet-clause"></a>
> >
> *didSet 子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **didSet** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block) > *didSet 子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **didSet** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block)
> >
<a name="type_alias_declaration"></a> <a name="type_alias_declaration"></a>
@ -400,7 +400,7 @@ func sum<T: Sequence>(_ sequence: T) -> Int where T.Element == Int {
> >
> <a name="typealias-declaration"></a> > <a name="typealias-declaration"></a>
> >
> *类型别名声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> **typealias** [*类型别名名称*](#typealias-name) [*类型别子句*](#typealias-clause) [*类型别名赋值*](#typealias-assignment) > *类型别名声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> **typealias** [*类型别名名称*](#typealias-name) [*类型别子句*](#typealias-clause) [*类型别名赋值*](#typealias-assignment)
> >
> <a name="typealias-name"></a> > <a name="typealias-name"></a>
> >
@ -607,7 +607,7 @@ func someFunction(callback: () throws -> Void) rethrows {
Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。 Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。
不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在[*Guard 语句*](./10_Statements.md#guard_statements)。 不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在[*Guard 语句*](./05_Statements.md#guard_statements)。
你可以重写一个不归方法，但是新的方法必须保持原有的返回类型和没有返回的行为。 你可以重写一个不归方法，但是新的方法必须保持原有的返回类型和没有返回的行为。
@ -615,11 +615,11 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
> 函数声明语法 > 函数声明语法
> >
<a name="function-declaration"></a> <a name="function-declaration"></a>
> *函数声明* → [*函数头*](./#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*函数签名*](./#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause) [*函数体*](#function-body)<sub>可选</sub> > *函数声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*函数签名*](#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause) [*函数体*](#function-body)<sub>可选</sub>
> >
<a name="function-head"></a> <a name="function-head"></a>
> *函数头* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **func** > *函数头* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **func**
> >
> <a name="function-name"></a> > <a name="function-name"></a>
> >
@ -635,7 +635,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
> >
> <a name="function-result"></a> > <a name="function-result"></a>
> >
> *函数结果* → **->** [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*类型*](./03_Types.md#type) > *函数结果* → **->** [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*类型*](./03_Types.md#type)
> >
> <a name="function-body"></a> > <a name="function-body"></a>
> >
@ -652,11 +652,11 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
> >
> <a name="parameter"></a> > <a name="parameter"></a>
> >
> *参数* → [*外部参数名*](./#external-parameter-name)<sub>可选</sub> [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)<sub>可选</sub> > *参数* → [*外部参数名*](#external-parameter-name)<sub>可选</sub> [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)<sub>可选</sub>
> >
> *参数* → [*外部参数名*](./#external-parameter-name)<sub>可选</sub> [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) > *参数* → [*外部参数名*](#external-parameter-name)<sub>可选</sub> [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation)
> >
> *参数* → [*外部参数名*](./#external-parameter-name)<sub>可选</sub> [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) **...** > *参数* → [*外部参数名*](#external-parameter-name)<sub>可选</sub> [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) **...**
> >
> <a name="external-parameter-name"></a> > <a name="external-parameter-name"></a>
> >
@ -683,7 +683,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
不同于类或者结构体，枚举类型并不隐式提供默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例赋值给 `self` 后才算完成。 不同于类或者结构体，枚举类型并不隐式提供默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例赋值给 `self` 后才算完成。
和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。
可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。 可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。
@ -781,7 +781,7 @@ enum GamePlayMode: String {
使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../chapter2/08_Enumerations.md#enumeration_syntax) 和 [显式成员表达式](./04_Expressions.md#explicit_member_expression) 所述。 使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../chapter2/08_Enumerations.md#enumeration_syntax) 和 [显式成员表达式](./04_Expressions.md#explicit_member_expression) 所述。
可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../chapter2/08_Enumerations.md#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./07_Patterns.md#enumeration_case_pattern) 所述。 可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../chapter2/08_Enumerations.md#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./08_Patterns.md#enumeration_case_pattern) 所述。
<a name="grammer_of_an_enumeration_declaration"></a> <a name="grammer_of_an_enumeration_declaration"></a>
> 枚举声明语法 > 枚举声明语法
@ -789,12 +789,12 @@ enum GamePlayMode: String {
> >
> <a name="enum-declaration"></a> > <a name="enum-declaration"></a>
> >
> *枚举声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> [*联合风格枚举*](#union-style-enum) > *枚举声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> [*联合风格枚举*](#union-style-enum)
> >
> *枚举声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier) <sub>可选</sub> [*原始值风格枚举*](#raw-value-style-enum) > *枚举声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier) <sub>可选</sub> [*原始值风格枚举*](#raw-value-style-enum)
> >
> >
> *联合风格枚举* → **indirect**<sub>可选</sub> **enum** [*枚举名称*](./#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [类型继承子句](./03_Types.md#type-inheritance-clause)<sub>可选</sub> **{** [*多个联合风格枚举成员*](#union-style-enum-members)<sub>可选</sub> **}** > *联合风格枚举* → **indirect**<sub>可选</sub> **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [类型继承子句](./03_Types.md#type-inheritance-clause)<sub>可选</sub> **{** [*多个联合风格枚举成员*](#union-style-enum-members)<sub>可选</sub> **}**
> >
> <a name="union-style-enum-members"></a> > <a name="union-style-enum-members"></a>
> >
@ -802,11 +802,11 @@ enum GamePlayMode: String {
> >
> <a name="union-style-enum-member"></a> > <a name="union-style-enum-member"></a>
> >
> *联合风格枚举成员* → [*声明*](./#declaration) | [*联合风格枚举用例子句*](#union-style-enum-case-clause) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) > *联合风格枚举成员* → [*声明*](#declaration) | [*联合风格枚举用例子句*](#union-style-enum-case-clause) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
> >
> <a name="union-style-enum-case-clause"></a> > <a name="union-style-enum-case-clause"></a>
> >
> *联合风格枚举用例子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **indirect**<sub>可选</sub> **case** [*联合风格枚举用例列表*](#union-style-enum-case-list) > *联合风格枚举用例子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **indirect**<sub>可选</sub> **case** [*联合风格枚举用例列表*](#union-style-enum-case-list)
> >
> <a name="union-style-enum-case-list"></a> > <a name="union-style-enum-case-list"></a>
> >
@ -814,7 +814,7 @@ enum GamePlayMode: String {
> >
> <a name="union-style-enum-case"></a> > <a name="union-style-enum-case"></a>
> >
> *联合风格枚举用例* → [*枚举用例名称*](./#enum-case-name) [*元组类型*](03_Types.md#tuple-type)<sub>可选</sub> > *联合风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*元组类型*](03_Types.md#tuple-type)<sub>可选</sub>
> >
> <a name="enum-name"></a> > <a name="enum-name"></a>
> >
@ -828,7 +828,7 @@ enum GamePlayMode: String {
> <a name="raw-value-style-enum"></a> > <a name="raw-value-style-enum"></a>
> >
> >
> *原始值风格枚举* → **enum** [*枚举名称*](./#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause) [*泛型 where 子句*](./08_Generic_Parameters_and_Arguments.md#generic-where-clause) **{** [*多个原始值风格枚举成员*](#raw-value-style-enum-members) **}** > *原始值风格枚举* → **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause) [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause) **{** [*多个原始值风格枚举成员*](#raw-value-style-enum-members) **}**
> >
> <a name="raw-value-style-enum-members"></a> > <a name="raw-value-style-enum-members"></a>
> >
@ -836,11 +836,11 @@ enum GamePlayMode: String {
> >
> <a name="raw-value-style-enum-member"></a> > <a name="raw-value-style-enum-member"></a>
> >
> *原始值风格枚举成员* → [*声明*](./#declaration) | [*原始值风格枚举用例子句*](#raw-value-style-enum-case-clause) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) > *原始值风格枚举成员* → [*声明*](#declaration) | [*原始值风格枚举用例子句*](#raw-value-style-enum-case-clause) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
> >
> <a name="raw-value-style-enum-case-clause"></a> > <a name="raw-value-style-enum-case-clause"></a>
> >
> *原始值风格枚举用例子句* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **case** [*原始值风格枚举用例列表*](#raw-value-style-enum-case-list) > *原始值风格枚举用例子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **case** [*原始值风格枚举用例列表*](#raw-value-style-enum-case-list)
> >
> <a name="raw-value-style-enum-case-list"></a> > <a name="raw-value-style-enum-case-list"></a>
> >
@ -870,7 +870,7 @@ struct 结构体名称: 采纳的协议 {
} }
``` ```
结构体内可包含零个或多个声明。这些声明可以包括存储型和计算型属性、类型属性、实例方法、类型方法、构造器、下标、类型别名，甚至其他结构体、类、和枚举声明。结构体声明不能包含析构器或者协议声明。关于结构体的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Classes_and_Structures.md)。 结构体内可包含零个或多个声明。这些声明可以包括存储型和计算型属性、类型属性、实例方法、类型方法、构造器、下标、类型别名，甚至其他结构体、类、和枚举声明。结构体声明不能包含析构器或者协议声明。关于结构体的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Structures_And_Classes.md)。
结构体可以采纳任意数量的协议，但是不能继承自类、枚举或者其他结构体。 结构体可以采纳任意数量的协议，但是不能继承自类、枚举或者其他结构体。
@ -884,10 +884,10 @@ struct 结构体名称: 采纳的协议 {
结构体的构造过程请参阅 [构造过程](../chapter2/14_Initialization.md)。 结构体的构造过程请参阅 [构造过程](../chapter2/14_Initialization.md)。
结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../chapter2/09_Classes_and_Structures.md#accessing_properties) 所述。 结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../chapter2/09_Structures_And_Classes.md#accessing_properties) 所述。
结构体是值类型。结构体的实例在被赋予变量或常量，或传递给函数作为参数时会被复制。关于值类型的更多信息，请参阅 结构体是值类型。结构体的实例在被赋予变量或常量，或传递给函数作为参数时会被复制。关于值类型的更多信息，请参阅
[结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 [结构体和枚举是值类型](../chapter2/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。
可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。 可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。
@ -897,7 +897,7 @@ struct 结构体名称: 采纳的协议 {
> >
> <a name="struct-declaration"></a> > <a name="struct-declaration"></a>
> >
> *结构体声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](./#access-level-modifier) <sub>可选</sub> **struct** [*结构体名称*](#struct-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*结构体主体*](#struct-body) > *结构体声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier) <sub>可选</sub> **struct** [*结构体名称*](#struct-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*结构体主体*](#struct-body)
> >
> <a name="struct-name"></a> > <a name="struct-name"></a>
> >
@ -914,7 +914,7 @@ struct 结构体名称: 采纳的协议 {
> >
> <a name="struct-member"></a> > <a name="struct-member"></a>
> >
> *结构体成员* → [*声明*](./#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) > *结构体成员* → [*声明*](#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
> >
<a name="class_declaration"></a> <a name="class_declaration"></a>
@ -929,7 +929,7 @@ class 类名: 超类, 采纳的协议 {
} }
``` ```
类内可以包含零个或多个声明。这些声明可以包括存储型和计算型属性、实例方法、类型方法、构造器、唯一的析构器、下标、类型别名，甚至其他结构体、类和枚举声明。类声明不能包含协议声明。关于类的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Classes_and_Structures.md)。 类内可以包含零个或多个声明。这些声明可以包括存储型和计算型属性、实例方法、类型方法、构造器、唯一的析构器、下标、类型别名，甚至其他结构体、类和枚举声明。类声明不能包含协议声明。关于类的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Structures_And_Classes.md)。
一个类只能继承自一个超类，但是可以采纳任意数量的协议。超类紧跟在类名和冒号后面，其后跟着采纳的协议。泛型类可以继承自其它泛型类和非泛型类，但是非泛型类只能继承自其它非泛型类。当在冒号后面写泛型超类的名称时，必须写上泛型类的全名，包括它的泛型形参子句。 一个类只能继承自一个超类，但是可以采纳任意数量的协议。超类紧跟在类名和冒号后面，其后跟着采纳的协议。泛型类可以继承自其它泛型类和非泛型类，但是非泛型类只能继承自其它非泛型类。当在冒号后面写泛型超类的名称时，必须写上泛型类的全名，包括它的泛型形参子句。
@ -947,9 +947,9 @@ class 类名: 超类, 采纳的协议 {
* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../chapter2/14_Initialization.md#default_initializers)。 * 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../chapter2/14_Initialization.md#default_initializers)。
类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../chapter2/09_Classes_and_Structures.md#accessing_properties)。 类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../chapter2/09_Structures_And_Classes.md#accessing_properties)。
类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。
可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。 可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。
@ -959,9 +959,9 @@ class 类名: 超类, 采纳的协议 {
> >
> <a name="class-declaration"></a> > <a name="class-declaration"></a>
> >
> *类声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [访问级别修饰符](./#access-level-modifier)<sub>可选</sub> **final**<sub>可选</sub> **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*类主体*](#class-body) > *类声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [访问级别修饰符](#access-level-modifier)<sub>可选</sub> **final**<sub>可选</sub> **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*类主体*](#class-body)
> >
> *类声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **final** [访问级别修饰符](./#access-level-modifier)<sub>可选</sub> **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*类主体*](#class-body) > *类声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **final** [访问级别修饰符](#access-level-modifier)<sub>可选</sub> **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*类型继承子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*类主体*](#class-body)
> >
> <a name="class-name"></a> > <a name="class-name"></a>
> >
@ -976,7 +976,7 @@ class 类名: 超类, 采纳的协议 {
> >
> <a name="class-member"></a> > <a name="class-member"></a>
> >
> *类成员* → [*声明*](./#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) > *类成员* → [*声明*](#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
> >
<a name="protocol_declaration"></a> <a name="protocol_declaration"></a>
@ -1028,7 +1028,7 @@ protocol SomeProtocol: AnyObject {
> >
> <a name="protocol-declaration"></a> > <a name="protocol-declaration"></a>
> >
> *协议声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](./#access-level-modifier)<sub>可选</sub> **protocol** [*协议名称*](#protocol-name) [*类型继承子句*](03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*协议主体*](#protocol-body) > *协议声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> **protocol** [*协议名称*](#protocol-name) [*类型继承子句*](03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*协议主体*](#protocol-body)
> >
> <a name="protocol-name"></a> > <a name="protocol-name"></a>
> >
@ -1043,7 +1043,7 @@ protocol SomeProtocol: AnyObject {
> >
> <a name="protocol-member"></a> > <a name="protocol-member"></a>
> >
> *协议成员* → [*协议成员声明*](./#protocol-member-declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) > *协议成员* → [*协议成员声明*](#protocol-member-declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
> >
> >
> <a name="protocol-member-declaration"></a> > <a name="protocol-member-declaration"></a>
@ -1083,7 +1083,7 @@ var 属性名: 类型 { get set }
> >
> <a name="protocol-property-declaration"></a> > <a name="protocol-property-declaration"></a>
> >
> *协议属性声明* → [*变量声明头*](./#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > *协议属性声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block)
> >
<a name="protocol_method_declaration"></a> <a name="protocol_method_declaration"></a>
@ -1100,7 +1100,7 @@ var 属性名: 类型 { get set }
> >
> <a name="protocol-method-declaration"></a> > <a name="protocol-method-declaration"></a>
> >
> *协议方法声明* → [*函数头*](./#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*函数签名*](./#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> > *协议方法声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*函数签名*](#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
> >
<a name="protocol_initializer_declaration"></a> <a name="protocol_initializer_declaration"></a>
@ -1121,9 +1121,9 @@ var 属性名: 类型 { get set }
> >
> <a name="protocol-initializer-declaration"></a> > <a name="protocol-initializer-declaration"></a>
> >
> *协议构造器声明* → [*构造器头*](./#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](./#parameter-clause) **throws**<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> > *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause) **throws**<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
> >
> *协议构造器声明* → [*构造器头*](./#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](./#parameter-clause) **rethrows** [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> > *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause) **rethrows** [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
> >
<a name="protocol_subscript_declaration"></a> <a name="protocol_subscript_declaration"></a>
@ -1145,7 +1145,7 @@ subscript (参数列表) -> 返回类型 { get set }
> >
> <a name="protocol-subscript-declaration"></a> > <a name="protocol-subscript-declaration"></a>
> >
> *协议下标声明* → [*下标头*](./#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > *协议下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 关键字代码块*](#getter-setter-keyword-block)
> >
<a name="protocol_associated_type_declaration"></a> <a name="protocol_associated_type_declaration"></a>
@ -1179,7 +1179,7 @@ protocol SubProtocolB: SomeProtocol where SomeType: Equatable { }
> >
> <a name="protocol-associated-type-declaration"></a> > <a name="protocol-associated-type-declaration"></a>
> >
> *协议关联类型声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](./#access-level-modifier)<sub>可选</sub> **associatedtype** [*类型别名头*](#typealias-head) [*类型继承子句*](03_Types.md#type-inheritance-clause)<sub>可选</sub> [*类型别名赋值*](./#typealias-assignment)<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> > *协议关联类型声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> **associatedtype** [*类型别名头*](#typealias-head) [*类型继承子句*](03_Types.md#type-inheritance-clause)<sub>可选</sub> [*类型别名赋值*](#typealias-assignment)<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
> >
<a name="initializer_declaration"></a> <a name="initializer_declaration"></a>
@ -1274,17 +1274,17 @@ if let actualInstance = SomeStruct(input: "Hello") {
> >
> <a name="initializer-declaration"></a> > <a name="initializer-declaration"></a>
> >
> *构造器声明* → [*构造器头*](./#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](./#parameter-clause) **throws**<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*构造器主体*](#initializer-body) > *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause) **throws**<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*构造器主体*](#initializer-body)
> >
> *构造器声明* → [*构造器头*](./#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](./#parameter-clause) **rethrows**<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*构造器主体*](#initializer-body) > *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause) **rethrows**<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*构造器主体*](#initializer-body)
> >
> <a name="initializer-head"></a> > <a name="initializer-head"></a>
> >
> *构造器头* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **init** > *构造器头* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **init**
> >
> *构造器头* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **init** **?** > *构造器头* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **init** **?**
> >
> *构造器头* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **init** **!** > *构造器头* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **init** **!**
> >
> <a name="initializer-body"></a> > <a name="initializer-body"></a>
> >
@ -1315,7 +1315,7 @@ deinit {
> >
> <a name="deinitializer-declaration"></a> > <a name="deinitializer-declaration"></a>
> >
> *析构器声明* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> **deinit** [*代码块*](#code-block) > *析构器声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **deinit** [*代码块*](#code-block)
> >
<a name="extension_declaration"></a> <a name="extension_declaration"></a>
@ -1516,7 +1516,7 @@ extension Array: Loggable where Element: MarkedLoggable { }
> >
> <a name="extension-declaration"></a> > <a name="extension-declaration"></a>
> >
> *扩展声明* → [特性](./06_Attributes.md#type_attributes)<sub>可选</sub> [访问级别修饰符](./#access-level-modifier)<sub>可选</sub> **extension** [*类型标识符*](03_Types.md#type-identifier) [*类型-继承-子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*扩展主体*](#extension-body) > *扩展声明* → [特性](./07_Attributes.md#type_attributes)<sub>可选</sub> [访问级别修饰符](#access-level-modifier)<sub>可选</sub> **extension** [*类型标识符*](03_Types.md#type-identifier) [*类型-继承-子句*](./03_Types.md#type-inheritance-clause)<sub>可选</sub> [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*扩展主体*](#extension-body)
> >
> <a name="extension-body"></a> > <a name="extension-body"></a>
> >
@ -1524,7 +1524,7 @@ extension Array: Loggable where Element: MarkedLoggable { }
> >
> *多条声明* → [单条声明](#subscript_declaration) [多条声明](#declarations) <sub>可选</sub> > *多条声明* → [单条声明](#subscript_declaration) [多条声明](#declarations) <sub>可选</sub>
> >
> *单条声明* → [声明语句](./#declarations) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) > *单条声明* → [声明语句](#declarations) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
> >
<a name="subscript_declaration"></a> <a name="subscript_declaration"></a>
@ -1567,19 +1567,19 @@ subscript (参数列表) -> 返回类型 {
> >
> <a name="subscript-declaration"></a> > <a name="subscript-declaration"></a>
> >
> *下标声明* → [*下标头*](./#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*代码块*](#code-block) > *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*代码块*](#code-block)
> >
> *下标声明* → [*下标头*](./#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 代码块*](#getter-setter-block) > *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 代码块*](#getter-setter-block)
> >
> *下标声明* → [*下标头*](./#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 关键字代码块*](#getter-setter-keyword-block)
> >
> <a name="subscript-head"></a> > <a name="subscript-head"></a>
> >
> *下标头* → [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](./#declaration-modifiers)<sub>可选</sub> **subscript** [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause) > *下标头* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*声明修饰符列表*](#declaration-modifiers)<sub>可选</sub> **subscript** [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause)
> >
> <a name="subscript-result"></a> > <a name="subscript-result"></a>
> >
> *下标结果* → **->** [*特性列表*](./06_Attributes.md#attributes)<sub>可选</sub> [*类型*](./03_Types.md#type) > *下标结果* → **->** [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*类型*](./03_Types.md#type)
> >
<a name="operator_declaration"></a> <a name="operator_declaration"></a>
@ -1621,7 +1621,7 @@ postfix operator 运算符名称 {}
和前缀运算符一样，后缀运算符的声明中不指定优先级，而且后缀运算符是非结合的。 和前缀运算符一样，后缀运算符的声明中不指定优先级，而且后缀运算符是非结合的。
声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../chapter2/25_Advanced_Operators.md#custom_operators)。 声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../chapter2/26_Advanced_Operators.md#custom_operators)。
<a name="grammer_of_an_operator_declaration"></a> <a name="grammer_of_an_operator_declaration"></a>
> 运算符声明语法 > 运算符声明语法
@ -1634,7 +1634,7 @@ postfix operator 运算符名称 {}
> >
> <a name="postfix-operator-declaration"></a> > <a name="postfix-operator-declaration"></a>
> >
> *后缀运算符声明* → **postfix** **运算符** [*运算符*] (02_Lexical_Structure.html#operator) **{** **}** > *后缀运算符声明* → **postfix** **运算符** [*运算符*](./02_Lexical_Structure.html#operator) **{** **}**
> >
> <a name="infix-operator-declaration"></a> > <a name="infix-operator-declaration"></a>
> >
@ -1735,7 +1735,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用，
该修饰符用于修饰协议中的属性、方法以及下标成员，表示符合类型可以不实现这些成员要求。 该修饰符用于修饰协议中的属性、方法以及下标成员，表示符合类型可以不实现这些成员要求。
只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../chapter2/22_Protocols.md#optional_protocol_requirements)。 只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../chapter2/21_Protocols.md#optional_protocol_requirements)。
`required` `required`
@ -1743,7 +1743,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用，
`unowned` `unowned`
该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会引发运行时错误。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../chapter2/16_Automatic_Reference_Counting.md#unowned_references) 该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会引发运行时错误。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../chapter2/23_Automatic_Reference_Counting.md#unowned_references)
`unowned(safe)` `unowned(safe)`
@ -1755,12 +1755,12 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用，
`weak` `weak`
该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../chapter2/16_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。
<a name="access_control_levels"></a> <a name="access_control_levels"></a>
### 访问控制级别 ### 访问控制级别
Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../chapter2/24_Access_Control.md) 中有详细讨论。 Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../chapter2/25_Access_Control.md) 中有详细讨论。
`public` `public`
@ -1774,7 +1774,7 @@ Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`
该修饰符表示声明只能被所在源文件的代码访问。 该修饰符表示声明只能被所在源文件的代码访问。
以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../chapter2/24_Access_Control.md#getters_and_setters) 中所讨论的。 以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../chapter2/25_Access_Control.md#getters_and_setters) 中所讨论的。
<a name="grammer_of_a_declaration_modifier"></a> <a name="grammer_of_a_declaration_modifier"></a>
> 声明修饰符的语法 > 声明修饰符的语法

8
source/chapter3/07_Attributes.md
View File

@ -279,7 +279,7 @@ NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv)
如果你将 `objc` 特性应用于枚举，每一个枚举用例都会以枚举名称和用例名称组合的方式暴露在 Objective-C 代码中。例如，在 `Planet` 枚举中有一个名为 `Venus` 的用例，该用例暴露在 Objective-C 代码中时叫做 `PlanetVenus`。 如果你将 `objc` 特性应用于枚举，每一个枚举用例都会以枚举名称和用例名称组合的方式暴露在 Objective-C 代码中。例如，在 `Planet` 枚举中有一个名为 `Venus` 的用例，该用例暴露在 Objective-C 代码中时叫做 `PlanetVenus`。
`objc` 特性有一个可选的参数，由标识符构成。当你想把 `objc` 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举用例、协议、方法、存取方法以及构造器。如果你要指定类、协议或枚举在 Objective-C 下的名称，在名称上包含三个字母的前缀，如 [Objective-C 编程](./https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.md#//apple_ref/doc/uid/TP40011210) 中的 [约定](./https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.md#//apple_ref/doc/uid/TP40011210-CH10-SW1)。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。 `objc` 特性有一个可选的参数，由标识符构成。当你想把 `objc` 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举用例、协议、方法、存取方法以及构造器。如果你要指定类、协议或枚举在 Objective-C 下的名称，在名称上包含三个字母的前缀，如 [Objective-C 编程](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210) 中的 [约定](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html#//apple_ref/doc/uid/TP40011210-CH10-SW1)。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。
```swift ```swift
class ExampleClass: NSObject { class ExampleClass: NSObject {
@ -349,7 +349,7 @@ class ExampleClass: NSObject {
<a name="autoclosure"></a> <a name="autoclosure"></a>
### `autoclosure` ### `autoclosure`
这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 autoclosure 特性的例子，请参阅 [自动闭包](./https://docs.swift.org/swift-book/LanguageGuide/Closures.md#ID543) 和 [函数类型](./https://docs.swift.org/swift-book/ReferenceManual/Types.md#ID449)。 这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 autoclosure 特性的例子，请参阅 [自动闭包](../chapter2/07_Closures.md#autoclosures) 和 [函数类型](./03_Types.md#function_type)。
<a name="convention"></a> <a name="convention"></a>
### `convention` ### `convention`
@ -369,7 +369,7 @@ convention 特性总是与下面的参数之一一起出现。
<a name="escaping"></a> <a name="escaping"></a>
### `escaping` ### `escaping`
在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行，这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 声明特性的函数类型中访问属性和方法时不需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](./https://docs.swift.org/swift-book/LanguageGuide/Closures.md#ID546)。 在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行，这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 声明特性的函数类型中访问属性和方法时不需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../chapter2/07_Closures.md#escaping_closures)。
<a name="switch_case_attributes"></a> <a name="switch_case_attributes"></a>
## Switch Case 特性 ## Switch Case 特性
@ -378,7 +378,7 @@ convention 特性总是与下面的参数之一一起出现。
### `unknown` ### `unknown`
次特性用于 switch case，表示在编译时该地方不会匹配枚举的任何情况。有关如何使用 `unknown` 特性的示例，可参阅 [Switching over Future Enumeration Cases](./https://docs.swift.org/swift-book/ReferenceManual/Statements.md#ID602)。 次特性用于 switch case，表示在编译时该地方不会匹配枚举的任何情况。有关如何使用 `unknown` 特性的示例，可参阅 [对未来枚举的 `case` 进行 `switch`](./05_Statements.md#future-case)。
> 特性语法 > 特性语法
> >

10
source/chapter3/08_Patterns.md
View File

@ -11,13 +11,13 @@ Swift 中的模式分为两类：一种能成功匹配任何类型的值，另
> 模式语法 > 模式语法
> >
<a name="pattern"></a> <a name="pattern"></a>
> *模式* → [*通配符模式*](./#wildcard_pattern) [*类型标注*](03_Types.md#type-annotation)<sub>可选</sub> > *模式* → [*通配符模式*](#wildcard_pattern) [*类型标注*](03_Types.md#type-annotation)<sub>可选</sub>
> >
> *模式* → [*标识符模式*](./#identifier_pattern) [*类型标注*](03_Types.md#type-annotation)<sub>可选</sub> > *模式* → [*标识符模式*](#identifier_pattern) [*类型标注*](03_Types.md#type-annotation)<sub>可选</sub>
> >
> *模式* → [*值绑定模式*](#value-binding-pattern) > *模式* → [*值绑定模式*](#value-binding-pattern)
> >
> *模式* → [*元组模式*](./#tuple-pattern) [*类型标注*](03_Types.md#type-annotation)<sub>可选</sub> > *模式* → [*元组模式*](#tuple-pattern) [*类型标注*](03_Types.md#type-annotation)<sub>可选</sub>
> >
> *模式* → [*枚举用例模式*](#enum-case-pattern) > *模式* → [*枚举用例模式*](#enum-case-pattern)
> >
@ -136,7 +136,7 @@ let (a): Int = 2 // a: Int = 2
> 枚举用例模式语法 > 枚举用例模式语法
> >
<a name="enum-case-pattern"></a> <a name="enum-case-pattern"></a>
> *枚举用例模式* → [*类型标识*](./03_Types.md#type-identifier)<sub>可选</sub> **.** [*枚举用例名*](./05_Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)<sub>可选</sub> > *枚举用例模式* → [*类型标识*](./03_Types.md#type-identifier)<sub>可选</sub> **.** [*枚举用例名*](./06_Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)<sub>可选</sub>
> >
<a name="optional_pattern"></a> <a name="optional_pattern"></a>
@ -203,7 +203,7 @@ for case let number? in arrayOfOptinalInts {
> *is 模式* → **is** [*类型*](./03_Types.md#type) > *is 模式* → **is** [*类型*](./03_Types.md#type)
> >
<a name="as-pattern"></a> <a name="as-pattern"></a>
> *as 模式* → [*模式*](./#pattern) **as** [*类型*](03_Types.md#type) > *as 模式* → [*模式*](#pattern) **as** [*类型*](03_Types.md#type)
> >
<a name="expression_pattern"></a> <a name="expression_pattern"></a>

2
source/chapter3/09_Generic_Parameters_and_Arguments.md
View File

@ -56,7 +56,7 @@ simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型
泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会根据这些约束来决定调用哪个重载函数或构造器。 泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会根据这些约束来决定调用哪个重载函数或构造器。
更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](./https://github.com/numbbbbb/the-swift-programming-language-in-chinese/blob/gh-pages/source/chapter2/22_Generics.md#where_clauses) 更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](../chapter2/22_Generics.md#where_clauses)
> 泛型形参子句语法 > 泛型形参子句语法
> >

358
source/chapter3/10_Summary_of_the_Grammar.md
View File

@ -7,15 +7,15 @@
> >
> *语句* → [*表达式*](./04_Expressions.md#expression) **;** _可选_ > *语句* → [*表达式*](./04_Expressions.md#expression) **;** _可选_
> >
> *语句* → [*声明*](./05_Declarations.md#declaration) **;** _可选_ > *语句* → [*声明*](./06_Declarations.md#declaration) **;** _可选_
> >
> *语句* → [*循环语句*](./10_Statements.md#loop_statement) **;** _可选_ > *语句* → [*循环语句*](./05_Statements.md#loop_statement) **;** _可选_
> >
> *语句* → [*分支语句*](./10_Statements.md#branch_statement) **;** _可选_ > *语句* → [*分支语句*](./05_Statements.md#branch_statement) **;** _可选_
> >
> *语句* → [*标记语句（Labeled Statement）*](./10_Statements.md#labeled_statement) > *语句* → [*标记语句（Labeled Statement）*](./05_Statements.md#labeled_statement)
> >
> *语句* → [*控制转移语句*](./10_Statements.md#control_transfer_statement) **;** _可选_ > *语句* → [*控制转移语句*](./05_Statements.md#control_transfer_statement) **;** _可选_
> >
> *语句* → [*延迟语句*](TODO) **;** _可选_ > *语句* → [*延迟语句*](TODO) **;** _可选_
> >
@ -23,45 +23,45 @@
> *语句* → [*执行语句*](TODO) **;** _可选_ > *语句* → [*执行语句*](TODO) **;** _可选_
> >
> *多条语句（Statements）* → [*语句*](./10_Statements.md#statement) [*多条语句（Statements）*](./10_Statements.md#statements) _可选_ > *多条语句（Statements）* → [*语句*](./05_Statements.md#statement) [*多条语句（Statements）*](./05_Statements.md#statements) _可选_
> >
<!-- --> <!-- -->
> 循环语句语法 > 循环语句语法
> >
> *循环语句* → [*for 语句*](./10_Statements.md#for_statement) > *循环语句* → [*for 语句*](./05_Statements.md#for_statement)
> >
> *循环语句* → [*for-in 语句*](./10_Statements.md#for_in_statement) > *循环语句* → [*for-in 语句*](./05_Statements.md#for_in_statement)
> >
> *循环语句* → [*while 语句*](./10_Statements.md#wheetatype 类型 ile_statement) > *循环语句* → [*while 语句*](./05_Statements.md#wheetatype 类型 ile_statement)
> >
> *循环语句* → [*repeat-while 语句*](./10_Statements.md#do_while_statement) > *循环语句* → [*repeat-while 语句*](./05_Statements.md#do_while_statement)
> >
<!-- --> <!-- -->
> For 循环语法 > For 循环语法
> >
> *for 语句* → **for** [*for 初始条件*](./10_Statements.md#for_init) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ [*代码块*](./05_Declarations.md#code_block) > *for 语句* → **for** [*for 初始条件*](./05_Statements.md#for_init) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ [*代码块*](./06_Declarations.md#code_block)
> >
> *for 语句* → **for** **(** [*for 初始条件*](./10_Statements.md#for_init) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ **)** [*代码块*](./05_Declarations.md#code_block) > *for 语句* → **for** **(** [*for 初始条件*](./05_Statements.md#for_init) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ **;** [*表达式*](./04_Expressions.md#expression) _可选_ **)** [*代码块*](./06_Declarations.md#code_block)
> >
> *for 初始条件* → [*变量声明*](./05_Declarations.md#variable_declaration) | [*表达式集*](./04_Expressions.md#expression_list) > *for 初始条件* → [*变量声明*](./06_Declarations.md#variable_declaration) | [*表达式集*](./04_Expressions.md#expression_list)
> >
<!-- --> <!-- -->
> For-In 循环语法 > For-In 循环语法
> >
> *for-in 语句* → **for case** _可选_ [*模式*](./07_Patterns.md#pattern) **in** [*表达式*](./04_Expressions.md#expression) [*代码块*](./05_Declarations.md#code_block) [*where 从句*](TODO) _可选_ > *for-in 语句* → **for case** _可选_ [*模式*](./08_Patterns.md#pattern) **in** [*表达式*](./04_Expressions.md#expression) [*代码块*](./06_Declarations.md#code_block) [*where 从句*](TODO) _可选_
> >
<!-- --> <!-- -->
> While 循环语法 > While 循环语法
> >
> *while 语句* → **while** [*条件从句*](./10_Statements.md#while_condition) [*代码块*](./05_Declarations.md#code_block) > *while 语句* → **while** [*条件从句*](./05_Statements.md#while_condition) [*代码块*](./06_Declarations.md#code_block)
> >
> *条件从句* → [*表达式*](TODO) > *条件从句* → [*表达式*](TODO)
> >
@ -95,11 +95,11 @@
> 分支语句语法 > 分支语句语法
> >
> *分支语句* → [*if 语句*](./10_Statements.md#if_statement) > *分支语句* → [*if 语句*](./05_Statements.md#if_statement)
> >
> *分支语句* → [*guard 语句*](TODO) > *分支语句* → [*guard 语句*](TODO)
> >
> *分支语句* → [*switch 语句*](./10_Statements.md#switch_statement) > *分支语句* → [*switch 语句*](./05_Statements.md#switch_statement)
> >
<!-- --> <!-- -->
@ -108,7 +108,7 @@
> >
> *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句（Clause）*](TODO) _可选_ > *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句（Clause）*](TODO) _可选_
> >
> *else 从句（Clause）* → **else** [*代码块*](./05_Declarations.md#code_block) | **else** [*if 语句*](./10_Statements.md#if_statement) > *else 从句（Clause）* → **else** [*代码块*](./06_Declarations.md#code_block) | **else** [*if 语句*](./05_Statements.md#if_statement)
> >
<!-- --> <!-- -->
@ -122,17 +122,17 @@
> Switch 语句语法 > Switch 语句语法
> >
> *switch 语句* → **switch** [*表达式*](./04_Expressions.md#expression) **{** [*SwitchCase*](./10_Statements.md#switch_cases) _可选_ **}** > *switch 语句* → **switch** [*表达式*](./04_Expressions.md#expression) **{** [*SwitchCase*](./05_Statements.md#switch_cases) _可选_ **}**
> >
> *SwitchCase 集* → [*SwitchCase*](./10_Statements.md#switch_case) [*SwitchCase 集*](./10_Statements.md#switch_cases) _可选_ > *SwitchCase 集* → [*SwitchCase*](./05_Statements.md#switch_case) [*SwitchCase 集*](./05_Statements.md#switch_cases) _可选_
> >
> *SwitchCase* → [*case 标签*](./10_Statements.md#case_label) [*多条语句（Statements）*](./10_Statements.md#statements) | [*default 标签*](./10_Statements.md#default_label) [*多条语句（Statements）*](./10_Statements.md#statements) > *SwitchCase* → [*case 标签*](./05_Statements.md#case_label) [*多条语句（Statements）*](./05_Statements.md#statements) | [*default 标签*](./05_Statements.md#default_label) [*多条语句（Statements）*](./05_Statements.md#statements)
> >
> *SwitchCase* → [*case 标签*](./10_Statements.md#case_label) **;** | [*default 标签*](./10_Statements.md#default_label) **;** > *SwitchCase* → [*case 标签*](./05_Statements.md#case_label) **;** | [*default 标签*](./05_Statements.md#default_label) **;**
> >
> *case 标签* → **case** [*case 项集*](./10_Statements.md#case_item_list) **:** > *case 标签* → **case** [*case 项集*](./05_Statements.md#case_item_list) **:**
> >
> *case 项集* → [*模式*](./07_Patterns.md#pattern) [*where-clause*](./10_Statements.md#guard_clause) _可选_ | [*模式*](./07_Patterns.md#pattern) [*where-clause*](./10_Statements.md#guard_clause) _可选_ **,** [*case 项集*](./10_Statements.md#case_item_list) > *case 项集* → [*模式*](./08_Patterns.md#pattern) [*where-clause*](./05_Statements.md#guard_clause) _可选_ | [*模式*](./08_Patterns.md#pattern) [*where-clause*](./05_Statements.md#guard_clause) _可选_ **,** [*case 项集*](./05_Statements.md#case_item_list)
> >
> *default 标签* → **default** **:** > *default 标签* → **default** **:**
> >
@ -145,9 +145,9 @@
> 标记语句语法 > 标记语句语法
> >
> *标记语句（Labeled Statement）* → [*语句标签*](./10_Statements.md#statement_label) [*循环语句*](./10_Statements.md#loop_statement) | [*语句标签*](./10_Statements.md#statement_label) [*if 语句*](./10_Statements.md#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY) > *标记语句（Labeled Statement）* → [*语句标签*](./05_Statements.md#statement_label) [*循环语句*](./05_Statements.md#loop_statement) | [*语句标签*](./05_Statements.md#statement_label) [*if 语句*](./05_Statements.md#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY)
> >
> *语句标签* → [*标签名称*](./10_Statements.md#label_name) **:** > *语句标签* → [*标签名称*](./05_Statements.md#label_name) **:**
> >
> *标签名称* → [*标识符*](./02_Lexical_Structure.md#identifier) > *标签名称* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
@ -156,13 +156,13 @@
> 控制传递语句（Control Transfer Statement）语法 > 控制传递语句（Control Transfer Statement）语法
> >
> *控制传递语句* → [*break 语句*](./10_Statements.md#break_statement) > *控制传递语句* → [*break 语句*](./05_Statements.md#break_statement)
> >
> *控制传递语句* → [*continue 语句*](./10_Statements.md#continue_statement) > *控制传递语句* → [*continue 语句*](./05_Statements.md#continue_statement)
> >
> *控制传递语句* → [*fallthrough 语句*](./10_Statements.md#fallthrough_statement) > *控制传递语句* → [*fallthrough 语句*](./05_Statements.md#fallthrough_statement)
> >
> *控制传递语句* → [*return 语句*](./10_Statements.md#return_statement) > *控制传递语句* → [*return 语句*](./05_Statements.md#return_statement)
> >
> *控制传递语句* → [*throw 语句*](TODO) > *控制传递语句* → [*throw 语句*](TODO)
> >
@ -171,14 +171,14 @@
> Break 语句语法 > Break 语句语法
> >
> *break 语句* → **break** [*标签名称*](./10_Statements.md#label_name) _可选_ > *break 语句* → **break** [*标签名称*](./05_Statements.md#label_name) _可选_
> >
<!-- --> <!-- -->
> Continue 语句语法 > Continue 语句语法
> >
> *continue 语句* → **continue** [*标签名称*](./10_Statements.md#label_name) _可选_ > *continue 语句* → **continue** [*标签名称*](./05_Statements.md#label_name) _可选_
> >
<!-- --> <!-- -->
@ -249,9 +249,9 @@
> 泛型形参从句（Generic Parameter Clause）语法 > 泛型形参从句（Generic Parameter Clause）语法
> >
> >
> *泛型参数从句* → **<** [*泛型参数集*](./GenericParametersAndArguments.md#generic_parameter_list) [*约束从句*](./GenericParametersAndArguments.md#requirement_clause) _可选_ **>** > *泛型参数从句* → **<** [*泛型参数集*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_list) [*约束从句*](./09_Generic_Parameters_and_Arguments.md#requirement_clause) _可选_ **>**
> >
> *泛型参数集* → [*泛形参数*](./GenericParametersAndArguments.md#generic_parameter) | [*泛形参数*](./GenericParametersAndArguments.md#generic_parameter) **,** [*泛型参数集*](./GenericParametersAndArguments.md#generic_parameter_list) > *泛型参数集* → [*泛形参数*](./09_Generic_Parameters_and_Arguments.md#generic_parameter) | [*泛形参数*](./09_Generic_Parameters_and_Arguments.md#generic_parameter) **,** [*泛型参数集*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_list)
> >
> *泛形参数* → [*类型名称*](./03_Types.md#type_name) > *泛形参数* → [*类型名称*](./03_Types.md#type_name)
> >
@ -259,11 +259,11 @@
> >
> *泛形参数* → [*类型名称*](./03_Types.md#type_name) **:** [*协议合成类型*](./03_Types.md#protocol_composition_type) > *泛形参数* → [*类型名称*](./03_Types.md#type_name) **:** [*协议合成类型*](./03_Types.md#protocol_composition_type)
> >
> *约束从句* → **where** [*约束集*](./GenericParametersAndArguments.md#requirement_list) > *约束从句* → **where** [*约束集*](./09_Generic_Parameters_and_Arguments.md#requirement_list)
> >
> *约束集* → [*约束*](./GenericParametersAndArguments.md#requirement) | [*约束*](./GenericParametersAndArguments.md#requirement) **,** [*约束集*](./GenericParametersAndArguments.md#requirement_list) > *约束集* → [*约束*](./09_Generic_Parameters_and_Arguments.md#requirement) | [*约束*](./09_Generic_Parameters_and_Arguments.md#requirement) **,** [*约束集*](./09_Generic_Parameters_and_Arguments.md#requirement_list)
> >
> *约束* → [*一致性约束*](./GenericParametersAndArguments.md#conformance_requirement) | [*同类型约束*](./GenericParametersAndArguments.md#same_type_requirement) > *约束* → [*一致性约束*](./09_Generic_Parameters_and_Arguments.md#conformance_requirement) | [*同类型约束*](./09_Generic_Parameters_and_Arguments.md#same_type_requirement)
> >
> *一致性约束* → [*类型标识*](./03_Types.md#type_identifier) **:** [*类型标识*](./03_Types.md#type_identifier) > *一致性约束* → [*类型标识*](./03_Types.md#type_identifier) **:** [*类型标识*](./03_Types.md#type_identifier)
> >
@ -276,9 +276,9 @@
> 泛型实参从句语法 > 泛型实参从句语法
> >
> *(泛型参数从句 Generic Argument Clause)* → **<** [*泛型参数集*](./GenericParametersAndArguments.md#generic_argument_list) **>** > *(泛型参数从句 Generic Argument Clause)* → **<** [*泛型参数集*](./09_Generic_Parameters_and_Arguments.md#generic_argument_list) **>**
> >
> *泛型参数集* → [*泛型参数*](./GenericParametersAndArguments.md#generic_argument) | [*泛型参数*](./GenericParametersAndArguments.md#generic_argument) **,** [*泛型参数集*](./GenericParametersAndArguments.md#generic_argument_list) > *泛型参数集* → [*泛型参数*](./09_Generic_Parameters_and_Arguments.md#generic_argument) | [*泛型参数*](./09_Generic_Parameters_and_Arguments.md#generic_argument) **,** [*泛型参数集*](./09_Generic_Parameters_and_Arguments.md#generic_argument_list)
> >
> *泛型参数* → [*类型*](./03_Types.md#type) > *泛型参数* → [*类型*](./03_Types.md#type)
> >
@ -288,35 +288,35 @@
> 声明语法 > 声明语法
> >
> *声明* → [*导入声明*](./05_Declarations.md#import_declaration) > *声明* → [*导入声明*](./06_Declarations.md#import_declaration)
> >
> *声明* → [*常量声明*](./05_Declarations.md#constant_declaration) > *声明* → [*常量声明*](./06_Declarations.md#constant_declaration)
> >
> *声明* → [*变量声明*](./05_Declarations.md#variable_declaration) > *声明* → [*变量声明*](./06_Declarations.md#variable_declaration)
> >
> *声明* → [*类型别名声明*](./05_Declarations.md#typealias_declaration) > *声明* → [*类型别名声明*](./06_Declarations.md#typealias_declaration)
> >
> *声明* → [*函数声明*](./05_Declarations.md#function_declaration) > *声明* → [*函数声明*](./06_Declarations.md#function_declaration)
> >
> *声明* → [*枚举声明*](./05_Declarations.md#enum_declaration) > *声明* → [*枚举声明*](./06_Declarations.md#enum_declaration)
> >
> *声明* → [*结构体声明*](./05_Declarations.md#struct_declaration) > *声明* → [*结构体声明*](./06_Declarations.md#struct_declaration)
> >
> *声明* → [*类声明*](./05_Declarations.md#class_declaration) > *声明* → [*类声明*](./06_Declarations.md#class_declaration)
> >
> *声明* → [*协议声明*](./05_Declarations.md#protocol_declaration) > *声明* → [*协议声明*](./06_Declarations.md#protocol_declaration)
> >
> *声明* → [*构造器声明*](./05_Declarations.md#initializer_declaration) > *声明* → [*构造器声明*](./06_Declarations.md#initializer_declaration)
> >
> *声明* → [*析构器声明*](./05_Declarations.md#deinitializer_declaration) > *声明* → [*析构器声明*](./06_Declarations.md#deinitializer_declaration)
> >
> *声明* → [*扩展声明*](./05_Declarations.md#extension_declaration) > *声明* → [*扩展声明*](./06_Declarations.md#extension_declaration)
> >
> *声明* → [*下标声明*](./05_Declarations.md#subscript_declaration) > *声明* → [*下标声明*](./06_Declarations.md#subscript_declaration)
> >
> *声明* → [*运算符声明*](./05_Declarations.md#operator_declaration) > *声明* → [*运算符声明*](./06_Declarations.md#operator_declaration)
> >
> *声明（Declarations）集* → [*声明*](./05_Declarations.md#declaration) [*声明（Declarations）集*](./05_Declarations.md#declarations) _可选_ > *声明（Declarations）集* → [*声明*](./06_Declarations.md#declaration) [*声明（Declarations）集*](./06_Declarations.md#declarations) _可选_
> >
@ -324,25 +324,25 @@
> 顶级（Top Level）声明语法 > 顶级（Top Level）声明语法
> >
> *顶级声明* → [*多条语句（Statements）*](./10_Statements.md#statements) _可选_ > *顶级声明* → [*多条语句（Statements）*](./05_Statements.md#statements) _可选_
> >
<!-- --> <!-- -->
> 代码块语法 > 代码块语法
> >
> *代码块* → **{** [*多条语句（Statements）*](./10_Statements.md#statements) _可选_ **}** > *代码块* → **{** [*多条语句（Statements）*](./05_Statements.md#statements) _可选_ **}**
> >
<!-- --> <!-- -->
> 导入（Import）声明语法 > 导入（Import）声明语法
> >
> *导入声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **import** [*导入类型*](./05_Declarations.md#import_kind) _可选_ [*导入路径*](./05_Declarations.md#import_path) > *导入声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **import** [*导入类型*](./06_Declarations.md#import_kind) _可选_ [*导入路径*](./06_Declarations.md#import_path)
> >
> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func** > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**
> >
> *导入路径* → [*导入路径标识符*](./05_Declarations.md#import_path_identifier) | [*导入路径标识符*](./05_Declarations.md#import_path_identifier) **.** [*导入路径*](./05_Declarations.md#import_path) > *导入路径* → [*导入路径标识符*](./06_Declarations.md#import_path_identifier) | [*导入路径标识符*](./06_Declarations.md#import_path_identifier) **.** [*导入路径*](./06_Declarations.md#import_path)
> >
> *导入路径标识符* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator) > *导入路径标识符* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator)
> >
@ -351,11 +351,11 @@
> 常数声明语法 > 常数声明语法
> >
> *常量声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明修改符（Modifiers）集*](./05_Declarations.md#declaration_specifiers) _可选_ **let** [*模式构造器集*](./05_Declarations.md#pattern_initializer_list) > *常量声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明修改符（Modifiers）集*](./06_Declarations.md#declaration_specifiers) _可选_ **let** [*模式构造器集*](./06_Declarations.md#pattern_initializer_list)
> >
> *模式构造器集* → [*模式构造器*](./05_Declarations.md#pattern_initializer) | [*模式构造器*](./05_Declarations.md#pattern_initializer) **,** [*模式构造器集*](./05_Declarations.md#pattern_initializer_list) > *模式构造器集* → [*模式构造器*](./06_Declarations.md#pattern_initializer) | [*模式构造器*](./06_Declarations.md#pattern_initializer) **,** [*模式构造器集*](./06_Declarations.md#pattern_initializer_list)
> >
> *模式构造器* → [*模式*](../ chapter3/07_Patterns.md#pattern) [*构造器*](./05_Declarations.md#initializer) _可选_ > *模式构造器* → [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) _可选_
> >
> *构造器* → **=** [*表达式*](./04_Expressions.md#expression) > *构造器* → **=** [*表达式*](./04_Expressions.md#expression)
> >
@ -364,55 +364,55 @@
> 变量声明语法 > 变量声明语法
> >
> *变量声明* → [*变量声明头（Head）*](./05_Declarations.md#variable_declaration_head) [*模式构造器集*](./05_Declarations.md#pattern_initializer_list) > *变量声明* → [*变量声明头（Head）*](./06_Declarations.md#variable_declaration_head) [*模式构造器集*](./06_Declarations.md#pattern_initializer_list)
> >
> *变量声明* → [*变量声明头（Head）*](./05_Declarations.md#variable_declaration_head) [*变量名*](./05_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*代码块*](./05_Declarations.md#code_block) > *变量声明* → [*变量声明头（Head）*](./06_Declarations.md#variable_declaration_head) [*变量名*](./06_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*代码块*](./06_Declarations.md#code_block)
> >
> *变量声明* → [*变量声明头（Head）*](./05_Declarations.md#variable_declaration_head) [*变量名*](./05_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*getter-setter 块*](./05_Declarations.md#getter_setter_block) > *变量声明* → [*变量声明头（Head）*](./06_Declarations.md#variable_declaration_head) [*变量名*](./06_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*getter-setter 块*](./06_Declarations.md#getter_setter_block)
> >
> *变量声明* → [*变量声明头（Head）*](./05_Declarations.md#variable_declaration_head) [*变量名*](./05_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*getter-setter 关键字（Keyword）块*](./05_Declarations.md#getter_setter_keyword_block) > *变量声明* → [*变量声明头（Head）*](./06_Declarations.md#variable_declaration_head) [*变量名*](./06_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*getter-setter 关键字（Keyword）块*](./06_Declarations.md#getter_setter_keyword_block)
> >
> *变量声明* → [*变量声明头（Head）*](./05_Declarations.md#variable_declaration_head) [*变量名*](./05_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*构造器*](./05_Declarations.md#initializer) _可选_ [*willSet-didSet 代码块*](./05_Declarations.md#willSet_didSet_block) > *变量声明* → [*变量声明头（Head）*](./06_Declarations.md#variable_declaration_head) [*变量名*](./06_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*构造器*](./06_Declarations.md#initializer) _可选_ [*willSet-didSet 代码块*](./06_Declarations.md#willSet_didSet_block)
> >
> *变量声明头（Head）* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明修改符（Modifers）集*](./05_Declarations.md#declaration_specifiers) _可选_ **var** > *变量声明头（Head）* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明修改符（Modifers）集*](./06_Declarations.md#declaration_specifiers) _可选_ **var**
> >
> *变量名称* → [*标识符*](./02_Lexical_Structure.md#identifier) > *变量名称* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *getter-setter 块* → **{** [*getter 从句*](./05_Declarations.md#getter_clause) [*setter 从句*](./05_Declarations.md#setter_clause) _可选_ **}** > *getter-setter 块* → **{** [*getter 从句*](./06_Declarations.md#getter_clause) [*setter 从句*](./06_Declarations.md#setter_clause) _可选_ **}**
> >
> *getter-setter 块* → **{** [*setter 从句*](./05_Declarations.md#setter_clause) [*getter 从句*](./05_Declarations.md#getter_clause) **}** > *getter-setter 块* → **{** [*setter 从句*](./06_Declarations.md#setter_clause) [*getter 从句*](./06_Declarations.md#getter_clause) **}**
> >
> *getter 从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **get** [*代码块*](./05_Declarations.md#code_block) > *getter 从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **get** [*代码块*](./06_Declarations.md#code_block)
> >
> *setter 从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **set** [*setter 名称*](./05_Declarations.md#setter_name) _可选_ [*代码块*](./05_Declarations.md#code_block) > *setter 从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **set** [*setter 名称*](./06_Declarations.md#setter_name) _可选_ [*代码块*](./06_Declarations.md#code_block)
> >
> *setter 名称* → **(** [*标识符*](./02_Lexical_Structure.md#identifier) **)** > *setter 名称* → **(** [*标识符*](./02_Lexical_Structure.md#identifier) **)**
> >
> *getter-setter 关键字（Keyword）块* → **{** [*getter 关键字（Keyword）从句*](./05_Declarations.md#getter_keyword_clause) [*setter 关键字（Keyword）从句*](./05_Declarations.md#setter_keyword_clause) _可选_ **}** > *getter-setter 关键字（Keyword）块* → **{** [*getter 关键字（Keyword）从句*](./06_Declarations.md#getter_keyword_clause) [*setter 关键字（Keyword）从句*](./06_Declarations.md#setter_keyword_clause) _可选_ **}**
> >
> *getter-setter 关键字（Keyword）块* → **{** [*setter 关键字（Keyword）从句*](./05_Declarations.md#setter_keyword_clause) [*getter 关键字（Keyword）从句*](./05_Declarations.md#getter_keyword_clause) **}** > *getter-setter 关键字（Keyword）块* → **{** [*setter 关键字（Keyword）从句*](./06_Declarations.md#setter_keyword_clause) [*getter 关键字（Keyword）从句*](./06_Declarations.md#getter_keyword_clause) **}**
> >
> *getter 关键字（Keyword）从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **get** > *getter 关键字（Keyword）从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **get**
> >
> *setter 关键字（Keyword）从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **set** > *setter 关键字（Keyword）从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **set**
> >
> *willSet-didSet 代码块* → **{** [*willSet 从句*](./05_Declarations.md#willSet_clause) [*didSet 从句*](./05_Declarations.md#didSet_clause) _可选_ **}** > *willSet-didSet 代码块* → **{** [*willSet 从句*](./06_Declarations.md#willSet_clause) [*didSet 从句*](./06_Declarations.md#didSet_clause) _可选_ **}**
> >
> *willSet-didSet 代码块* → **{** [*didSet 从句*](./05_Declarations.md#didSet_clause) [*willSet 从句*](./05_Declarations.md#willSet_clause) **}** > *willSet-didSet 代码块* → **{** [*didSet 从句*](./06_Declarations.md#didSet_clause) [*willSet 从句*](./06_Declarations.md#willSet_clause) **}**
> >
> *willSet 从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **willSet** [*setter 名称*](./05_Declarations.md#setter_name) _可选_ [*代码块*](./05_Declarations.md#code_block) > *willSet 从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **willSet** [*setter 名称*](./06_Declarations.md#setter_name) _可选_ [*代码块*](./06_Declarations.md#code_block)
> >
> *didSet 从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ > *didSet 从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_
> >
**didSet** [*setter 名称*](./05_Declarations.md#setter_name) _可选_ [*代码块*](./05_Declarations.md#code_block) **didSet** [*setter 名称*](./06_Declarations.md#setter_name) _可选_ [*代码块*](./06_Declarations.md#code_block)
<!-- --> <!-- -->
> 类型别名声明语法 > 类型别名声明语法
> >
> *类型别名声明* → [*类型别名头（Head）*](./05_Declarations.md#typealias_head) [*类型别名赋值*](./05_Declarations.md#typealias_assignment) > *类型别名声明* → [*类型别名头（Head）*](./06_Declarations.md#typealias_head) [*类型别名赋值*](./06_Declarations.md#typealias_assignment)
> >
> *类型别名头（Head）* → [*属性*](./TODO) _可选_ [*访问级别修改符（access-level-modifier）*](TODO) **typealias** [*类型别名名称*](./05_Declarations.md#typealias_name) > *类型别名头（Head）* → [*属性*](TODO) _可选_ [*访问级别修改符（access-level-modifier）*](TODO) **typealias** [*类型别名名称*](./06_Declarations.md#typealias_name)
> >
> *类型别名名称* → [*标识符*](./02_Lexical_Structure.md#identifier) > *类型别名名称* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
@ -423,32 +423,32 @@
> 函数声明语法 > 函数声明语法
> >
> *函数声明* → [*函数头*](./05_Declarations.md#function_head) [*函数名*](./05_Declarations.md#function_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*函数签名（Signature）*](./05_Declarations.md#function_signature) [*函数体*](./05_Declarations.md#function_body) > *函数声明* → [*函数头*](./06_Declarations.md#function_head) [*函数名*](./06_Declarations.md#function_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*函数签名（Signature）*](./06_Declarations.md#function_signature) [*函数体*](./06_Declarations.md#function_body)
> >
> *函数头* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明描述符（Specifiers）集*](./05_Declarations.md#declaration_specifiers) _可选_ **func** > *函数头* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明描述符（Specifiers）集*](./06_Declarations.md#declaration_specifiers) _可选_ **func**
> >
> *函数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator) > *函数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator)
> >
> *函数签名（Signature）* → [*parameter-clauses*](./05_Declarations.md#parameter_clauses) **throws** _可选_ [*函数结果*](./05_Declarations.md#function_result) _可选_ > *函数签名（Signature）* → [*parameter-clauses*](./06_Declarations.md#parameter_clauses) **throws** _可选_ [*函数结果*](./06_Declarations.md#function_result) _可选_
> >
> *函数签名（Signature）* → [*parameter-clauses*](./05_Declarations.md#parameter_clauses) **rethrows** [*函数结果*](./05_Declarations.md#function_result) _可选_ > *函数签名（Signature）* → [*parameter-clauses*](./06_Declarations.md#parameter_clauses) **rethrows** [*函数结果*](./06_Declarations.md#function_result) _可选_
> >
> *函数结果* → **->** [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type) > *函数结果* → **->** [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type)
> >
> *函数体* → [*代码块*](./05_Declarations.md#code_block) > *函数体* → [*代码块*](./06_Declarations.md#code_block)
> >
> *参数从句* → [*参数从句*](./05_Declarations.md#parameter_clause) [*parameter-clauses*](./05_Declarations.md#parameter_clauses) _可选_ > *参数从句* → [*参数从句*](./06_Declarations.md#parameter_clause) [*parameter-clauses*](./06_Declarations.md#parameter_clauses) _可选_
> >
> *参数从句* → **(** **)** | **(** [*参数集*](./05_Declarations.md#parameter_list) **...** _可选_ **)** > *参数从句* → **(** **)** | **(** [*参数集*](./06_Declarations.md#parameter_list) **...** _可选_ **)**
> >
> *参数集* → [*参数*](./05_Declarations.md#parameter) | [*参数*](./05_Declarations.md#parameter) **,** [*参数集*](./05_Declarations.md#parameter_list) > *参数集* → [*参数*](./06_Declarations.md#parameter) | [*参数*](./06_Declarations.md#parameter) **,** [*参数集*](./06_Declarations.md#parameter_list)
> >
> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](./05_Declarations.md#parameter_name) _可选_ [*本地参数名*](./05_Declarations.md#local_parameter_name) _可选_ [*类型注解*](./03_Types.md#type_annotation) [*默认参数从句*](./05_Declarations.md#default_argument_clause) _可选_ > *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](./06_Declarations.md#parameter_name) _可选_ [*本地参数名*](./06_Declarations.md#local_parameter_name) _可选_ [*类型注解*](./03_Types.md#type_annotation) [*默认参数从句*](./06_Declarations.md#default_argument_clause) _可选_
> >
> *参数* → **inout** _可选_ **var** [*外部参数名*](./05_Declarations.md#parameter_name) [*本地参数名*](./05_Declarations.md#local_parameter_name) _可选_ [*类型注解*](./03_Types.md#type_annotation) [*默认参数从句*](./05_Declarations.md#default_argument_clause) _可选_ > *参数* → **inout** _可选_ **var** [*外部参数名*](./06_Declarations.md#parameter_name) [*本地参数名*](./06_Declarations.md#local_parameter_name) _可选_ [*类型注解*](./03_Types.md#type_annotation) [*默认参数从句*](./06_Declarations.md#default_argument_clause) _可选_
> >
> *参数* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type) > *参数* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type)
> >
> *外部参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | **_** > *外部参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | **_**
> >
@ -461,37 +461,37 @@
> 枚举声明语法 > 枚举声明语法
> >
> *枚举声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](./TODO) _可选_ [*联合式枚举*](./05_Declarations.md#union_style_enum) > *枚举声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*联合式枚举*](./06_Declarations.md#union_style_enum)
> >
> *枚举声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*原始值式枚举（raw-value-style-enum）*](TODO) > *枚举声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*原始值式枚举（raw-value-style-enum）*](TODO)
> >
> *联合式枚举* → **enum** [*枚举名*](./05_Declarations.md#enum_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*类型继承从句（type-inheritance-clause）*](./TODO) _可选_ **{** [*联合样式枚举成员*](./05_Declarations.md#union_style_enum_members) _可选_ **}** > *联合式枚举* → **enum** [*枚举名*](./06_Declarations.md#enum_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*类型继承从句（type-inheritance-clause）*](TODO) _可选_ **{** [*联合样式枚举成员*](./06_Declarations.md#union_style_enum_members) _可选_ **}**
> >
> *联合样式枚举成员* → [*union-style-enum-member*](./05_Declarations.md#union_style_enum_member) [*联合样式枚举成员*](./05_Declarations.md#union_style_enum_members) _可选_ > *联合样式枚举成员* → [*union-style-enum-member*](./06_Declarations.md#union_style_enum_member) [*联合样式枚举成员*](./06_Declarations.md#union_style_enum_members) _可选_
> >
> *联合样式枚举成员* → [*声明*](./05_Declarations.md#declaration) | [*联合式（Union Style）的枚举 case 从句*](./05_Declarations.md#union_style_enum_case_clause) > *联合样式枚举成员* → [*声明*](./06_Declarations.md#declaration) | [*联合式（Union Style）的枚举 case 从句*](./06_Declarations.md#union_style_enum_case_clause)
> >
> *联合式（Union Style）的枚举 case 从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **case** [*联合式（Union Style）的枚举 case 集*](./05_Declarations.md#union_style_enum_case_list) > *联合式（Union Style）的枚举 case 从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **case** [*联合式（Union Style）的枚举 case 集*](./06_Declarations.md#union_style_enum_case_list)
> >
> *联合式（Union Style）的枚举 case 集* → [*联合式（Union Style）的 case*](./05_Declarations.md#union_style_enum_case) | [*联合式（Union Style）的 case*](./05_Declarations.md#union_style_enum_case) **,** [*联合式（Union Style）的枚举 case 集*](./05_Declarations.md#union_style_enum_case_list) > *联合式（Union Style）的枚举 case 集* → [*联合式（Union Style）的 case*](./06_Declarations.md#union_style_enum_case) | [*联合式（Union Style）的 case*](./06_Declarations.md#union_style_enum_case) **,** [*联合式（Union Style）的枚举 case 集*](./06_Declarations.md#union_style_enum_case_list)
> >
> *联合式（Union Style）的枚举 case* → [*枚举的 case 名*](./05_Declarations.md#enum_case_name) [*元组类型*](./03_Types.md#tuple_type) _可选_ > *联合式（Union Style）的枚举 case* → [*枚举的 case 名*](./06_Declarations.md#enum_case_name) [*元组类型*](./03_Types.md#tuple_type) _可选_
> >
> *枚举名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *枚举名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *枚举的 case 名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *枚举的 case 名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *原始值式枚举* → **enum** [*枚举名*](./05_Declarations.md#enum_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ **:** [*类型标识*](./03_Types.md#type_identifier) **{** [*原始值式枚举成员集*](./05_Declarations.md#raw_value_style_enum_members) _可选_ **}** > *原始值式枚举* → **enum** [*枚举名*](./06_Declarations.md#enum_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ **:** [*类型标识*](./03_Types.md#type_identifier) **{** [*原始值式枚举成员集*](./06_Declarations.md#raw_value_style_enum_members) _可选_ **}**
> >
> *原始值式枚举成员集* → [*原始值式枚举成员*](./05_Declarations.md#raw_value_style_enum_member) [*原始值式枚举成员集*](./05_Declarations.md#raw_value_style_enum_members) _可选_ > *原始值式枚举成员集* → [*原始值式枚举成员*](./06_Declarations.md#raw_value_style_enum_member) [*原始值式枚举成员集*](./06_Declarations.md#raw_value_style_enum_members) _可选_
> >
> *原始值式枚举成员* → [*声明*](./05_Declarations.md#declaration) | [*原始值式枚举 case 从句*](./05_Declarations.md#raw_value_style_enum_case_clause) > *原始值式枚举成员* → [*声明*](./06_Declarations.md#declaration) | [*原始值式枚举 case 从句*](./06_Declarations.md#raw_value_style_enum_case_clause)
> >
> *原始值式枚举 case 从句* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **case** [*原始值式枚举 case 集*](./05_Declarations.md#raw_value_style_enum_case_list) > *原始值式枚举 case 从句* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **case** [*原始值式枚举 case 集*](./06_Declarations.md#raw_value_style_enum_case_list)
> >
> *原始值式枚举 case 集* → [*原始值式枚举 case*](./05_Declarations.md#raw_value_style_enum_case) | [*原始值式枚举 case*](./05_Declarations.md#raw_value_style_enum_case) **,** [*原始值式枚举 case 集*](./05_Declarations.md#raw_value_style_enum_case_list) > *原始值式枚举 case 集* → [*原始值式枚举 case*](./06_Declarations.md#raw_value_style_enum_case) | [*原始值式枚举 case*](./06_Declarations.md#raw_value_style_enum_case) **,** [*原始值式枚举 case 集*](./06_Declarations.md#raw_value_style_enum_case_list)
> >
> *原始值式枚举 case* → [*枚举的 case 名*](./05_Declarations.md#enum_case_name) [*原始值赋值*](./05_Declarations.md#raw_value_assignment) _可选_ > *原始值式枚举 case* → [*枚举的 case 名*](./06_Declarations.md#enum_case_name) [*原始值赋值*](./06_Declarations.md#raw_value_assignment) _可选_
> >
> *原始值赋值* → **=** [*字面量*](./02_Lexical_Structure.md#literal) > *原始值赋值* → **=** [*字面量*](./02_Lexical_Structure.md#literal)
> >
@ -502,147 +502,147 @@
> 结构体声明语法 > 结构体声明语法
> >
> *结构体声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](./TODO) _可选_ **struct** [*结构体名称*](./05_Declarations.md#struct_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*结构体主体*](./05_Declarations.md#struct_body) > *结构体声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ **struct** [*结构体名称*](./06_Declarations.md#struct_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*结构体主体*](./06_Declarations.md#struct_body)
> >
> *结构体名称* → [*标识符*](./02_Lexical_Structure.md#identifier) > *结构体名称* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *结构体主体* → **{** [*声明（Declarations）集*](./05_Declarations.md#declarations) _可选_ **}** > *结构体主体* → **{** [*声明（Declarations）集*](./06_Declarations.md#declarations) _可选_ **}**
> >
<!-- --> <!-- -->
> 类声明语法 > 类声明语法
> >
> *类声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](./TODO) **class** [*类名*](./05_Declarations.md#class_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*类主体*](./05_Declarations.md#class_body) > *类声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) **class** [*类名*](./06_Declarations.md#class_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*类主体*](./06_Declarations.md#class_body)
> >
> *类名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *类名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *类主体* → **{** [*声明（Declarations）集*](./05_Declarations.md#declarations) _可选_ **}** > *类主体* → **{** [*声明（Declarations）集*](./06_Declarations.md#declarations) _可选_ **}**
> >
<!-- --> <!-- -->
> 协议（Protocol）声明语法 > 协议（Protocol）声明语法
> >
> *协议声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_[*访问级别修改器（access-level-modifier）*](./TODO) **protocol** [*协议名*](./05_Declarations.md#protocol_name) [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*协议主体*](./05_Declarations.md#protocol_body) > *协议声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_[*访问级别修改器（access-level-modifier）*](TODO) **protocol** [*协议名*](./06_Declarations.md#protocol_name) [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*协议主体*](./06_Declarations.md#protocol_body)
> >
> *协议名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *协议名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *协议主体* → **{** [*协议成员声明（Declarations）集*](./05_Declarations.md#protocol_member_declarations) _可选_ **}** > *协议主体* → **{** [*协议成员声明（Declarations）集*](./06_Declarations.md#protocol_member_declarations) _可选_ **}**
> >
> *协议成员声明* → [*协议属性声明*](./05_Declarations.md#protocol_property_declaration) > *协议成员声明* → [*协议属性声明*](./06_Declarations.md#protocol_property_declaration)
> >
> *协议成员声明* → [*协议方法声明*](./05_Declarations.md#protocol_method_declaration) > *协议成员声明* → [*协议方法声明*](./06_Declarations.md#protocol_method_declaration)
> >
> *协议成员声明* → [*协议构造器声明*](./05_Declarations.md#protocol_initializer_declaration) > *协议成员声明* → [*协议构造器声明*](./06_Declarations.md#protocol_initializer_declaration)
> >
> *协议成员声明* → [*协议下标声明*](./05_Declarations.md#protocol_subscript_declaration) > *协议成员声明* → [*协议下标声明*](./06_Declarations.md#protocol_subscript_declaration)
> >
> *协议成员声明* → [*协议关联类型声明*](./05_Declarations.md#protocol_associated_type_declaration) > *协议成员声明* → [*协议关联类型声明*](./06_Declarations.md#protocol_associated_type_declaration)
> >
> *协议成员声明（Declarations）集* → [*协议成员声明*](./05_Declarations.md#protocol_member_declaration) [*协议成员声明（Declarations）集*](./05_Declarations.md#protocol_member_declarations) _可选_ > *协议成员声明（Declarations）集* → [*协议成员声明*](./06_Declarations.md#protocol_member_declaration) [*协议成员声明（Declarations）集*](./06_Declarations.md#protocol_member_declarations) _可选_
> >
<!-- --> <!-- -->
> 协议属性声明语法 > 协议属性声明语法
> >
> *协议属性声明* → [*变量声明头（Head）*](./05_Declarations.md#variable_declaration_head) [*变量名*](./05_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*getter-setter 关键字（Keyword）块*](./05_Declarations.md#getter_setter_keyword_block) > *协议属性声明* → [*变量声明头（Head）*](./06_Declarations.md#variable_declaration_head) [*变量名*](./06_Declarations.md#variable_name) [*类型注解*](./03_Types.md#type_annotation) [*getter-setter 关键字（Keyword）块*](./06_Declarations.md#getter_setter_keyword_block)
> >
<!-- --> <!-- -->
> 协议方法声明语法 > 协议方法声明语法
> >
> *协议方法声明* → [*函数头*](./05_Declarations.md#function_head) [*函数名*](./05_Declarations.md#function_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*函数签名（Signature）*](./05_Declarations.md#function_signature) > *协议方法声明* → [*函数头*](./06_Declarations.md#function_head) [*函数名*](./06_Declarations.md#function_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*函数签名（Signature）*](./06_Declarations.md#function_signature)
> >
<!-- --> <!-- -->
> 协议构造器声明语法 > 协议构造器声明语法
> >
> *协议构造器声明* → [*构造器头（Head）*](./05_Declarations.md#initializer_head) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*参数从句*](./05_Declarations.md#parameter_clause) > *协议构造器声明* → [*构造器头（Head）*](./06_Declarations.md#initializer_head) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*参数从句*](./06_Declarations.md#parameter_clause)
> >
<!-- --> <!-- -->
> 协议下标声明语法 > 协议下标声明语法
> >
> *协议下标声明* → [*下标头（Head）*](./05_Declarations.md#subscript_head) [*下标结果（Result）*](./05_Declarations.md#subscript_result) [*getter-setter 关键字（Keyword）块*](./05_Declarations.md#getter_setter_keyword_block) > *协议下标声明* → [*下标头（Head）*](./06_Declarations.md#subscript_head) [*下标结果（Result）*](./06_Declarations.md#subscript_result) [*getter-setter 关键字（Keyword）块*](./06_Declarations.md#getter_setter_keyword_block)
> >
<!-- --> <!-- -->
> 协议关联类型声明语法 > 协议关联类型声明语法
> >
> *协议关联类型声明* → [*类型别名头（Head）*](./05_Declarations.md#typealias_head) [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*类型别名赋值*](./05_Declarations.md#typealias_assignment) _可选_ > *协议关联类型声明* → [*类型别名头（Head）*](./06_Declarations.md#typealias_head) [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*类型别名赋值*](./06_Declarations.md#typealias_assignment) _可选_
> >
<!-- --> <!-- -->
> 构造器声明语法 > 构造器声明语法
> >
> *构造器声明* → [*构造器头（Head）*](./05_Declarations.md#initializer_head) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_parameter_clause) _可选_ [*参数从句*](./05_Declarations.md#parameter_clause) [*构造器主体*](./05_Declarations.md#initializer_body) > *构造器声明* → [*构造器头（Head）*](./06_Declarations.md#initializer_head) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause) _可选_ [*参数从句*](./06_Declarations.md#parameter_clause) [*构造器主体*](./06_Declarations.md#initializer_body)
> >
> *构造器头（Head）* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init** > *构造器头（Head）* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init**
> >
> *构造器头（Head）* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init ?** > *构造器头（Head）* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init ?**
> >
> *构造器头（Head）* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init !** > *构造器头（Head）* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init !**
> >
> *构造器主体* → [*代码块*](./05_Declarations.md#code_block) > *构造器主体* → [*代码块*](./06_Declarations.md#code_block)
> >
<!-- --> <!-- -->
> 析构器声明语法 > 析构器声明语法
> >
> *析构器声明* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **deinit** [*代码块*](./05_Declarations.md#code_block) > *析构器声明* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **deinit** [*代码块*](./06_Declarations.md#code_block)
> >
<!-- --> <!-- -->
> 扩展（Extension）声明语法 > 扩展（Extension）声明语法
> >
> *扩展声明* → [*访问级别修改器*](./TODO) _可选_ **extension** [*类型标识*](./03_Types.md#type_identifier) [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*extension-body*](./05_Declarations.md#extension_body) > *扩展声明* → [*访问级别修改器*](TODO) _可选_ **extension** [*类型标识*](./03_Types.md#type_identifier) [*类型继承从句*](./03_Types.md#type_inheritance_clause) _可选_ [*extension-body*](./06_Declarations.md#extension_body)
> >
> *extension-body* → **{** [*声明（Declarations）集*](./05_Declarations.md#declarations) _可选_ **}** > *extension-body* → **{** [*声明（Declarations）集*](./06_Declarations.md#declarations) _可选_ **}**
> >
<!-- --> <!-- -->
> 下标声明语法 > 下标声明语法
> >
> *下标声明* → [*下标头（Head）*](./05_Declarations.md#subscript_head) [*下标结果（Result）*](./05_Declarations.md#subscript_result) [*代码块*](./05_Declarations.md#code_block) > *下标声明* → [*下标头（Head）*](./06_Declarations.md#subscript_head) [*下标结果（Result）*](./06_Declarations.md#subscript_result) [*代码块*](./06_Declarations.md#code_block)
> >
> *下标声明* → [*下标头（Head）*](./05_Declarations.md#subscript_head) [*下标结果（Result）*](./05_Declarations.md#subscript_result) [*getter-setter 块*](./05_Declarations.md#getter_setter_block) > *下标声明* → [*下标头（Head）*](./06_Declarations.md#subscript_head) [*下标结果（Result）*](./06_Declarations.md#subscript_result) [*getter-setter 块*](./06_Declarations.md#getter_setter_block)
> >
> *下标声明* → [*下标头（Head）*](./05_Declarations.md#subscript_head) [*下标结果（Result）*](./05_Declarations.md#subscript_result) [*getter-setter 关键字（Keyword）块*](./05_Declarations.md#getter_setter_keyword_block) > *下标声明* → [*下标头（Head）*](./06_Declarations.md#subscript_head) [*下标结果（Result）*](./06_Declarations.md#subscript_result) [*getter-setter 关键字（Keyword）块*](./06_Declarations.md#getter_setter_keyword_block)
> >
> *下标头（Head）* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*声明修改器（declaration-modifiers）*](./TODO) _可选_ **subscript** [*参数从句*](./05_Declarations.md#parameter_clause) > *下标头（Head）* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*声明修改器（declaration-modifiers）*](TODO) _可选_ **subscript** [*参数从句*](./06_Declarations.md#parameter_clause)
> >
> *下标结果（Result）* → **->** [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type) > *下标结果（Result）* → **->** [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type)
> >
<!-- --> <!-- -->
> 运算符声明语法 > 运算符声明语法
> >
> *运算符声明* → [*前置运算符声明*](./05_Declarations.md#prefix_operator_declaration) | [*后置运算符声明*](./05_Declarations.md#postfix_operator_declaration) | [*中置运算符声明*](./05_Declarations.md#infix_operator_declaration) > *运算符声明* → [*前置运算符声明*](./06_Declarations.md#prefix_operator_declaration) | [*后置运算符声明*](./06_Declarations.md#postfix_operator_declaration) | [*中置运算符声明*](./06_Declarations.md#infix_operator_declaration)
> >
> *前置运算符声明* → **prefix** **运算符** [*运算符*](./02_Lexical_Structure.md#operator) **{** **}** > *前置运算符声明* → **prefix** **运算符** [*运算符*](./02_Lexical_Structure.md#operator) **{** **}**
> >
> *后置运算符声明* → **postfix** **运算符** [*运算符*](./02_Lexical_Structure.md#operator) **{** **}** > *后置运算符声明* → **postfix** **运算符** [*运算符*](./02_Lexical_Structure.md#operator) **{** **}**
> >
> *中置运算符声明* → **infix** **运算符** [*运算符*](./02_Lexical_Structure.md#operator) **{** [*中置运算符属性集*](./05_Declarations.md#infix_operator_attributes) _可选_ **}** > *中置运算符声明* → **infix** **运算符** [*运算符*](./02_Lexical_Structure.md#operator) **{** [*中置运算符属性集*](./06_Declarations.md#infix_operator_attributes) _可选_ **}**
> >
> *中置运算符属性集* → [*优先级从句*](./05_Declarations.md#precedence_clause) _可选_ [*结和性从句*](./05_Declarations.md#associativity_clause) _可选_ > *中置运算符属性集* → [*优先级从句*](./06_Declarations.md#precedence_clause) _可选_ [*结和性从句*](./06_Declarations.md#associativity_clause) _可选_
> >
> *优先级从句* → **precedence** [*优先级水平*](./05_Declarations.md#precedence_level) > *优先级从句* → **precedence** [*优先级水平*](./06_Declarations.md#precedence_level)
> >
> *优先级水平* → 数值 0 到 255，首末项包括在内 > *优先级水平* → 数值 0 到 255，首末项包括在内
> >
> *结和性从句* → **associativity** [*结和性*](./05_Declarations.md#associativity) > *结和性从句* → **associativity** [*结和性*](./06_Declarations.md#associativity)
> >
> *结和性* → **left** | **right** | **none** > *结和性* → **left** | **right** | **none**
> >
@ -671,21 +671,21 @@
> 模式（Patterns）语法 > 模式（Patterns）语法
> >
> *模式* → [*通配符模式*](./07_Patterns.md#wildcard_pattern) [*类型注解*](./03_Types.md#type_annotation) _可选_ > *模式* → [*通配符模式*](./08_Patterns.md#wildcard_pattern) [*类型注解*](./03_Types.md#type_annotation) _可选_
> >
> *模式* → [*标识符模式*](./07_Patterns.md#identifier_pattern) [*类型注解*](./03_Types.md#type_annotati Value Bindingon ) _可选_ > *模式* → [*标识符模式*](./08_Patterns.md#identifier_pattern) [*类型注解*](./03_Types.md#type_annotati Value Bindingon ) _可选_
> >
> *模式* → [*值绑定模式*](./07_Patterns.md#value_binding_pattern) > *模式* → [*值绑定模式*](./08_Patterns.md#value_binding_pattern)
> >
> *模式* → [*元组模式*](./07_Patterns.md#tuple_pattern) [*类型注解*](./03_Types.md#type_annotation) _可选_ > *模式* → [*元组模式*](./08_Patterns.md#tuple_pattern) [*类型注解*](./03_Types.md#type_annotation) _可选_
> >
> *模式* → [*枚举个例模式*](./07_Patterns.md#enum_case_pattern) > *模式* → [*枚举个例模式*](./08_Patterns.md#enum_case_pattern)
> >
> *模式* → [*可选模式*](TODO) > *模式* → [*可选模式*](TODO)
> >
> *模式* → [*类型转换模式*](./07_Patterns.md#type_casting_pattern) > *模式* → [*类型转换模式*](./08_Patterns.md#type_casting_pattern)
> >
> *模式* → [*表达式模式*](./07_Patterns.md#expression_pattern) > *模式* → [*表达式模式*](./08_Patterns.md#expression_pattern)
> >
<!-- --> <!-- -->
@ -706,25 +706,25 @@
> 值绑定（Value Binding）模式语法 > 值绑定（Value Binding）模式语法
> >
> *值绑定模式* → **var** [*模式*](./07_Patterns.md#pattern) | **let** [*模式*](./07_Patterns.md#pattern) > *值绑定模式* → **var** [*模式*](./08_Patterns.md#pattern) | **let** [*模式*](./08_Patterns.md#pattern)
> >
<!-- --> <!-- -->
> 元组模式语法 > 元组模式语法
> >
> *元组模式* → **(** [*元组模式元素集*](./07_Patterns.md#tuple_pattern_element_list) _可选_ **)** > *元组模式* → **(** [*元组模式元素集*](./08_Patterns.md#tuple_pattern_element_list) _可选_ **)**
> >
> *元组模式元素集* → [*元组模式元素*](./07_Patterns.md#tuple_pattern_element) | [*元组模式元素*](./07_Patterns.md#tuple_pattern_element) **,** [*元组模式元素集*](./07_Patterns.md#tuple_pattern_element_list) > *元组模式元素集* → [*元组模式元素*](./08_Patterns.md#tuple_pattern_element) | [*元组模式元素*](./08_Patterns.md#tuple_pattern_element) **,** [*元组模式元素集*](./08_Patterns.md#tuple_pattern_element_list)
> >
> *元组模式元素* → [*模式*](./07_Patterns.md#pattern) > *元组模式元素* → [*模式*](./08_Patterns.md#pattern)
> >
<!-- --> <!-- -->
> 枚举用例模式语法 > 枚举用例模式语法
> >
> *enum-case-pattern* → [*类型标识*](./03_Types.md#type_identifier) _可选_ **.** [*枚举的 case 名*](./05_Declarations.md#enum_case_name) [*元组模式*](./07_Patterns.md#tuple_pattern) _可选_ > *enum-case-pattern* → [*类型标识*](./03_Types.md#type_identifier) _可选_ **.** [*枚举的 case 名*](./06_Declarations.md#enum_case_name) [*元组模式*](./08_Patterns.md#tuple_pattern) _可选_
> >
<!-- --> <!-- -->
@ -737,11 +737,11 @@
> 类型转换模式语法 > 类型转换模式语法
> >
> *类型转换模式（type-casting-pattern）* → [*is 模式*](./07_Patterns.md#is_pattern) | [*as 模式*](./07_Patterns.md#as_pattern) > *类型转换模式（type-casting-pattern）* → [*is 模式*](./08_Patterns.md#is_pattern) | [*as 模式*](./08_Patterns.md#as_pattern)
> >
> *is 模式* → **is** [*类型*](./03_Types.md#type) > *is 模式* → **is** [*类型*](./03_Types.md#type)
> >
> *as 模式* → [*模式*](./07_Patterns.md#pattern) **as** [*类型*](./03_Types.md#type) > *as 模式* → [*模式*](./08_Patterns.md#pattern) **as** [*类型*](./03_Types.md#type)
> >
<!-- --> <!-- -->
@ -756,21 +756,21 @@
> 属性语法 > 属性语法
> >
> *属性* → **@** [*属性名*](./06_Attributes.md#attribute_name) [*属性参数从句*](./06_Attributes.md#attribute_argument_clause) _可选_ > *属性* → **@** [*属性名*](./07_Attributes.md#attribute_name) [*属性参数从句*](./07_Attributes.md#attribute_argument_clause) _可选_
> >
> *属性名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *属性名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
> *属性参数从句* → **(** [*平衡令牌集*](./06_Attributes.md#balanced_tokens) _可选_ **)** > *属性参数从句* → **(** [*平衡令牌集*](./07_Attributes.md#balanced_tokens) _可选_ **)**
> >
> *属性（Attributes）集* → [*属性*](./06_Attributes.md#attribute) [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ > *属性（Attributes）集* → [*属性*](./07_Attributes.md#attribute) [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_
> >
> *平衡令牌集* → [*平衡令牌*](./06_Attributes.md#balanced_token) [*平衡令牌集*](./06_Attributes.md#balanced_tokens) _可选_ > *平衡令牌集* → [*平衡令牌*](./07_Attributes.md#balanced_token) [*平衡令牌集*](./07_Attributes.md#balanced_tokens) _可选_
> >
> *平衡令牌* → **(** [*平衡令牌集*](./06_Attributes.md#balanced_tokens) _可选_ **)** > *平衡令牌* → **(** [*平衡令牌集*](./07_Attributes.md#balanced_tokens) _可选_ **)**
> >
> *平衡令牌* → **[** [*平衡令牌集*](./06_Attributes.md#balanced_tokens) _可选_ **]** > *平衡令牌* → **[** [*平衡令牌集*](./07_Attributes.md#balanced_tokens) _可选_ **]**
> >
> *平衡令牌* → **{** [*平衡令牌集*](./06_Attributes.md#balanced_tokens) _可选_ **}** > *平衡令牌* → **{** [*平衡令牌集*](./07_Attributes.md#balanced_tokens) _可选_ **}**
> >
> *平衡令牌* → **任意标识符、关键字、字面量或运算符** > *平衡令牌* → **任意标识符、关键字、字面量或运算符**
> >
@ -782,7 +782,7 @@
> 表达式语法 > 表达式语法
> >
> *表达式* → [*try-operator*](./TODO) _可选_ [*前置表达式*](./04_Expressions.md#prefix_expression) [*二元表达式集*](./04_Expressions.md#binary_expressions) _可选_ > *表达式* → [*try-operator*](TODO) _可选_ [*前置表达式*](./04_Expressions.md#prefix_expression) [*二元表达式集*](./04_Expressions.md#binary_expressions) _可选_
> >
> *表达式集* → [*表达式*](./04_Expressions.md#expression) | [*表达式*](./04_Expressions.md#expression) **,** [*表达式集*](./04_Expressions.md#expression_list) > *表达式集* → [*表达式*](./04_Expressions.md#expression) | [*表达式*](./04_Expressions.md#expression) **,** [*表达式集*](./04_Expressions.md#expression_list)
> >
@ -810,9 +810,9 @@
> >
> *二元表达式* → [*二元运算符*](./02_Lexical_Structure.md#binary_operator) [*前置表达式*](./04_Expressions.md#prefix_expression) > *二元表达式* → [*二元运算符*](./02_Lexical_Structure.md#binary_operator) [*前置表达式*](./04_Expressions.md#prefix_expression)
> >
> *二元表达式* → [*赋值运算符*](./04_Expressions.md#assignment_operator) [*try 运算符*](./TODO) _可选_ [*前置表达式*](./04_Expressions.md#prefix_expression) > *二元表达式* → [*赋值运算符*](./04_Expressions.md#assignment_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](./04_Expressions.md#prefix_expression)
> >
> *二元表达式* → [*条件运算符*](./04_Expressions.md#conditional_operator) [*try 运算符*](./TODO) _可选_ [*前置表达式*](./04_Expressions.md#prefix_expression) > *二元表达式* → [*条件运算符*](./04_Expressions.md#conditional_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](./04_Expressions.md#prefix_expression)
> >
> *二元表达式* → [*类型转换运算符*](./04_Expressions.md#type_casting_operator) > *二元表达式* → [*类型转换运算符*](./04_Expressions.md#type_casting_operator)
> >
@ -850,7 +850,7 @@
> 主表达式语法 > 主表达式语法
> >
> *主表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_argument_clause) _可选_ > *主表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause) _可选_
> >
> *主表达式* → [*字面量表达式*](./04_Expressions.md#literal_expression) > *主表达式* → [*字面量表达式*](./04_Expressions.md#literal_expression)
> >
@ -920,15 +920,15 @@
> 闭包表达式语法 > 闭包表达式语法
> >
> *闭包表达式* → **{** [*闭包签名（Signational）*](./04_Expressions.md#closure_signature) _可选_ [*多条语句（Statements）*](./10_Statements.md#statements) **}** > *闭包表达式* → **{** [*闭包签名（Signational）*](./04_Expressions.md#closure_signature) _可选_ [*多条语句（Statements）*](./05_Statements.md#statements) **}**
> >
> *闭包签名（Signational）* → [*参数从句*](./05_Declarations.md#parameter_clause) [*函数结果*](./05_Declarations.md#function_result) _可选_ **in** > *闭包签名（Signational）* → [*参数从句*](./06_Declarations.md#parameter_clause) [*函数结果*](./06_Declarations.md#function_result) _可选_ **in**
> >
> *闭包签名（Signational）* → [*标识符集*](./02_Lexical_Structure.md#identifier_list) [*函数结果*](./05_Declarations.md#function_result) _可选_ **in** > *闭包签名（Signational）* → [*标识符集*](./02_Lexical_Structure.md#identifier_list) [*函数结果*](./06_Declarations.md#function_result) _可选_ **in**
> >
> *闭包签名（Signational）* → [*捕获（Capature）集*](./04_Expressions.md#capture_list) [*参数从句*](./05_Declarations.md#parameter_clause) [*函数结果*](./05_Declarations.md#function_result) _可选_ **in** > *闭包签名（Signational）* → [*捕获（Capature）集*](./04_Expressions.md#capture_list) [*参数从句*](./06_Declarations.md#parameter_clause) [*函数结果*](./06_Declarations.md#function_result) _可选_ **in**
> >
> *闭包签名（Signational）* → [*捕获（Capature）集*](./04_Expressions.md#capture_list) [*标识符集*](./02_Lexical_Structure.md#identifier_list) [*函数结果*](./05_Declarations.md#function_result) _可选_ **in** > *闭包签名（Signational）* → [*捕获（Capature）集*](./04_Expressions.md#capture_list) [*标识符集*](./02_Lexical_Structure.md#identifier_list) [*函数结果*](./06_Declarations.md#function_result) _可选_ **in**
> >
> *闭包签名（Signational）* → [*捕获（Capature）集*](./04_Expressions.md#capture_list) **in** > *闭包签名（Signational）* → [*捕获（Capature）集*](./04_Expressions.md#capture_list) **in**
> >
@ -1011,7 +1011,7 @@
> >
> *显示成员表达式* → [*后置表达式*](./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) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_argument_clause) _可选_ > *显示成员表达式* → [*后置表达式*](./04_Expressions.md#postfix_expression) **.** [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause) _可选_
> >
<!-- --> <!-- -->
@ -1282,21 +1282,21 @@
> 类型语法 > 类型语法
> >
> *类型* → [*数组类型*](./03_Types.md#array_type) | [*字典类型*](./TODO) | [*函数类型*](./03_Types.md#function_type) | [*类型标识符*](./03_Types.md#type_identifier) | [*元组类型*](./03_Types.md#tuple_type) | [*可选类型*](./03_Types.md#optional_type) | [*隐式解析可选类型*](./03_Types.md#implicitly_unwrapped_optional_type) | [*协议合成类型*](./03_Types.md#protocol_composition_type) | [*元型类型*](./03_Types.md#metatype_type) > *类型* → [*数组类型*](./03_Types.md#array_type) | [*字典类型*](TODO) | [*函数类型*](./03_Types.md#function_type) | [*类型标识符*](./03_Types.md#type_identifier) | [*元组类型*](./03_Types.md#tuple_type) | [*可选类型*](./03_Types.md#optional_type) | [*隐式解析可选类型*](./03_Types.md#implicitly_unwrapped_optional_type) | [*协议合成类型*](./03_Types.md#protocol_composition_type) | [*元型类型*](./03_Types.md#metatype_type)
> >
<!-- --> <!-- -->
> 类型注解语法 > 类型注解语法
> >
> *类型注解* → **:** [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type) > *类型注解* → **:** [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ [*类型*](./03_Types.md#type)
> >
<!-- --> <!-- -->
> 类型标识语法 > 类型标识语法
> >
> *类型标识* → [*类型名称*](./03_Types.md#type_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_argument_clause) _可选_ | [*类型名称*](./03_Types.md#type_name) [*泛型参数从句*](./GenericParametersAndArguments.md#generic_argument_clause) _可选_ **.** [*类型标识符*](./03_Types.md#type_identifier) > *类型标识* → [*类型名称*](./03_Types.md#type_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause) _可选_ | [*类型名称*](./03_Types.md#type_name) [*泛型参数从句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause) _可选_ **.** [*类型标识符*](./03_Types.md#type_identifier)
> >
> *类型名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *类型名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
@ -1311,7 +1311,7 @@
> >
> *元组类型的元素集* → [*元组类型的元素*](./03_Types.md#tuple_type_element) | [*元组类型的元素*](./03_Types.md#tuple_type_element) **,** [*元组类型的元素集*](./03_Types.md#tuple_type_element_list) > *元组类型的元素集* → [*元组类型的元素*](./03_Types.md#tuple_type_element) | [*元组类型的元素*](./03_Types.md#tuple_type_element) **,** [*元组类型的元素集*](./03_Types.md#tuple_type_element_list)
> >
> *元组类型的元素* → [*属性（Attributes）集*](./06_Attributes.md#attributes) _可选_ **inout** _可选_ [*类型*](./03_Types.md#type) | **inout** _可选_ [*元素名*](./03_Types.md#element_name) [*类型注解*](./03_Types.md#type_annotation) > *元组类型的元素* → [*属性（Attributes）集*](./07_Attributes.md#attributes) _可选_ **inout** _可选_ [*类型*](./03_Types.md#type) | **inout** _可选_ [*元素名*](./03_Types.md#element_name) [*类型注解*](./03_Types.md#type_annotation)
> >
> *元素名* → [*标识符*](./02_Lexical_Structure.md#identifier) > *元素名* → [*标识符*](./02_Lexical_Structure.md#identifier)
> >
@ -1374,7 +1374,7 @@
> 类型继承从句语法 > 类型继承从句语法
> >
> *类型继承从句* → **:** [*类条件（class-requirement）)*](./TODO) **,** [*类型继承集*](./03_Types.md#type_inheritance_list) > *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO) **,** [*类型继承集*](./03_Types.md#type_inheritance_list)
> >
> *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO) > *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO)
> >