add list, modify a to -3

source/chapter1/02_a_swift_tour.md

@@ -257,7 +257,7 @@
 
 有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
 
-你可以获取参数的数量——这个方法在非常短的闭包中很有用。一个被作为最后一个参数传入函数的时候可以直接出现在括号后面。
+你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。
 
     sort([1, 5, 3, 12, 2]) { $0 > $1 }
 

source/chapter2/01_The_Basics.md

@@ -301,8 +301,10 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
     let integerPi = Int(pi)
     // integerPi 等于 3，所以被推测为 Int 类型
 
+<<<<<<< HEAD
 当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说`4.75`会变成`4`，`-3.9`会变成`-3`。
+=======
 
 > 注意：结合数字类常量和变量不同于结合数字类原始值。原始值`3`可以直接和原始值`0.14159`相加，因为数字原始值本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。
 
-=======
+=======

source/chapter2/03_Strings_and_Characters.md

@@ -1,22 +1,30 @@
 # 字符串和字符 (Strings and Characters)
 
-**String** 是一个有序的字符集合，例如 "hello, world", "albatross"。Swift 字符串通过 **String** 类型来表示，也可以表示为 **Character** 类型值的集合。
+**String** 是一个有序的字符集合，例如 "hello, world", "albatross"。
+Swift 字符串通过 **String** 类型来表示，也可以表示为 **Character** 类型值的集合。
 
-Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。创建和操作字符串的语法与 C的操作方式相似，轻量并且易读。字符串连接操作只需要简单地通过 `+` 号将两个字符串相连即可。与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
+Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
+创建和操作字符串的语法与 C的操作方式相似，轻量并且易读。
+字符串连接操作只需要简单地通过 `+` 号将两个字符串相连即可。
+与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
 
-尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。每一个字符串都是由独立编码的 Unicode 字符组成，并提供了用于访问这些字符在不同的Unicode表示的支持。
+尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。
+每一个字符串都是由独立编码的 Unicode 字符组成，并提供了用于访问这些字符在不同的Unicode表示的支持。
 
 **String** 也可以用于在常量、变量、字面量和表达式中进行字符串插值，这使得创建用于展示、存储和打印的字符串变得轻松自如。
 
 > 注意：
 > 
