update Types

source/chapter3/03_Types.md

@@ -14,30 +14,31 @@ Swift 语言存在两种类型：命名型类型和复合型类型。*命名型
 
 > 类型语法
 > 
-> *类型* → [*数组类型*](#array-type)
+> *类型* → [函数类型](#function-type)
 > 
-> *类型* → [*字典类型*](#dictionary-type)
+> *类型* → [数组类型](#array-type)
 > 
-> *类型* → [*函数类型*](#function-type)
+> *类型* → [字典类型](#dictionary-type)
 > 
-> *类型* → [*类型标识*](#type-identifier)
+> *类型* → [类型标识](#type-identifier)
 > 
-> *类型* → [*元组类型*](#tuple-type)
+> *类型* → [元组类型](#tuple-type)
 > 
-> *类型* → [*可选类型*](#optional-type)
+> *类型* → [可选类型](#optional-type)
 > 
-> *类型* → [*隐式解析可选类型*](#implicitly-unwrapped-optional-type)
+> *类型* → [隐式解析可选类型](#implicitly-unwrapped-optional-type)
 > 
-> *类型* → [*协议合成类型*](#protocol-composition-type)
+> *类型* → [协议合成类型](#protocol-composition-type)
 > 
-> *类型* → [*元型类型*](#metatype-type)
+> *类型* →[不透明类型](#opaque-type)
 > 
-> *类型* → **任意类型**
+> *类型* → [元型类型](#metatype-type)
 > 
-> *类型* → **自身类型**
+> *类型* → [自身类型](#self-type)
 > 
-> *类型* → [*(类型)*](#type)
+> *类型* → **Any**
 > 
+> *类型* → **（** [类型](#type) **）**
 
 ## 类型注解 {#type-annotation}
 *类型注解*显式地指定一个变量或表达式的类型。类型注解始于冒号 `:` 终于类型，比如下面两个例子：
@@ -56,10 +57,9 @@ func someFunction(a: Int) { /* ... */ }
 
 #### type-annotation {#type-annotation}
 > *类型注解* → **:** [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **输入输出参数**<sub>可选</sub> [*类型*](#type)
-> 
 
 ## 类型标识符 {#type-identifier}
-类型标识符引用命名型类型，还可引用命名型或复合型类型的别名。
+*类型标识符*引用命名型类型，还可引用命名型或复合型类型的别名。
 
 大多数情况下，类型标识符引用的是与之同名的命名型类型。例如类型标识符 `Int` 引用命名型类型 `Int`，同样，类型标识符 `Dictionary<String, Int>` 引用命名型类型 `Dictionary<String, Int>`。
 
@@ -85,10 +85,9 @@ var someValue: ExampleModule.MyType
 
 #### type-name {#type-name}
 > *类型名称* → [*标识符*](./02_Lexical_Structure.md#identifier)
-> 
 
 ## 元组类型 {#tuple-type}
-元组类型是使用括号括起来的零个或多个类型，类型间用逗号隔开。
+*元组类型*是使用括号括起来的零个或多个类型，类型间用逗号隔开。
 
 你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符紧跟一个冒号 `(:)` 组成。[函数和多返回值](../chapter2/06_Functions.md#functions_with_multiple_return_values) 章节里有一个展示上述特性的例子。
 
@@ -123,7 +122,7 @@ someTuple = (left: 5, right: 5)  // 错误：命名类型不匹配
 > 
 
 ## 函数类型 {#function-type}
-函数类型表示一个函数、方法或闭包的类型，它由参数类型和返回值类型组成，中间用箭头（`->`）隔开：
+*函数类型*表示一个函数、方法或闭包的类型，它由参数类型和返回值类型组成，中间用箭头（`->`）隔开：
 
 > （`参数类型`）->（`返回值类型`）
 
@@ -347,12 +346,11 @@ let implicitlyUnwrappedArray: [Int]!                  // 正确
 > 
 
 ## 协议合成类型 {#protocol-composition-type}
-协议合成类型定义了一种遵循协议列表中每个指定协议的类型，或者一个现有类型的子类并遵循协议列表中每个指定协议。协议合成类型只能用在类型注解、泛型参数子句和泛型 `where` 子句中指定类型。
+*协议合成类型*定义了一种遵循协议列表中每个指定协议的类型，或者一个现有类型的子类并遵循协议列表中每个指定协议。协议合成类型只能用在类型注解、泛型参数子句和泛型 `where` 子句中指定类型。
 
 协议合成类型的形式如下：
 
 > `Protocol 1` & `Procotol 2`
-> 
 
 协议合成类型允许你指定一个值，其类型遵循多个协议的要求而不需要定义一个新的命名型协议来继承它想要符合的各个协议。比如，协议合成类型 `Protocol A & Protocol B & Protocol C` 等效于一个从 `Protocol A`，`Protocol B`，`Protocol C` 继承而来的新协议。同样的，你可以使用 `SuperClass & ProtocolA` 来取代申明一个新的协议作为 `SuperClass` 的子类并遵循 `ProtocolA`。
 
@@ -378,10 +376,34 @@ typealias PQR = PQ & Q & R
 
 #### protocol-composition-continuation {#protocol-composition-continuation}
 > *协议合成延续* → [*协议标识符*](#protocol-identifier) | [*协议合成类型*](#protocol-composition-type)
-> 
+
+## 不透明类型
+
+*不透明类型*定义了遵循某个协议或者合成协议的类型，但不需要指明底层的具体类型。
+
+不透明类型可以作为函数或下标的返回值，或属性的类型使用。
+
+不透明类型不能作为元组类型的一部分或范型类型使用，比如数组元素类型或者可选值的包装类型。
+
+不透明类型的形式如下：
+
+> some `constraint`
+
+*constraint* 可以是类类型，协议类型，协议组合类型或者 `Any`。值只有当它遵循上述协议或者组合协议，或者从上述的类继承的时候，才能作为这个不透明类型的实例使用。和不透明值交互的代码只能用该值定义在 *constraint* 上的接口。
+
+协议声明里不能包括不透明类型。类不能使用不透明类型作为非 final 方法的返回值。
+
+使用不透明类型作为返回值的函数必须返回同样的的单一底层类型。返回的类型可以包含函数范型类型参数的一部分。举个例子，函数 `someFunction<T>()` 可以返回类型 `T` 或者 `Dictionary<String,T>` 的值。
+
+> 不透明类型语法
+
+#### opaque-type {#opaque-type}
+
+> *不透明类型* → **some** [type](#type)
 
 ## 元类型 {#metatype-type}
-元类型是指任意类型的类型，包括类类型、结构体类型、枚举类型和协议类型。
+
+*元类型*是指任意类型的类型，包括类类型、结构体类型、枚举类型和协议类型。
 
 类、结构体或枚举类型的元类型是相应的类型名紧跟 `.Type`。协议类型的元类型——并不是运行时遵循该协议的具体类型——是该协议名字紧跟 `.Protocol`。比如，类 `SomeClass` 的元类型就是 `SomeClass.Type`，协议 `SomeProtocol` 的元类型就是 `SomeProtocal.Protocol`。
 
@@ -428,10 +450,48 @@ let anotherInstance = metatype.init(string: "some string")
 
 #### metatype-type {#metatype-type}
 > *元类型* → [*类型*](#type) **.** **Type** | [*类型*](#type) **.** **Protocol**
-> 
+
+## 自身类型
+
+`Self` 类型不是具体的类型，而是让你更方便的引用当前类型，不需要重复或者知道该类的名字。
+
+在协议声明或者协议成员声明时，`Self` 类型引用的是最终遵循该协议的类型。
+
+在结构体，类或者枚举值声明时，`Self` 类型引用的是声明的类型。在类型成员声明时，`Self` 类型引用的是该类型。在类成员声明时，`Self` 可以在方法的返回值和方法体中使用，但不能在其他上下文中使用。举个例子，下面的代码演示了返回值是 `Self` 的实例方法 `f` 。
+
+```swift
+class Superclass {
+    func f() -> Self { return self }
+}
+let x = Superclass()
+print(type(of: x.f()))
+// 打印 "Superclass"
+
+class Subclass: Superclass { }
+let y = Subclass()
+print(type(of: y.f()))
+// 打印 "Subclass"
+
+let z: Superclass = Subclass()
+print(type(of: z.f()))
+// 打印 "Subclass"
+```
+
+上面例子中的最后一部分表明 `Self` 引用的是值 `z` 的运行时类型 `Subclass` ，而不是变量本身的编译时类型 `Superclass` 。
+
+在嵌套类型声明时，`Self` 类型引用的是最内层的声明的类型。
+
+`Self` 类型引用的类型和 Swift 标准库中 `type(of:)` 函数的结果一样。使用 `Self.someStaticMember` 访问当前类型中的成员和使用 `type(of: self).someStaticMember` 是一样的。
+
+> 自身类型语法
+
+#### self-type{#type}
+
+> *自身类型* → **Self**
 
 ## 类型继承子句 {#type-inheritance-clause}
-类型继承子句被用来指定一个命名型类型继承自哪个类、采纳哪些协议。类型继承子句开始于冒号 `:`，其后是类型标识符列表。
+
+*类型继承子句*被用来指定一个命名型类型继承自哪个类、采纳哪些协议。类型继承子句开始于冒号 `:`，其后是类型标识符列表。
 
 类可以继承自单个超类，并遵循任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要遵循的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，请参阅 [继承](../chapter2/13_Inheritance.md)。
 
@@ -454,7 +514,7 @@ let anotherInstance = metatype.init(string: "some string")
 
 
 ## 类型推断 {#type-inference}
-Swift 广泛使用类型推断，从而允许你省略代码中很多变量和表达式的类型或部分类型。比如，对于 `var x: Int = 0`，你可以完全省略类型而简写成 `var x = 0`，编译器会正确推断出 `x` 的类型 `Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以省略类型的一部分。比如，如果你写了 `let dict: Dictionary = ["A" : 1]`，编译器能推断出 `dict` 的类型是 `Dictionary<String, Int>`。
+Swift 广泛使用*类型推断*，从而允许你省略代码中很多变量和表达式的类型或部分类型。比如，对于 `var x: Int = 0`，你可以完全省略类型而简写成 `var x = 0`，编译器会正确推断出 `x` 的类型 `Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以省略类型的一部分。比如，如果你写了 `let dict: Dictionary = ["A" : 1]`，编译器能推断出 `dict` 的类型是 `Dictionary<String, Int>`。
 
 在上面的两个例子中，类型信息从表达式树的叶子节点传向根节点。也就是说，`var x: Int = 0` 中 `x` 的类型首先根据 `0` 的类型进行推断，然后将该类型信息传递到根节点（变量 `x`）。