Merge pull request #555 from 949478479/gh-pages

校对 Expressions
2015-12-05 17:29:40 +08:00
parent 06dcff66b8 425916bb60
commit fdb72ce038
4 changed files with 171 additions and 131 deletions
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@ -228,9 +228,7 @@ true			// 布尔值字面量

 字符串字面量由被包在双引号中的一串字符组成，形式如下：

-```swift
-"characters"
-```
+> "`字符`"

 字符串字面量中不能包含未转义的双引号（`"`）、未转义的反斜线（`\`）、回车符、换行符。

--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@ -107,7 +107,7 @@ var someValue: ExampleModule.MyType

 函数类型表示一个函数、方法或闭包的类型，它由参数类型和返回值类型组成，中间用箭头（`->`）隔开：

-`参数类型` -> `返回值类型`
+> `参数类型` -> `返回值类型`

 由于参数类型和返回值类型可以是元组类型，所以函数类型支持多参数与多返回值的函数与方法。

@ -131,7 +131,7 @@ var someValue: ExampleModule.MyType

 Swift 语言为标准库中定义的 `Array<Element>` 类型提供了如下语法糖：

-[`类型`]
+> [`类型`]

 换句话说，下面两个声明是等价的：

@ -161,7 +161,7 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

 Swift 语言为标准库中定义的 `Dictionary<Key, Value>` 类型提供了如下语法糖：

-[`键类型` : `值类型`]
+> [`键类型` : `值类型`]

 换句话说，下面两个声明是等价的：

@ -246,7 +246,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>

 协议合成类型的形式如下：

-protocol<`Protocol 1`, `Procotol 2`>
+> protocol<`Protocol 1`, `Procotol 2`>

 协议合成类型允许你指定一个值，其类型符合多个协议的要求且不需要定义一个新的命名型协议来继承它想要符合的各个协议。比如，协议合成类型 `protocol<Protocol A, Protocol B, Protocol C>` 等效于一个从 `Protocol A`，`Protocol B`， `Protocol C` 继承而来的新协议 `Protocol D`，很显然这样做有效率的多，甚至不需引入一个新名字。

--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@ -25,7 +25,7 @@
    - [super 表达式](#superclass_expression)
    - [闭包表达式](#closure_expression)
    - [隐式成员表达式](#implicit_member_expression)
-    - [括号表达式](#parenthesized_expression)
+    - [圆括号表达式](#parenthesized_expression)
    - [通配符表达式](#wildcard_expression)
 - [后缀表达式](#postfix_expressions)
    - [函数调用表达式](#function_call_expression) 
@ -56,7 +56,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表

 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Swift Standard Library Operators Reference*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_StandardLibrary_Operators/index.html#//apple_ref/doc/uid/TP40016054)。

-除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。 更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters).
+除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。 更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters)。

 > 前缀表达式语法  
 <a name="prefix-expression"></a>
@ -70,17 +70,17 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表

 try 表达式由 `try` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：

-try `可抛出错误的表达式`
+> try `可抛出错误的表达式`

 可选的 try 表达式由 `try?` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：

-try? `可抛出错误的表达式`
+> try? `可抛出错误的表达式`

 如果可抛出错误的表达式没有抛出错误，整个表达式返回的可选值将包含可抛出错误的表达式的返回值，否则，该可选值为 `nil`。

 强制的 try 表达式由 `try!` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：

-try! `可抛出错误的表达式`
+> try! `可抛出错误的表达式`

 如果可抛出错误的表达式抛出了错误，将会引发运行时错误。

@ -105,7 +105,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try

 二元表达式形式如下：

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

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

@ -128,7 +128,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try

 赋值表达式会为某个给定的表达式赋值，形式如下；

-`表达式` = `值`
+> `表达式` = `值`

 右边的值会被赋值给左边的表达式。如果左边表达式是一个元组，那么右边必须是一个具有同样元素个数的元组。嵌套元组也是允许的。

@ -148,7 +148,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try

 三元条件运算符会根据条件来对两个给定表达式中的一个进行求值，形式如下：

-`条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）`
+> `条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）`

 如果条件为真，那么对第一个表达式进行求值并返回结果。否则，对第二个表达式进行求值并返回结果。未使用的表达式不会进行求值。

@ -163,7 +163,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try

 有 4 种类型转换运算符：`is`、`as`、`? `和`!`。它们有如下的形式：

-`表达式` is `类型`  
+> `表达式` is `类型`  
 `表达式` as `类型`  
 `表达式` is? `类型`  
 `表达式` as! `类型`  
@ -205,74 +205,84 @@ f(x as Any)
 <a name="primary_expressions"></a>
 ## 基本表达式

-`主表达式`是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。
+基本表达式是最基本的表达式。 它们可以跟前缀表达式、二元表达式、后缀表达式以及其他基本表达式组合使用。

-> 主表达式语法  
-> *主表达式* → [*标识符*](LexicalStructure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
-> *主表达式* → [*字符型表达式*](../chapter3/04_Expressions.html#literal_expression)  
-> *主表达式* → [*self表达式*](../chapter3/04_Expressions.html#self_expression)  
-> *主表达式* → [*超类表达式*](../chapter3/04_Expressions.html#superclass_expression)  
-> *主表达式* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)  
-> *主表达式* → [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression)  
-> *主表达式* → [*隐式成员表达式*](../chapter3/04_Expressions.html#implicit_member_expression)  
-> *主表达式* → [*通配符表达式*](../chapter3/04_Expressions.html#wildcard_expression)  
+> 基本表达式语法  
+> *基本表达式* → [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub>  
+> *基本表达式* → [*字面量表达式*](#literal-expression)  
+> *基本表达式* → [*self表达式*](#self-expression)  
+> *基本表达式* → [*超类表达式*](#superclass-expression)  
+> *基本表达式* → [*闭包表达式*](#closure-expression)  
+> *基本表达式* → [*圆括号表达式*](#parenthesized-expression)  
+> *基本表达式* → [*隐式成员表达式*](#implicit-member-expression)  
+> *基本表达式* → [*通配符表达式*](#wildcard-expression)  

 <a name="literal_expression"></a>
 ### 字面量表达式

-由这些内容组成：普通的字符（string, number） , 一个字符的字典或者数组，或者下面列表中的特殊字符。
+字面量表达式可由普通字面量（例如字符串或者数字），字典或者数组字面量，或者下面列表中的特殊字面量组成：

-字符（Literal） | 类型（Type） | 值（Value）
------------- | ---------- | ----------
-/__FILE__ | String | 所在的文件名
-/__LINE__ | Int | 所在的行数
-/__COLUMN__ | Int | 所在的列数
-/__FUNCTION__ | String | 所在的function 的名字
+字面量 | 类型 | 值
+:------------- | :---------- | :----------
+`__FILE__` | `String` | 所在的文件名
+`__LINE__` | `Int` | 所在的行数
+`__COLUMN__` | `Int` | 所在的列数
+`__FUNCTION__` | `String` | 所在的声明的名字

-在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在特殊的成员如init/subscript中 会返回这个关键字的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
+对于 `__FUNCTION__`，在函数中会返回当前函数的名字，在方法中会返回当前方法的名字，在属性的存取器中会返回属性的名字，在特殊的成员如 `init` 或 `subscript` 中会返回这个关键字的名字，在某个文件中会返回当前模块的名字。
+
+`__FUNCTION__` 作为函数或者方法的默认参数值时，该字面量的值取决于函数或方法调用时所处的环境。

-当作为函数或者方法时，字符型表达式的值在被调用时初始化。
 ```swift
 func logFunctionName(string: String = __FUNCTION__) {
    print(string)
 }
 func myFunction() {
-    logFunctionName() // Prints "myFunction()".
+    logFunctionName() // 打印 “myFunction()”
 }
- 
 myFunction()
-namedArgs(1, withJay: 2)
 ```

-一个`array literal`，是一个有序的值的集合。 它的形式是：
+数组字面量是值的有序集合，形式如下：

-> [`value 1`, `value 2`, `...`]
+> [`值 1`, `值 2`, `...`]
+
+数组中的最后一个表达式可以紧跟一个逗号。数组字面量的类型是 `[T]`，这个 `T` 就是数组中元素的类型。如果数组中包含多种类型，`T` 则是跟这些类型最接近的的公共父类型。空数组字面量由一组方括号定义，可用来创建特定类型的空数组。

-数组中的最后一个表达式可以紧跟一个逗号（','）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共`supertype`最接近的type.空的`array literal`由一组方括号定义，可用来创建特定类型的空数组。
 ```swift
 var emptyArray: [Double] = []
 ```

-一个`dictionary literal` 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:
+字典字面量是一个包含无序键值对的集合，形式如下：

-> [`key 1`: `value 1`, `key 2`: `value 2`, `...`]
+> [`键 1` : `值 1`, `键 2` : `值 2`, `...`]

-dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary<KeyType, ValueType> （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.一个空的dictionary literal由方括号中加一个冒号组成，以此来与空array literal区分开，可以使用空的dictionary literal来创建特定类型的键值对。
+字典中的最后一个表达式可以紧跟一个逗号。字典字面量的类型是 `[Key : Value]`，`Key` 表示键的类型，`Value` 表示值的类型。如果字典中包含多种类型，那么 `Key` 表示的类型则为所有键最接近的公共父类型，`Value` 也是同样如此。一个空的字典字面量由方括号中加一个冒号组成（`[:]`），从而与空数组字面量区分开，可以使用空字典字面量来创建特定类型的字典。

 ```swift
-var emptyDictionary: [String: Double]=[:]
+var emptyDictionary: [String : Double] = [:]
 ```

 > 字面量表达式语法  
-> *字面量表达式* → [*字面量*](LexicalStructure.html#literal)  
-> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal)  
-> *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;**  
-> *数组字面量* → **[** [*数组字面量项列表*](../chapter3/04_Expressions.html#array_literal_items) _可选_ **]**  
-> *数组字面量项列表* → [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** [*数组字面量项列表*](../chapter3/04_Expressions.html#array_literal_items)  
-> *数组字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression)  
-> *字典字面量* → **[** [*字典字面量项列表*](../chapter3/04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
-> *字典字面量项列表* → [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项列表*](../chapter3/04_Expressions.html#dictionary_literal_items)  
-> *字典字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) **:** [*表达式*](../chapter3/04_Expressions.html#expression)  
+
+<a name="literal-expression"></a>
+> *字面量表达式* → [*字面量*](02_Lexical_Structure.md#literal)  
+> *字面量表达式* → [*数组字面量*](#array-literal) | [*字典字面量*](#dictionary-literal)  
+> *字面量表达式* → **\_\_FILE\_\_** | **\_\_LINE\_\_** | **\_\_COLUMN\_\_** | **\_\_FUNCTION\_\_**  
+
+<a name="array-literal"></a>
+> *数组字面量* → **[** [*数组字面量项列表*](#array-literal-items)<sub>可选</sub> **]**  
+<a name="array-literal-items"></a>
+> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**<sub>可选</sub> | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items)  
+<a name="array-literal-item"></a>
+> *数组字面量项* → [*表达式*](#expression)  
+
+<a name="dictionary-literal"></a>
+> *字典字面量* → **[** [*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]**  
+<a name="dictionary-literal-items"></a>
+> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**<sub>可选</sub> | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items)  
+<a name="dictionary-literal-item"></a>
+> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression)  

 <a name="self_expression"></a>
 ### self 表达式
@ -310,11 +320,12 @@ struct Point {
 }
 ```

-> Self 表达式语法  
-> *self表达式* → **self**  
-> *self表达式* → **self** **.** [*标识符*](LexicalStructure.html#identifier)  
-> *self表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
-> *self表达式* → **self** **.** **init**  
+> self 表达式语法  
+<a name="self-expression"></a>
+> *self 表达式* → **self**  
+> *self 表达式* → **self** **.** [*标识符*](02_Lexical_Structure.md#identifier)  
+> *self 表达式* → **self** **[** [*表达式*](#expression) **]**  
+> *self 表达式* → **self** **.** **init**  

 <a name="superclass_expression"></a>
 ### super 表达式
@ -329,10 +340,14 @@ struct Point {

 子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。

-> 超类(superclass)表达式语法  
-> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)  
+> super 表达式语法  
+<a name="superclass-expression"></a>
+> *super 表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)  
+<a name="superclass-method-expression"></a>
 > *超类方法表达式* → **super** **.** [*标识符*](LexicalStructure.html#identifier)  
+<a name="superclass-subscript-expression"></a>
 > *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
+<a name="superclass-initializer-expression"></a>
 > *超类构造器表达式* → **super** **.** **init**  

 <a name="closure_expression"></a>
@ -396,14 +411,25 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
 关于闭包表达式的更多信息和例子，请参见： [Closure Expressions](TODO：添加链接)，关于更多参数列表的信息和例子，请参见： [Resolving Strong Reference Cycles for Closures](TODO：添加链接)。

 > 闭包表达式语法  
-> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}**  
-> *闭包签名(Signational)* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+
+<a name="closure-expression"></a>
+> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature)<sub>可选</sub> [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}**  
+
+<a name="closure-signature"></a>
+> *闭包签名(Signational)* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**  
+> *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**  
 > *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) **in**  
-> *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
-> *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**  
+
+<a name="capture-list"></a>
+> *捕获列表* → **[** [*捕获说明符*](#capture-specifier) [*表达式*](#expression) **]**  
+<a name="capture-list-items"></a>
+> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items)
+<a name="capture-list-item"></a>
+> *捕获列表项* → [*捕获说明符*](#capture-specifier)<sub>可选</sub> [*表达式*](#expression)
+<a name="capture-specifier"></a>
+> *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**  

 <a name="implicit_member_expression"></a>
 ### 隐式成员表达式
@ -420,10 +446,11 @@ x = .AnotherValue
 ```

 > 隐式成员表达式语法  
+<a name="implicit-member-expression"></a>
 > *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  

 <a name="parenthesized_expression"></a>
-### 括号表达式
+### 圆括号表达式

 圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下：

@ -431,10 +458,14 @@ x = .AnotherValue

 圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）

-> 圆括号表达式(Parenthesized Expression)语法  
-> *圆括号表达式* → **(** [*表达式元素列表*](../chapter3/04_Expressions.html#expression_element_list) _可选_ **)**  
-> *表达式元素列表* → [*表达式元素*](../chapter3/04_Expressions.html#expression_element) | [*表达式元素*](../chapter3/04_Expressions.html#expression_element) **,** [*表达式元素列表*](../chapter3/04_Expressions.html#expression_element_list)  
-> *表达式元素* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **:** [*表达式*](../chapter3/04_Expressions.html#expression)  
+> 圆括号表达式语法  
+<a name="parenthesized-expression"></a>
+> *圆括号表达式* → **(** [*表达式元素列表*](#expression-element-list)<sub>可选</sub> **)**  
+<a name="expression-element-list"></a>
+> *表达式元素列表* → [*表达式元素*](#expression-element) | [*表达式元素*](#expression-element) **,** [*表达式元素列表*](#expression-element-list)  
+<a name="expression-element"></a>
+> *表达式元素* → [*表达式*](#expression) | [*标识符*](02_Lexical_Structure.md#identifier) **:** [*表达式*](#expression)  
+
 <a name="wildcard_expression"></a>
 ### 通配符表达式

@ -446,6 +477,7 @@ x = .AnotherValue
 ```

 > 通配符表达式语法  
+<a name="wildcard-expression"></a>
 > *通配符表达式* → **_**  

 <a name="postfix_expressions"></a>
@ -704,6 +736,6 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects()
 // someDictionary is now [b: [10, 20], a: [42, 2, 3]]
 ```

-
 > 可选链表达式语法  
-> *可选链表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **?**  
+<a name="optional-chaining-expression"></a>
+> *可选链表达式* → [*后缀表达式*](#postfix-expression) **?**  
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@ -11,27 +11,28 @@
 本页包含内容：

 - [泛型形参子句](#generic_parameter)
+    - [Where 子句](#where_clauses)
 - [泛型实参子句](#generic_argument)

-本节涉及泛型类型、泛型函数以及泛型初始化器（**initializer**）的参数，包括形参和实参。声明泛型类型、函数或初始化器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型初始化器时，就用具体的类型实参替代之。
+本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。

-关于 Swift 语言的泛型概述，见[泛型](../chapter2/23_Generics.md)(第二部分第23章)。
+关于 Swift 语言的泛型概述，请参阅 [泛型](../chapter2/23_Generics.md)。

 <a name="generic_parameter"></a>
 ## 泛型形参子句

-泛型形参子句指定泛型类型或函数的类型形参，以及这些参数的关联约束和关联类型要求（**requirement**）。泛型形参子句用尖括号（<>）包住，并且有以下两种形式：
+泛型形参子句指定泛型类型或函数的类型形参，以及这些参数相关的约束和要求。泛型形参子句用尖括号（`<>`）包住，并且有以下两种形式：

 > <`泛型形参列表`>  
-> <`泛型形参列表` where `关联类型要求`>
+> <`泛型形参列表` where `类型要求`>

 泛型形参列表中泛型形参用逗号分开，其中每一个采用以下形式：

 > `类型形参` : `约束`

-泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如 T，U，V，Key，Value 等）的名字而已。你可以在泛型类型、函数的其余部分或者初始化器声明，包括函数或初始化器的签名中使用它（与其任何相关类型）。
+泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如 `T`，`U`，`V`，`Key`，`Value` 等）的名字而已。你可以在泛型类型、函数的其余部分或者构造器声明，包括函数或构造器的签名中使用它（以及它的关联类型）。

-约束用于指明该类型形参继承自某个类或者遵守某个协议或协议的一部分。例如，在下面的泛型函数中，泛型形参`T: Comparable`表示任何用于替代类型形参`T`的类型实参必须满足`Comparable`协议。
+约束用于指明该类型形参继承自某个类或者符合某个协议或协议组合。例如，在下面的泛型函数中，泛型形参 `T: Comparable` 表示任何用于替代类型形参 `T` 的类型实参必须满足 `Comparable` 协议。


 ```swift
@ -43,74 +44,83 @@ func simpleMax<T: Comparable>(x: T, _ y: T) -> T {
 }
 ```

+例如，因为 `Int` 和 `Double` 均满足`Comparable`协议，所以该函数可以接受这两种类型。与泛型类型相反，调用泛型函数或构造器时不需要指定泛型实参子句。类型实参由传递给函数或构造器的实参推断而出。

-
-如，`Int`和`Double`均满足`Comparable`协议，该函数接受任何一种类型。与泛型类型相反，调用泛型函数或初始化器时不需要指定泛型实参子句。类型实参由传递给函数或初始化器的实参推断而出。
-
-
-```
-simpleMax(17, 42) // T被推断出为Int类型
-simpleMax(3.14159, 2.71828) // T被推断出为Double类型
+```swift
+simpleMax(17, 42) // T 被推断为 Int 类型
+simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型
 ```

-## Where 子句
+<a name="where_clauses"></a>
+### Where 子句

-要想对类型形参及其关联类型指定额外关联类型要求，可以在泛型形参列表之后添加`where`子句。`where`子句由关键字`where`及其后的用逗号分割的多个关联类型要求组成。
+要想对类型形参及其关联类型指定额外要求，可以在泛型形参列表之后添加 `where` 子句。`where` 子句由关键字 `where` 及其后的用逗号分隔的一个或多个要求组成。

-`where`子句中的关联关系用于指明该类型形参继承自某个类或遵守某个协议或协议的一部分。尽管`where`子句提供了语法糖使其有助于表达类型形参上的简单约束（如`T: Comparable`等同于`T where T: Comparable`，等等），但是依然可以用来对类型形参及其关联类型提供更复杂的约束。如，`<T where T: C, T: P>`表示泛型类型`T`继承自类`C`且遵守协议`P`。
+`where` 子句中的要求用于指明该类型形参继承自某个类或符合某个协议或协议组合。尽管 `where` 子句提供了语法糖使其有助于表达类型形参上的简单约束（如 `T: Comparable` 等同于 `T where T: Comparable`，等等），但是依然可以用来对类型形参及其关联类型提供更复杂的约束。如，`<T where T: C, T: P>` 表示泛型类型 `T` 继承自类 `C` 且符合协议 `P`。

-如上所述，可以强制约束类型形参的关联类型遵守某个协议。例如`<T: Generator where T.Element: Equatable>`表示`T`遵守`Generator`协议，而且`T`的关联类型`T.Element`遵守`Eauatable`协议（`T`有关联类型`Element`是因为`Generator`声明了`Element`，而`T`遵守`Generator`协议）。
+如上所述，可以强制约束类型形参的关联类型符合某个协议。例如 `<S: SequenceType where S.Generator.Element: Equatable>` 表示 `S` 符合 `SequenceType` 协议，而且 `S` 的关联类型 `S.Generator.Element` 符合 `Eauatable` 协议。这种约束确保了序列中的每个元素都是符合 `Equatable` 协议的。

-也可以用操作符`==`来指定两个类型等效的关联关系。例如，有这样一个约束：`T`和`U`遵守`Generator`协议，同时要求它们的关联类型等同，可以这样来表达：`<T: Generator, U: Generator where T.Element == U.Element>`。
+也可以用操作符 `==` 来指定两个类型必须相同。例如，泛型形参子句 `<S1: SequenceType, S2: SequenceType where S1.Generator.Element == S2.Generator.Element>` 表示 `S1` 和 `S2` 必须都符合 `SequenceType` 协议，而且两个序列中的元素类型必须相同。

-当然，替代类型形参的类型实参必须满足所有类型形参的约束和关联类型要求。
+当然，替代类型形参的类型实参必须满足所有的约束和要求。

-泛型函数或初始化器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或关联类型要求，抑或二者皆不同。当调用重载的泛型函数或始化器时，编译器会用这些约束来决定调用哪个重载函数或始化器。
+泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会根据这些约束来决定调用哪个重载函数或构造器。


 > 泛型形参子句语法  
-> *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**  
-> *泛型参数列表* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list)  
-> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name)  
-> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
-> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)  
-> *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list)  
-> *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list)  
-> *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement)  
-> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
-> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)  
-> *同类型约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **==** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
+
+<a name="generic-parameter-clause"></a>
+> *泛型形参子句* → **<** [*泛型形参列表*](#generic-parameter-list) [*约束子句*](#requirement-clause)<sub>可选</sub> **>**  
+<a name="generic-parameter-list"></a>
+> *泛型形参列表* → [*泛形形参*](#generic-parameter) | [*泛形形参*](#generic-parameter) **,** [*泛型形参列表*](#generic-parameter-list)  
+<a name="generic-parameter"></a>
+> *泛形形参* → [*类型名称*](03_Types.html#type-name)  
+> *泛形形参* → [*类型名称*](03_Types.html#type-name) **:** [*类型标识符*](03_Types.html#type-identifier)  
+> *泛形形参* → [*类型名称*](03_Types.html#type-name) **:** [*协议合成类型*](03_Types.html#protocol-composition-type)  
+
+<a name="requirement-clause"></a>
+> *约束子句* → **where** [*约束列表*](#requirement-list)  
+<a name="requirement-list"></a>
+> *约束列表* → [*约束*](#requirement) | [*约束*](#requirement) **,** [*约束列表*](#requirement-list)  
+<a name="requirement"></a>
+> *约束* → [*一致性约束*](#conformance-requirement) | [*同类型约束*](#same-type-requirement)  
+
+<a name="conformance-requirement"></a>
+> *一致性约束* → [*类型标识符*](03_Types.html#type-identifier) **:** [*类型标识符*](03_Types.html#type-identifier)  
+> *一致性约束* → [*类型标识符*](03_Types.html#type-identifier) **:** [*协议合成类型*](03_Types.html#protocol-composition-type)  
+<a name="same-type-requirement"></a>
+> *同类型约束* → [*类型标识符*](03_Types.html#type-identifier) **==** [*类型*](03_Types.html#type)  


 <a name="generic_argument"></a>
 ## 泛型实参子句

-泛型实参子句指定_泛型类型_的类型实参。泛型实参子句用尖括号（<>）包住，形式如下：
+泛型实参子句指定泛型类型的类型实参。泛型实参子句用尖括号（`<>`）包住，形式如下：

 > <`泛型实参列表`>

-泛型实参列表中类型实参有逗号分开。类型实参是实际具体类型的名字，用来替代泛型类型的泛型形参子句中的相应的类型形参。从而得到泛型类型的一个特化版本。如，Swift标准库的泛型字典类型定义如下：
-
+泛型实参列表中类型实参用逗号分开。类型实参是实际具体类型的名字，用来替代泛型类型的泛型形参子句中的相应的类型形参。从而得到泛型类型的一个特化版本。例如，Swift 标准库中的泛型字典类型定义如下：

 ```swift
-struct Dictionary<KeyTypel: Hashable, ValueType>: Collection, DictionaryLiteralConvertible {
-
-    /* .. */
-
+struct Dictionary<Key: Hashable, Value>: CollectionType, DictionaryLiteralConvertible {
+    /* ... */
 }
 ```

-泛型`Dictionary`类型的特化版本，`Dictionary<String, Int>`就是用具体的`String`和`Int`类型替代泛型类型`KeyType: Hashable`和`ValueType`产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何`where`子句所指定的额外的关联类型要求。上面的例子中，类型形参`Key`类型要求满足`Hashable`协议，因此`String`也必须满足`Hashable`协议。
+泛型 `Dictionary` 类型的特化版本，`Dictionary<String, Int>` 就是用具体的 `String` 和 `Int` 类型替代泛型类型 `Key: Hashable` 和 `Value` 产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何 `where` 子句所指定的额外的关联类型要求。上面的例子中，类型形参 `Key` 的类型必须符合 `Hashable` 协议，因此 `String` 也必须满足 `Hashable` 协议。

-可以用本身就是泛型类型的特化版本的类型实参替代类型形参（假设已满足合适的约束和关联类型要求）。例如，为了生成一个元素类型是整型数组的数组，可以用数组的特化版本`Array<Int>`替代泛型类型`Array<T>`的类型形参 `T` 来实现。
+可以用本身就是泛型类型的特化版本的类型实参替代类型形参（假设已满足合适的约束和关联类型要求）。例如，为了生成一个元素类型是整型数组的数组，可以用数组的特化版本 `Array<Int>` 替代泛型类型 `Array<T>` 的类型形参 `T` 来实现。

-```
+```swift
 let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 ```

-如[泛型形参子句](#generic_parameter)所述，不能用泛型实参子句来指定泛型函数或初始化器的类型实参。
+如 [泛型形参子句](#generic_parameter) 所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。

 > 泛型实参子句语法  
-> *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>**  
-> *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list)  
-> *泛型参数* → [*类型*](../chapter3/03_Types.html#type)  
+<a name="generic-argument-clause"></a>
+> *泛型实参子句* → **<** [*泛型实参列表*](#generic-argument-list) **>**  
+<a name="generic-argument-list"></a>
+> *泛型实参列表* → [*泛型实参*](#generic-argument) | [*泛型实参*](#generic-argument) **,** [*泛型实参列表*](#generic-argument-list)  
+<a name="generic-argument"></a>
+> *泛型实参* → [*类型*](03_Types.html#type)