-> Swift 的 **String** 类型与 Foundation NSString 类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作，整个 NSString API 都可以调用您创建的任意 String 类型的值，您额外还可以在任意 API 中使用本章介绍的 **String** 特性。您也可以在任意要求传入NSString 实例作为参数的 API 中使用 **String** 类型的值进行替换。
+> Swift 的 **String** 类型与 Foundation NSString 类进行了无缝桥接。
+> 如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作，整个 NSString API 都可以调用您创建的任意 String 类型的值，您额外还可以在任意 API 中使用本章介绍的 **String** 特性。
+> 您也可以在任意要求传入NSString 实例作为参数的 API 中使用 **String** 类型的值进行替换。
 >
 >更多关于在 Foundation 和 Cocoa 中使用 **String** 的信息请查看 [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
 
 ### 字符串字面量
 
-您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。
+您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
+字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。
 
 字符串字面量可以用于为常量和变量提供初始值。
 
@@ -49,7 +57,8 @@ let sparklingHeart = "\U0001F496"  // 💖, Unicode scalar U+1F496
 
 ### 初始化空字符串
 
-为了构造一个很长的字符串，可以创建一个空字符串作为初始值。可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
+为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
+可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
 
 ```
 var emptyString = ""               // empty string literal
@@ -85,19 +94,25 @@ constantString += " and another Highlander"
 
 ### 字符串是值类型
 
-Swift 的 **String** 类型是值类型。如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值。值类型在 [Structures and Enumerations Are Value Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104) 中进行了说明。
+Swift 的 **String** 类型是值类型。
+如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。
+任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值。
+值类型在 [Structures and Enumerations Are Value Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104) 中进行了说明。
 
 > 注意：
 >
-> 与 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用。除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。
+> 与 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用，除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。
 
-Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。您可以放心您传递的字符串本身不会被更改。
+Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。
+您可以放心您传递的字符串本身不会被更改。
 
 在实际编译时，Swift编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您始终可以将字符串作为值类型的同时获得极高的性能。
 
 #### 使用字符(Characters)
 
-Swift 的 **String** 类型表示特定序列的字符值的集合。每一个字符值代表一个 Unicode 字符。您可利用 for-in 循环来遍历字符串中的每一个字符：
+Swift 的 **String** 类型表示特定序列的字符值的集合。
+每一个字符值代表一个 Unicode 字符。
+您可利用 for-in 循环来遍历字符串中的每一个字符：
 
 ```
 for character in "Dog!🐶" {
@@ -128,11 +143,16 @@ println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
 // prints "unusualMenagerie has 40 characters"
 ```
 
->注意：
+> 注意：
 >
->不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储，所以Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此，字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意 `countElements` 函数必须遍历字符串中的字符以精准计算字符串的长度。
+> 不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。
+> 所以Swift 中的字符在一个字符串中并不一定占用相同的内存空间。
+> 因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。
+> 如果您正在处理一个长字符串，需要注意 `countElements` 函数必须遍历字符串中的字符以精准计算字符串的长度。
 >
->另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
+> 另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。
+> NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。
+> 为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
 
 ### 连接字符串和字符
 
@@ -168,7 +188,8 @@ welcome += character1
 
 ### 字符串插值
 
-字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
+字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。
+您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
 
 ```
 let multiplier = 3
@@ -176,9 +197,12 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 // message is "3 times 2.5 is 7.5"
 ```
 
-在上面的例子中，`multiplier` 作为 `\(multiplier)` 被插入到一个字符串字面量中。当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。
+在上面的例子中，`multiplier` 作为 `\(multiplier)` 被插入到一个字符串字面量中。
+当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。
 
-`multiplier` 的值也作为字符串中后面表达式的一部分。该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (7.5) 插入到字符串中。在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。
+`multiplier` 的值也作为字符串中后面表达式的一部分。
+该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (7.5) 插入到字符串中。
+在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。
 
 >注意：
 >
@@ -203,7 +227,9 @@ if quotation == sameQuotation {
 
 ##### 前缀/后缀相等
 
-通过调用字符串的 `hasPrefix`/`hasSuffix` 方法来检查字符串是否拥有特定前缀/后缀。两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
+通过调用字符串的 `hasPrefix`/`hasSuffix` 方法来检查字符串是否拥有特定前缀/后缀。
+两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。
+两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
 
 下面的例子以一个字符串数组表示莎士比亚话剧 `罗密欧与朱丽叶` 中前两场的场景位置：
 
@@ -250,13 +276,15 @@ let whispered = normal.lowercaseString
 
 ### Unicode
 
-Unicode 是文本编码和表示的国际标准。它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
+Unicode 是文本编码和表示的国际标准。
+它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
 
 Swift 的字符串和字符类型是完全兼容 Unicode 的，它支持如下所述的一系列不同的 Unicode 编码。
 
 ###### Unicode 术语(Terminology)
 
-Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 `U+0061` 表示小写的拉丁字母A ("a")，`U+1F425` 表示 ("🐥")
+Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
+字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 `U+0061` 表示小写的拉丁字母A ("a")，`U+1F425` 表示小幺鸡表情 ("🐥")
 
 当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括 `UTF-8` (以8位代码单元进行编码) 和 `UTF-16` (以16位代码单元进行编码)。
 
@@ -264,7 +292,8 @@ Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
 
 Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。
 
-您可以利用 `for-in` 来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。该过程在 [Working with Characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_376) 中进行了描述。
+您可以利用 `for-in` 来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。
+该过程在 [Working with Characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_376) 中进行了描述。
 
 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
 
@@ -280,7 +309,8 @@ let dogString = "Dog!🐶"
 
 ##### UTF-8
 
-您可以通过遍历字符串的 `utf8` 属性来访问它的 `UTF-8` 表示。其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个 `UIn8` 都是一个字符的 UTF-8 表示：
+您可以通过遍历字符串的 `utf8` 属性来访问它的 `UTF-8` 表示。
+其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个 `UIn8` 都是一个字符的 UTF-8 表示：
 
 ```
 for codeUnit in dogString.utf8 {
@@ -290,11 +320,13 @@ print("\n")
 // 68 111 103 33 240 159 144 182
 ```
 
-上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-8 表示与 ASCII 表示相同。后四个代码单元值 (240, 159, 144, 182) 是 `狗脸表情` 的4位 UTF-8 表示。
+上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-8 表示与 ASCII 表示相同。
+后四个代码单元值 (240, 159, 144, 182) 是 `狗脸表情` 的4位 UTF-8 表示。
 
 ##### UTF-16
 
-您可以通过遍历字符串的 `utf16` 属性来访问它的 `UTF-16` 表示。其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
+您可以通过遍历字符串的 `utf16` 属性来访问它的 `UTF-16` 表示。
+其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
 
 ```
 for codeUnit in dogString.utf16 {
@@ -306,11 +338,14 @@ print("\n")
 
 同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-16 代码单元和 UTF-8 完全相同。
 
-第五和第六个代码单元值 (55357 and 56374) 是 `狗脸表情` 字符的UTF-16 表示。第一个值为 `U+D83D` (十进制值为 55357)，第二个值为 `U+DC36` (十进制值为 56374)。
+第五和第六个代码单元值 (55357 and 56374) 是 `狗脸表情` 字符的UTF-16 表示。
+第一个值为 `U+D83D` (十进制值为 55357)，第二个值为 `U+DC36` (十进制值为 56374)。
 
 ##### Unicode 标量 (Scalars)
 
-您可以通过遍历字符串的 `unicodeScalars` 属性来访问它的 Unicode 标量表示。其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是 `UnicodeScalar` 的集合。`UnicodeScalar` 是21位的 Unicode 代码点。
+您可以通过遍历字符串的 `unicodeScalars` 属性来访问它的 Unicode 标量表示。
+其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是 `UnicodeScalar` 的集合。
+`UnicodeScalar` 是21位的 Unicode 代码点。
 
 每一个 `UnicodeScalar` 拥有一个值属性，可以返回对应的21位数值，用 `UInt32` 来表示。
 
@@ -322,7 +357,9 @@ print("\n")
 // 68 111 103 33 128054
 ```
 
-同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` 。第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于 `狗脸表情` 的Unicode 标量 U+1F436。
+同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` 。
+第五位数值，128054，是一个十六进制1F436的十进制表示。
+其等同于 `狗脸表情` 的Unicode 标量 U+1F436。
 
 作为查询字符值属性的一种替代方法，每个 `UnicodeScalar` 值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
 

source/chapter2/07_Closures.md

@@ -0,0 +1,358 @@
+# 闭包
+
+闭包是功能性自包含模块，可以在代码中被传递和使用。
+Swift 中的闭包与 C 和 Objective-C 中的 `blocks` 以及其他一些编程语言中的 `lambdas` 比较相似。
+
+闭包可以 **捕获** 和存储其所在上下文中任意常量和变量的引用。
+这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在 **捕获** 过程中涉及到的内存操作。
+
+> 注意：
+>
+> 如果您不熟悉 **捕获** (capturing) 这个概念也不用担心，后面会详细对其进行介绍。
+
+在 `函数` 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
+
+*	全局函数是一个有名字但不会捕获任何值的闭包
+*	嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
+*	闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
+
+Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
+
+*	利用上下文推断参数和返回值类型
+*	单表达式闭包可以省略 `return` 关键字
+*	参数名称缩写
+*	Trailing 闭包语法
+
+### 闭包表达式
+
+嵌套函数是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
+当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
+
+闭包表达式是一种利用简洁语法构建内联闭包的方式。
+闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
+下面闭包表达式的例子通过使用几次迭代展示了 `sort` 函数定义和语法优化的方式。
+每一次迭代都用更简洁的方式描述了相同的功能。
+
+##### `sort` 函数
+
+Swift 标准库提供了 `sort` 函数，会根据您提供的排序闭包将已知类型数组中的值进行排序。
+一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
+
+下面的闭包表达式示例使用 `sort` 函数对一个 **String** 类型的数组进行字母逆序排序，以下是初始数组值：
+
+```
+let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
+```
+
+该例子对一个 **String** 类型的数组进行排序，因此排序闭包需为 `(String, String) -> Bool` 类型的函数。
+
+提供排序闭包的一种方式是撰写一个符合其类型要求的普通函数，并将其作为 `sort` 函数的第二个参数传入：
+
+```
+func backwards(s1: String, s2: String) -> Bool {
+    return s1 > s2
+}
+var reversed = sort(names, backwards)
+// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
+```
+
+如果第一个字符串 (s1) 大于第二个字符串 (s2)，`backwards` 函数则返回 `true`，表示在新的数组中 s1 应该出现在 s2 前。
+字符中的 "大于" 表示 "按照字母顺序后出现"。
+这意味着字母 "B" 大于字母 "A", 字符串 "Tom" 大于字符串 "Tim"。
+其将进行字母逆序排序，"Barry" 将会排在 "Alex" 之后。
+
+然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。
+在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
+
+##### 闭包表达式语法
+
+闭包表达式语法有如下一般形式：
+
+```
+{ (parameters) -> returnType in
+    statements
+}
+```
+
+闭包表达式语法可以使用常量、变量和 `inout` 类型作为参数，不提供默认值。
+也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。
+
+下面的例子展示了之前 `backwards` 函数对应的闭包表达式版本的代码：
+
+```
+reversed = sort(names, { (s1: String, s2: String) -> Bool in
+    return s1 > s2
+    })
+```
+
+需要注意的是内联闭包参数和返回值类型声明与 `backwards` 函数类型声明相同。
+在这两种方式中，都写成了 (s1: String, s2: String) -> Bool。
+然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。
+
+闭包的函数体部分由关键字 `in` 引入。
+该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。
+
+因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：
+
+```
+reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
+```
+
+这说明 `sort` 函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于 `backwards` 版本的代码)。
+
+##### 根据上下文推断类型
+
+因为排序闭包是作为函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
+`sort` 期望第二个参数是类型为 `(String, String) -> Bool` 的函数，因此实际上 `String`, `String` 和 `Bool` 类型并不需要作为闭包表达式定义中的一部分。
+因为所有的类型都可以被正确推断，返回箭头 (->) 和 围绕在参数周围的括号也可以被省略：
+
+```
+reversed = sort(names, { s1, s2 in return s1 > s2 } )
+```
+
+实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
+
+##### 单行表达式闭包可以省略 `return`
+
+单行表达式闭包可以通过隐藏 `return` 关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
+
+```
+reversed = sort(names, { s1, s2 in s1 > s2 } )
+```
+
+在这个例子中，`sort` 函数的第二个参数函数类型明确了闭包必须返回一个 **Bool** 类型值。
+因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回 **Bool** 类型值，因此这里没有歧义，`return`关键字可以省略。
+
+##### 参数名称缩写
+
+Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过 `$0`,`$1`,`$2` 来顺序调用闭包的参数。
+
+如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。
+`in` 关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
+
+```
+reversed = sort(names, { $0 > $1 } )
+```
+
+在这个例子中，`$0` 和 `$1` 表示闭包中第一个和第二个 **String** 类型的参数。
+
+##### 运算符函数
+
+实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
+Swift 的 **String** 类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个 **String** 类型的参数并返回 **Bool** 类型的值。
+而这正好与 `sort` 函数的第二个参数需要的函数类型相符合。
+因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
+
+```
+reversed = sort(names, >)
+```
+
+更多关于运算符表达式的内容请查看 [Operator Functions](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43) 。
+
+### Trailing 闭包
+
+如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用 trailing 闭包来增强函数的可读性。
+Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
+
+```
+func someFunctionThatTakesAClosure(closure: () -> ()) {
+    // 函数体部分
+}
+ 
+// 以下是不使用 trailing 闭包进行函数调用
+ 
+someFunctionThatTakesAClosure({
+    // 闭包主体部分
+    })
+ 
+// 以下是使用 trailing 闭包进行函数调用
+
+someFunctionThatTakesAClosure() {
+	// 闭包主体部分
+}
+```
+> 注意：
+>
+> 如果函数只需要闭包表达式一个参数，当您使用 trailing 闭包时，您甚至可以把 () 省略掉。
+NOTE
+
+在上例中作为 `sort` 函数参数的字符串排序闭包可以改写为：
+
+```
+reversed = sort(names) { $0 > $1 }
+```
+
+当闭包非常长以至于不能在一行中进行书写时，Trailing 闭包变得非常有用。
+举例来说，Swift 的 **Array** 类型有一个 `map` 方法，其获取一个闭包表达式作为其唯一参数。
+数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。
+具体的映射方式和返回值类型由闭包来指定。
+
+当提供给数组闭包函数后，`map` 方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
+
+下例介绍了如何在 `map` 方法中使用 trailing 闭包将 **Int** 类型数组 `[16,58,510]` 转换为包含对应 **String** 类型的数组 `["OneSix", "FiveEight", "FiveOneZero"]`:
+
+```
+let digitNames = [
+    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
+    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
+]
+let numbers = [16, 58, 510]
+```
+
+如上代码创建了一个数字位和他们名字映射的英文版本字典。
+同时定义了一个准备转换为字符串的整型数组。
+
+您现在可以通过传递一个 trailing 闭包给 `numbers` 的 `map` 方法来创建对应的字符串版本数组。
+需要注意的时调用 `numbers.map` 不需要在 `map` 后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过 trailing 方式进行撰写：
+
+```
+let strings = numbers.map {
+    (var number) -> String in
+    var output = ""
+    while number > 0 {
+        output = digitNames[number % 10]! + output
+        number /= 10
+    }
+    return output
+}
+// strings 常量被推断为字符串类型数组，即 String[]
+// 其值为 ["OneSix", "FiveEight", "FiveOneZero"]
+```
+
+`map` 在数组中为每一个元素调用了闭包表达式。
+您不需要指定闭包的输入参数 `number` 的类型，因为可以通过要映射的数组类型进行推断。
+
+闭包 `number` 参数被声明为一个变量参数 (变量的具体描述请参看[Constant and Variable Parameters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-XID_224))，因此可以在闭包函数体内对其进行修改。
+闭包表达式制定了返回类型为 **String**，以表明存储映射值的新数组类型为 **String**。
+
+闭包表达式在每次被调用的时候创建了一个字符串并返回。
+其使用求余运算符 (number % 10) 计算最后一位数字并利用 `digitNames` 字典获取所映射的字符串。
+
+> 注意：
+>
+> 字典 `digitNames` 下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。
+> 在上例中，它保证了 `number % 10` 可以总是作为一个 `digitNames` 字典的有效下标 key。
+> 因此叹号可以用于强制展开 (force-unwrap) 存储在可选下标项中的 **String** 类型值。
+
+从 `digitNames` 字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。
+(在表达式 `number % 10`中，如果number为16，则返回6，58返回8，510返回0)。
+
+`number` 变量之后除以10。
+因为其是整数，在计算过程中未除尽部分被忽略。
+因此 16变成了1，58变成了5，510变成了51。
+
+整个过程重复进行，直到 `number /= 10` 为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。
+
+上例中 trailing 闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在 `map` 函数的括号内。
+
+### 捕获 (Caputure)
+
+闭包可以在其定义的上下文中捕获常量或变量。
+即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
+
+Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。
+嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
+
+下例为一个叫做 `makeIncrementor` 的函数，其包含了一个叫做 `incrementor` 嵌套函数。
+嵌套函数 `incrementor` 从上下文中捕获了两个值，`runningTotal` 和 `amount`。
+之后 `makeIncrementor` 将 `incrementor` 作为闭包返回。
+每次调用 `incrementor` 时，其会以 `amount` 作为增量增加 `runningTotal` 的值。
+
+```
+func makeIncrementor(forIncrement amount: Int) -> () -> Int {
+    var runningTotal = 0
+    func incrementor() -> Int {
+        runningTotal += amount
+        return runningTotal
+    }
+    return incrementor
+}
+```
+
+`makeIncrementor` 返回类型为 `() -> Int`。
+这意味着其返回的是一个函数，而不是一个简单类型值。
+该函数在每次调用时不接受参数只返回一个 **Int** 类型的值。
+关于函数返回其他函数的内容，请查看[Function Types as Return Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-XID_232)。
+
+`makeIncrementor` 函数定义了一个整型变量 `runningTotal` (初始为0) 用来存储当前跑步总数。
+该值通过 `incrementor` 返回。
+
+`makeIncrementor` 有一个 **Int** 类型的参数，其外部命名为 `forIncrement`， 内部命名为 `amount`，表示每次 `incrementor` 被调用时 `runningTotal` 将要增加的量。
+
+`incrementor` 函数用来执行实际的增加操作。
+该函数简单地使 `runningTotal` 增加 `amount`，并将其返回。
+
+如果我们单独看这个函数，会发现看上去不同寻常：
+
+```
+func incrementor() -> Int {
+    runningTotal += amount
+    return runningTotal
+}
+```
+
+`incrementor` 函数并没有获取任何参数，但是在函数体内访问了 `runningTotal` 和 `amount` 变量。这是因为其通过捕获在包含它的函数体内已经存在的 `runningTotal` 和 `amount` 变量而实现。
+
+由于没有修改 `amount` 变量，`incrementor` 实际上捕获并存储了该变量的一个副本，而该副本随着 `incrementor` 一同被存储。
+
+然而，因为每次调用该函数的时候都会修改 `runningTotal` 的值，`incrementor` 捕获了当前 `runningTotal` 变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当 `makeIncrementor` 结束时候并不会消失，也保证了当下一次执行 `incrementor` 函数时，`runningTotal` 可以继续增加。
+
+> 注意：
+>
+> Swift 会决定捕获引用还是拷贝值。
+> 您不需要标注 `amount` 或者 `runningTotal` 来声明在嵌入的 `incrementor` 函数中的使用方式。
+> Swift 同时也处理 `runingTotal` 变量的内存管理操作，如果不再被 `incrementor` 函数使用，则会被清除。
+
+下面为一个使用 `makeIncrementor` 的例子：
+
+```
+let incrementByTen = makeIncrementor(forIncrement: 10)
+```
+
+该例子定义了一个叫做 `incrementByTen` 的常量，该常量指向一个每次调用会加10的 `incrementor` 函数。
+调用这个函数多次可以得到以下结果：
+
+```
+incrementByTen()
+// 返回的值为10
+incrementByTen()
+// 返回的值为20
+incrementByTen()
+// 返回的值为30
+```
+
+如果您创建了另一个 `incrementor`，其会有一个属于自己的独立的 `runningTotal` 变量的引用。
+下面的例子中，`incrementBySevne` 捕获了一个新的 `runningTotal` 变量，该变量和 `incrementByTen` 中捕获的变量没有任何联系：
+
+```
+let incrementBySeven = makeIncrementor(forIncrement: 7)
+incrementBySeven()
+// 返回的值为7
+incrementByTen()
+// 返回的值为40
+```
+
+> 注意：
+>
+> 如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
+> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [Strong Reference Cycles for Closures](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-XID_61)。
+
+### 闭包是引用类型
+
+上面的例子中，`incrementBySeven` 和 `incrementByTen` 是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
+这是因为函数和闭包都是引用类型。
+
+无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。
+上面的例子中，`incrementByTen` 指向闭包的引用是一个常量，而并非闭包内容本身。
+
+这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
+
+```
+let alsoIncrementByTen = incrementByTen
+alsoIncrementByTen()
+// 返回的值为50
+```
+
+
+
+

source/chapter2/22_Generics.md

@@ -0,0 +1,475 @@
+# 泛型
+
+------
+
+*泛型代码*可以确保你写出灵活的，可重用的函数和定义出任何你所确定好的需求的类型。你的可以写出避免重复的代码，并且用一种清晰的，抽象的方式表达出来。
+
+泛型是Swift需要强大特征中的其中一个，许多Swift标准库是通过泛型代码构建出来的。事实上，你已经使用泛型贯穿着整个Language Guide，即便你没有实现它。例如：Swift的Array和Dictionary类型都是泛型集。你可以创建一个Int数组，也可创建一个String数组，或者甚至于可以是任何其他Swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(dictionary)，而且这些类型可以是没有限制的。
+
+------
+
+## 泛型所解决的问题
+
+这里是一个标准的，非泛型函数swapTwoInts,用来交换两个Int值：
+
+```C
+	func swapTwoInts(inout a: Int, inout b: Int) 
+		let temporaryA = a
+		a = b
+		b = temporaryA
+	}
+```
+这个函数使用in-out参数交换a和b的值，这两个参数被描述为[In-Out类型参数][1]。
+
+`swapTwoInts`函数可以交换b的原始值到a，也可以交换a的原始值到b，你可以调用这个函数交换两个Int变量值：
+```C
+    var someInt = 3
+    var anotherInt = 107
+    swapTwoInts(&someInt, &anotherInt)
+    println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
+    // prints "someInt is now 107, and anotherInt is now 3"
+```
+
+`swapTwoInts`函数是非常有用的，但是它只能交换Int值，如果你想要交换两个String或者Double，就不得不写更多的函数，如 `swapTwoStrings`和`swapTwoDoublesfunctions `，如同如下所示：
+
+```C
+    func swapTwoStrings(inout a: String, inout b: String) {
+        let temporaryA = a
+        a = b
+        b = temporaryA
+    }
+     
+    func swapTwoDoubles(inout a: Double, inout b: Double) {
+        let temporaryA = a
+        a = b
+        b = temporaryA
+    }
+```
+
+你可能注意到 `swapTwoInts`、 `swapTwoStrings`和`swapTwoDoubles`函数主题都是相同的，唯一不同之处就在于传入的变量不同，分别是Int、String和Double。
+
+但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数，可以用来交换两个任何类型值，很幸运的是，泛型代码帮你解决了这种问题。（一个这种泛型函数后面已经定义好了。）
+
+>NOTE
+
+>In all three functions, it is important that the types of a and b are defined to be the same as each other. If a and b were not of the same type, it would not be possible to swap their values. Swift is a type-safe language, and does not allow (for example) a variable of type String and a variable of type Double to swap values with each other. Attempting to do so would be reported as a compile-time error.
+
+
+## 泛型函数
+
+`泛型函数`可以工作于任何类型，这里是一个上面`swapTwoInts`函数的泛型版本，用于交换两个值： 
+```C
+    func swapTwoValues<T>(inout a: T, inout b: T) {
+        let temporaryA = a
+        a = b
+        b = temporaryA
+    }
+```
+`swapTwoValues`函数主体和`swapTwoInts`函数是一样，而且，只在第一行稍微有那么一点点不同于`swapTwoInts`，如下所示：
+```C
+    func swapTwoInts(inout a: Int, inout b: Int)
+    func swapTwoValues<T>(inout a: T, inout b: T)
+```
+
+这个函数的泛型版本使用了节点类型命名（通常此情况下用字母T来表示）来代替实际类型名（如Int、String或Double）。节点类型名并不是表示T必须是任何类型，但是其规定a和b必须是同一类型的T，而不管T表示任何类型。只有`swapTwoValues`函数在每次调用时所传入的实际类型决定了T所代表的类型。
+
+另外一个不同之处在于这个泛型函数名后面跟着的节点类型名(T)是用尖括号括起来的(<T>)。这个尖括号告诉Swift那个T是`swapTwoValues`函数所定义的一个节点类型。因为T是一个节点，Swift不会去查找每一个命名为T的实际类型。
+
+`swapTwoValues`函数除了只要传入的两个任何类型值是同一类型外，也可以作为`swapTwoInts`函数被调用。每次`swapTwoValues`被调用，T所代表的类型值都会传给函数。
+
+在下面的两个例子中,T分别代表Tnt和String：
+
+```C
+    var someInt = 3
+    var anotherInt = 107
+    swapTwoValues(&someInt, &anotherInt)
+    // someInt is now 107, and anotherInt is now 3
+     
+    var someString = "hello"
+    var anotherString = "world"
+    swapTwoValues(&someString, &anotherString)
+    // someString is now "world", and anotherString is now "hello"
+
+```
+
+>NOTE
+
+>The swapTwoValues function defined above is inspired by a generic function called swap, which is part of the Swift standard library, and is automatically made available for you to use in your apps. If you need the behavior of the swapTwoValues function in your own code, you can use Swift’s existing swap function rather than providing your own implementation.
+
+##Type Parameters
+## 类型参数
+
+在上面的`swapTwoValues`例子中，节点类型T是一种类型参数的示例。类型参数指定并命名为一个节点类型，并且紧随在函数名后面，并用一对尖括号括起来（如<T>）。
+
+一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如`swapTwoValues`函数中的参数a和b），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的节点类型不管函数任何时候被调用，都会被实际类型所替换（在上面`swapTwoValues`例子中，当函数第一次被调用时，T被Int替换，第二次调用时，被String替换。）。
+
+你可支持多个类型参数，命名在尖括号中，用逗号分开。
+
+## 命名类型参数
+
+在简单的情况下，泛型函数或泛型类型需要指定一个节点类型（如上面的`swapTwoValues`泛型函数，或一个存储单一类型的泛型集，如Array），通常用一单个字母T来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。
+
+如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift字典(Dictionary)类型有两个类型参数，一个是key，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为KeyType和ValueType，用来记住它们在你的泛型代码中的作用。
+
+>NOTE
+
+>Always give type parameters UpperCamelCase names (such as T and KeyType) to indicate that they are a placeholder for a type, not a value.
+
+## 泛型类型
+
+
+通常在泛型函数中，Swift允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同`Array`和`Dictionary`的用法。
+
+这部分向你展示如何写一个泛型集类型-`Stack`(栈)。一个栈是一系列值域的集合，和array(数组)相似，但其是一个比Swift的`Array`类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许，只允许在集合的末端添加新的项（如同*push*一个新值进栈）。同样的一个栈也只能从末端移除项（如同*pop*一个值出栈）。
+
+>NOTE
+
+>The concept of a stack is used by the UINavigationController class to model the view controllers in its navigation hierarchy. You call the UINavigationController class pushViewController:animated: method to add (or push) a view controller on to the navigation stack, and its popViewControllerAnimated: method to remove (or pop) a view controller from the navigation stack. A stack is a useful collection model whenever you need a strict “last in, first out” approach to managing a collection.
+
+下图展示了一个栈的压栈(push)/出栈(pop)的行为：
+
+![此处输入图片的描述][2]
+
+1. 现在有三个值在栈中；
+2. 第四个值“pushed”到栈的顶部；
+3. 现在有四个值在栈中，最近的那个在顶部；
+4. 栈中最顶部的那个项被移除，或称之为“popped”；
+5. 移除掉一个值后，现在栈又重新只有三个值。
+
+这里展示了如何写一个非泛型版本的栈，`Int`值型的栈：
+```C
+struct IntStack {
+    var items = Int[]()
+    mutating func push(item: Int) {
+        items.append(item)
+    }
+    mutating func pop() -> Int {
+        return items.removeLast()
+    }
+}
+```
+
+这个结构体在栈中使用一个`Array`性质的`items`存储值。`Stack`提供两个方法：`push`和`pop`，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为他们需要修改（或*转换*）结构体的`items`数组。
+
+上面所展现的`IntStack`类型只能用于`Int`值，不过，其对于定义一个泛型`Stack`类（可以处理*任何*类型值的栈）是非常有用的。
+
+这里是一个相同代码的泛型版本：
+
+```C
+struct Stack<T> {
+    var items = T[]()
+    mutating func push(item: T) {
+        items.append(item)
+    }
+    mutating func pop() -> T {
+        return items.removeLast()
+    }
+}
+```
+
+注意到`Stack`的泛型版本基本上和非泛型版本相同，但是泛型版本的节点类型参数为T代替了实际`Int`类型。这种类型参数包含在一对尖括号里(`<T>`)，紧随在结构体名字后面。
+
+T定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，T在如下三个地方被用作节点：
+
+- 创建一个名为`items`的属性，使用空的T类型值数组对其进行初始化；
+- 指定一个包含一个参数名为`item`的`push`方法，该参数必须是T类型；
+- 指定一个`pop`方法的返回值，该返回值将是一个T类型值。
+
+当创建一个新单例并初始化时， 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型，创建一个`Stack`实例，同创建`Array`和`Dictionary`一样：
+```c
+var stackOfStrings = Stack<String>()
+stackOfStrings.push("uno")
+stackOfStrings.push("dos")
+stackOfStrings.push("tres")
+stackOfStrings.push("cuatro")
+// 现在栈已经有4个string了
+```
+下图将展示`stackOfStrings`如何push这四个值进栈的过程：
+
+![此处输入图片的描述][3]
+
+从栈中pop并移除值"cuatro"：
+
+```C
+let fromTheTop = stackOfStrings.pop()
+// fromTheTop is equal to "cuatro", and the stack now contains 3 strings
+```
+下图展示了如何从栈中pop一个值的过程：
+![此处输入图片的描述][4]
+
+由于`Stack`是泛型类型，所以在Swift中其可以用来创建任何有效类型的栈，这种方式如同`Array`和`Dictionary`。
+
+##类型约束
+
+`swapTwoValues`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
+
+例如，Swift的`Dictionary`类型对作用于其keys的类型做了些限制。在[Dictionaries][5]的描述中，字典的keys类型必须是*hashable*，也就是说，必须有一种方法可以使其是唯一的表示。`Dictionary`之所以需要其keys是hashable是为了以便于其检查其是否包含某个特定key的值。如无此需求，`Dictionary`即不会告诉是否插入或者替换了某个特定key的值，也不能查找到已经存储在字典里面的给定key值。
+
+这个需求强制加上一个类型约束作用于`Dictionary`的key上，当然其key类型必须遵循`Hashable`协议（Swift标准库中定义的一个特定协议）。所有的Swift基本类型（如`String`，`Int`， `Double`和 `Bool`）默认都是hashable。
+
+当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如`Hashtable`具有的类型特征是根据他们概念特征来界定的，而不是他们的直接类型特征。
+
+### 类型约束语法
+
+你可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）：
+```c
+func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
+    // function body goes here
+}
+```
+
+上面这个假定函数有两个类型参数。第一个类型参数`T`，有一个需要`T`必须是`SomeClass`子类的类型约束；第二个类型参数`U`，有一个需要`U`必须遵循`SomeProtocol`协议的类型约束。
+
+### 类型约束行为
+
+这里有个名为`findStringIndex`的非泛型函数，该函数功能是去查找包含一给定`String`值的数组。若查找到匹配的字符串，`findStringIndex`函数返回该字符串在数组中的索引值（`Int`），反之则返回`nil`：
+```c
+func findStringIndex(array: String[], valueToFind: String) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+```
+
+`findStringIndex`函数可以作用于查找一字符串数组中的某个字符串:
+```c
+let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
+if let foundIndex = findStringIndex(strings, "llama") {
+    println("The index of llama is \(foundIndex)")
+}
+// prints "The index of llama is 2"
+```
+
+如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数`findIndex`，用某个类型`T`值替换掉提到的字符串。
+
+这里展示如何写一个你或许期望的`findStringIndex`的泛型版本`findIndex`。请注意这个函数仍然返回`Int`，是不是有点迷惑呢，而不是泛型类型?那是因为函数返回的是一个可选的索引数，而不是从数组中得到的一个可选值。需要提醒的是，这个函数不会编译，原因在例子后面会说明：
+
+```c
+func findIndex<T>(array: T[], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+```
+
+上面所写的函数不会编译。这个问题的位置在等式的检查上，`“if value == valueToFind”`。不是所有的Swift中的类型都可以用等式符(==)进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么Swift没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型`T`，当你试图编译这部分代码时估计会出现相应的错误。
+
+不过，所有的这些并不会让我们无从下手。Swift标准库中定义了一个`Equatable`协议，该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持`Equatable`协议。
+
+任何`Equatable`类型都可以安全的使用在`findIndex`函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个`Equatable`类型约束作为类型参数定义的一部分：
+```c
+func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+```
+
+`findIndex`中这个单个类型参数写做：`T: Equatable`，也就意味着“任何T类型都遵循`Equatable`协议”。
+
+findIndex函数现在则可以成功的编译过，并且作用于任何遵循Equatable的类型，如Double或String:
+```c
+let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
+// doubleIndex is an optional Int with no value, because 9.3 is not in the array
+let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
+// stringIndex is an optional Int containing a value of 2
+```
+
+##关联类型
+
+当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型给定作用于协议部分的类型一个节点名（或*别名*）。作用于关联类型上实际类型是不需要指定的，直到该协议接受。关联类型被指定为`typealias`关键字。
+
+### 关联类型行为
+
+这里是一个`Container`协议的例子，定义了一个ItemType关联类型：
+```c
+protocol Container {
+    typealias ItemType
+    mutating func append(item: ItemType)
+    var count: Int { get }
+    subscript(i: Int) -> ItemType { get }
+}
+```
+`Container`协议定义了三个任何容器必须支持的兼容要求：
+
+- 必须可能通过`append`方法添加一个新item到容器里；
+- 必须可能通过使用`count`属性获取容器里items的数量，并返回一个`Int`值；
+- 必须可能通过容器的`Int`索引值下标可以检索到每一个item。
+
+这个协议没有指定容器里item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循`Container`类型所必须支持的功能点。一个遵循的类型也可以提供其他额外的功能，只要满足这三个条件。
+
+任何遵循`Container`协议的类型必须指定存储在其里面的值类型，必须保证只有正确类型的items可以加进容器里，必须明确可以通过其下标返回item类型。
+
+为了定义这三个条件，`Container`协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。`Container`协议需要指定任何通过`append`方法添加到容器里的值和容器里元素是相同类型，并且通过容器下标返回的容器元素类型的值的类型是相同类型。
+
+为了达到此目的，`Container`协议声明了一个ItemType的关联类型，写作`typealias ItemType`。The protocol does not define what ItemType is an alias for—that information is left for any conforming type to provide（这个协议不会定义`ItemType`是遵循类型所提供的何种信息的别名）。尽管如此，`ItemType`别名支持一种方法识别在一个容器里的items类型，以及定义一种使用在`append`方法和下标中的类型，以便保证任何期望的`Container`的行为是强制性的。
+
+这里是一个早前IntStack类型的非泛型版本，适用于遵循Container协议：
+```c
+struct IntStack: Container {
+    // original IntStack implementation
+    var items = Int[]()
+    mutating func push(item: Int) {
+        items.append(item)
+    }
+    mutating func pop() -> Int {
+        return items.removeLast()
+    }
+    // conformance to the Container protocol
+    typealias ItemType = Int
+    mutating func append(item: Int) {
+        self.push(item)
+    }
+    var count: Int {
+    return items.count
+    }
+    subscript(i: Int) -> Int {
+        return items[i]
+    }
+}
+```
+
+`IntStack`类型实现了`Container`协议的所有三个要求，在`IntStack`类型的每个包含部分的功能都满足这些要求。
+
+此外，`IntStack`指定了`Container`的实现，适用的ItemType被用作`Int`类型。对于这个`Container`协议实现而言，定义 `typealias ItemType = Int`，将抽象的`ItemType`类型转换为具体的`Int`类型。
+
+感谢Swift类型参考，你不用在`IntStack`定义部分声明一个具体的`Int`的`ItemType`。由于`IntStack`遵循`Container`协议的所有要求，只要通过简单的查找`append`方法的item参数类型和下标返回的类型，Swift就可以推断出合适的`ItemType`来使用。确实，如果上面的代码中你删除了 `typealias ItemType = Int`这一行，一切仍旧可以工作，因为它清楚的知道ItemType使用的是何种类型。
+
+你也可以生成遵循`Container`协议的泛型`Stack`类型：
+```c
+struct Stack<T>: Container {
+    // original Stack<T> implementation
+    var items = T[]()
+    mutating func push(item: T) {
+        items.append(item)
+    }
+    mutating func pop() -> T {
+        return items.removeLast()
+    }
+    // conformance to the Container protocol
+    mutating func append(item: T) {
+        self.push(item)
+    }
+    var count: Int {
+    return items.count
+    }
+    subscript(i: Int) -> T {
+        return items[i]
+    }
+}
+```
+这个时候，节点类型参数`T`被用作`append`方法的item参数和下标的返回类型。Swift因此可以推断出被用作这个特定容器的`ItemType`的`T`的合适类型。
+
+
+### 扩展一个存在的类型为一指定关联类型
+
+在[Adding Protocol Conformance with an Extension][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
+
+Swift的`Array`已经提供`append`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[Declaring Protocol Adoption with an Extension][7]中有描述这样一个实现一个空扩展的行为：
+```c
+extension Array: Container {}
+```
+如同上面的泛型`Stack`类型一样，`Array的append`方法和下标保证`Swift`可以推断出`ItemType`所使用的适用的类型。定义了这个扩展后，你可以将任何`Array`当作`Container`来使用。
+
+## Where 语句
+
+[Type Constraints][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。
+
+对于关联类型的定义需求也是非常有用的。你可以通过这样去定义*where语句*作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个where语句，通过紧随放置`where`关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。
+
+下面的列子定义了一个名为`allItemsMatch`的泛型函数，用来检查是否两个`Container`单例包含具有相同顺序的相同items。如果匹配到所有的items，那么返回一个为true的Boolean值，反之，则相反。
+
+这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但他们确实拥有相同类型的items。这个需求通过一个类型约束和where语句结合来表示：
+```c
+func allItemsMatch<
+    C1: Container, C2: Container
+    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
+    (someContainer: C1, anotherContainer: C2) -> Bool {
+        
+        // check that both containers contain the same number of items
+        if someContainer.count != anotherContainer.count {
+            return false
+        }
+        
+        // check each pair of items to see if they are equivalent
+        for i in 0..someContainer.count {
+            if someContainer[i] != anotherContainer[i] {
+                return false
+            }
+        }
+        
+        // all items match, so return true
+        return true
+        
+}
+```
+
+这个函数用了两个参数：`someContainer`和`anotherContainer`。`someContainer`参数是类型`C1`，`anotherContainer`参数是类型`C2`。`C1`和`C2`是容器的两个节点类型参数，决定了这个函数何时被调用。
+
+这个函数的类型参数列紧随在两个类型参数需求的后面：
+
+- `C1`必须遵循`Container`协议 (写作 `C1: Container`)。
+- `C2`必须遵循`Container`协议 (写作 `C2: Container`)。
+- `C1`的`ItemType`同样是C2的`ItemType`（写作 `C1.ItemType == C2.ItemType`）。
+- `C1`的`ItemType`必须遵循`Equatable`协议 (写作 `C1.ItemType: Equatable`)。
+
+第三个和第四个要求被定义为一个where语句的一部分，写在关键字`where`后面，作为函数类型参数链的一部分。
+
+这些要求意思是：
+
+`someContainer`是一个`C1`类型的容器。
+`anotherContainer`是一个`C2`类型的容器。
+`someContainer`和`anotherContainer`包含相同的items类型。
+`someContainer`中的items可以通过不等于操作(`!=`)来检查它们是否彼此不同。
+
+第三个和第四个要求结合起来的意思是`anotherContainer`中的items也可以通过 `!=` 操作来检查，因为他们在`someContainer`中items确实是相同的类型。
+
+这些要求能够使`allItemsMatch`函数比较两个容器，即便他们是不同的容器类型。
+
+`allItemsMatch`首先检查两个容器是否拥有同样数目的items，如果他们的items数目不同，没有办法进行匹配，函数就会`false`。
+
+检查完之后，函数通过`for-in`循环和半闭区间操作(..)来迭代`someContainer`中的所有items。对于每个item，函数检查是否`someContainer`中的item不等于对应的`anotherContainer`中的item，如果这两个items不等，则这两个容器不匹配，返回`false`。
+
+
+如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回true。
+
+Here’s how the allItemsMatch function looks in action:
+这里演示了allItemsMatch函数运算的过程：
+```c
+var stackOfStrings = Stack<String>()
+stackOfStrings.push("uno")
+stackOfStrings.push("dos")
+stackOfStrings.push("tres")
+ 
+var arrayOfStrings = ["uno", "dos", "tres"]
+ 
+if allItemsMatch(stackOfStrings, arrayOfStrings) {
+    println("All items match.")
+} else {
+    println("Not all items match.")
+}
+// prints "All items match."
+```
+ 上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但他们都遵循`Container`协议，而且他们都包含同样的类型值。你因此可以调用`allItemsMatch`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch`函数正确的显示了所有的这两个容器的items匹配。
+
+  [1]: https://www.zybuluo.com/mdeditor?url=https://www.zybuluo.com/static/editor/md-help.markdown
+  [2]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPushPop_2x.png
+  [3]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPushedFourStrings_2x.png
+  [4]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPoppedOneString_2x.png
+  [5]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html#//apple_ref/doc/uid/TP40014097-CH8-XID_143
+  [6]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_355
+  [7]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_357
+  [8]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Generics.html#//apple_ref/doc/uid/TP40014097-CH26-XID_244
+  [9]: https://www.zybuluo.com/mdeditor?url=https://www.zybuluo.com/static/editor/md-help.markdown
+  [10]: https://www.zybuluo.com/mdeditor?url=https://www.zybuluo.com/static/editor/md-help.markdown#cmd-markdown-高阶语法手册
+  [11]: http://weibo.com/ghosert
+  [12]: http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference