daily update

straightdave · straightdave · commit bb10eb6e8f94 · 2016-04-20T10:31:30.000+08:00
diff --git a/1-intro.md b/1-intro.md
@@ -15,7 +15,7 @@
 
 现在开始吧！
 
->如果你发现本手册有错误，请帮忙开issue或发pull request。
+>如果你发现本手册有错误，请帮忙开_issue_讨论或发_pull request_。
 
 ## 1.1-安装包
 在各个平台上最方便的安装方式是相应平台的安装包。
diff --git a/2-basic-types.md b/2-basic-types.md
@@ -27,6 +27,7 @@ iex> 5 * 5
 iex> 10 / 2
 5.0
 ```
+
 >```10 / 2```返回了一个浮点型的5.0而非整型的5，这是预期的。   
 在Elixir中，```/```运算符总是返回浮点型数值。
 
@@ -234,7 +235,7 @@ iex> [1, true, 2, false, 3, true] -- [true, false]
 [1, 2, 3, true]
 ```
 
-本教程将多次涉及列表的头（head）和尾（tail）的概念。
+本教程将多次涉及列表头（head）和尾（tail）的概念。
 列表的头指的是第一个元素，而尾指的是除了第一个元素以外，其它元素组成的列表。
 它们分别可以用函数```hd/1```和```tl/1```从原列表中取出：
 ```elixir
@@ -252,15 +253,15 @@ iex> hd []
 ```
 
 ## 2.7-元组
-Elixir使用大括号（花括号）定义元组（tuples）。类似列表，元组也可以承载任意类型的数据。：
+Elixir使用大括号（花括号）定义元组（tuples）。类似列表，元组也可以承载任意类型的数据：
 ```elixir
 iex> {:ok, "hello"}
 {:ok, "hello"}
 iex> tuple_size {:ok, "hello"}
 2
 ```
-元组使用连续的内存空间存储数据。
-这意味着可以很方便地使用索引访问元组数据，以及获取元组大小。（索引从0开始）：
+元组使用 ***连续的内存空间*** 存储数据。
+这意味着可以很方便地使用索引访问元组数据，以及获取元组大小（索引从0开始）：
 ```elixir
 iex> tuple = {:ok, "hello"}
 {:ok, "hello"}
@@ -288,7 +289,7 @@ iex> tuple
 ## 2.8-列表还是元组？
 列表与元组的区别：列表在内存中是以链表的形式存储的，一个元素指向下一个元素，
 然后再下一个...直到到达列表末尾。
-我们称这样的一对（元素值+指向下一个元素的指针）为列表的一个单元（cons cell）。   
+我们称这样的一对数据（元素值 和 指向下一个元素的指针）为列表的一个单元（cons cell）。   
 
 用Elixir语法表示这种模式：
 ```elixir
@@ -306,16 +307,17 @@ iex> list ++ [4]
 [1, 2, 3, 4]
 ```
 
-上面例子中第一条语句是前置拼接操作，执行起来很快。
-因为它只是简单地添加了一个新列表单元，它指向原先列表头部。而原先的列表没有任何变化。
-第二条语句是后缀拼接操作，执行速度较慢。
+上面例子中第一条语句是 __前置__ 拼接操作，执行起来很快。
+因为它只是简单地添加了一个新列表单元，它的尾指针指向原先列表头部。而原先的列表没有任何变化。   
+
+第二条语句是 __后缀__ 拼接操作，执行速度较慢。
 这是因为它 **重建** 了原先的列表，让原先列表的末尾元素指向那个新元素。
 
-而另一方面，元组在内存中是连续存储的。
+另一方面，元组在内存中是连续存储的。
 这意味着获取元组大小，或者使用索引访问元组元素的操作十分快速。
-但是元组在修改或添加元素时开销很大，因为这些操作会在内存中对元组的进行整体复制。
+但是元组在修改或添加元素时开销很大，因为这些操作会在内存中对元组的进行整体复制。   
 
-这些讨论告诉我们当如何在不同的情况下选择使用不同的数据结构。
+这些讨论告诉我们当如何在不同的情况下选择使用不同的数据结构。   
 
 函数常用元组来返回多个信息。如```File.read/1```，它读取文件内容，返回一个元组：
 ```elixir
@@ -330,7 +332,7 @@ iex> File.read("path/to/unknown/file")
 如果路径无效，函数也将返回一个元组，其首元素是原子```:error```，第二个元素是错误信息。
 
 大多数情况下，Elixir会引导你做正确的事。
-如有个叫```elem/2```的函数，它使用索引来访问一个元组元素。
+比如有个叫```elem/2```的函数，它使用索引来访问一个元组元素。
 这个函数没有相应的列表版本，因为根据存储机制，列表不适用通过索引来访问：
 ```elixir
 iex> tuple = {:ok, "hello"}
@@ -340,11 +342,10 @@ iex> elem(tuple, 1)
 ```
 
 当需要计算某数据结构包含的元素个数时，Elixir遵循一个简单的规则：
-如果操作在常数时间内完成（答案是提前算好的），这样的函数通常被命名为 _*size_。
-而如果操作需要显式计数，那么该函数通常命名为 _*length_。
+如果操作在常数时间内完成（答案是提前算好的），这样的函数通常被命名为 ```*size```。
+而如果操作需要显式计数，那么该函数通常命名为 ```*length```。
 
-例如，目前讲到过的4个计数函数：```byte_size/1```
-（用来计算字符串有多少字节），```tuple_size/1```
+例如，目前讲到过的4个计数函数：```byte_size/1```（用来计算字符串有多少字节），```tuple_size/1```
 （用来计算元组大小），```length/1```（计算列表长度）
 以及```String.length/1```（计算字符串中的字符数）。
 
diff --git a/3-basic-ops.md b/3-basic-ops.md
@@ -1,44 +1,51 @@
 3-基本运算符
 ============
-通过前几章我们知道Elixir提供了 +，-，*，/ 4个算术运算符，外加整数除法函数div/2和取余函数rem/2。
-Elixir还提供了++和--运算符来操作列表：
-```
+
+通过前几章的学习，我们知道Elixir提供了 ```+，-，*，/``` 4个算术运算符，外加整数除法函数```div/2```和
+取余函数```rem/2```。
+Elixir还提供了```++```和```--```运算符来操作列表：
+```elixir
 iex> [1,2,3] ++ [4,5,6]
 [1,2,3,4,5,6]
 iex> [1,2,3] -- [2]
 [1,3]
 ```
-使用<>进行字符串拼接：
-```
+
+使用```<>```进行字符串拼接：
+```elixir
 iex> "foo" <> "bar"
 "foobar"
 ```
-Elixir还提供了三个布尔运算符：or，and和not。这三个运算符只接受布尔值作为第一个参数：
-```
+
+Elixir还提供了三个布尔运算符：```or，and，not```。这三个运算符只接受布尔值作为 *第一个* 参数：
+```elixir
 iex> true and true
 true
 iex> false or is_atom(:example)
 true
 ```
+
 如果提供了非布尔值作为第一个参数，会报异常：
-```
+```elixir
 iex> 1 and true
 ** (ArgumentError) argument error
 ```
 
-or和and可短路，即它们仅在第一个参数无法决定整体结果的情况下才执行第二个参数：
-```
+运算符```or```和```and```可短路，即它们仅在第一个参数无法决定整体结果的情况下才执行第二个参数：
+```elixir
 iex> false and error("This error will never be raised")
 false
 
 iex> true or error("This error will never be raised")
 true
 ```
->如果你是Erlang程序员，Elixir中的and和or其实就是andalso和orelse运算符。
 
-除了这几个布尔运算符，Elixir还提供||，&&和!运算符。它们可以接受任意类型的参数值。
-在使用这些运算符时，除了false和nil的值都被视作true：
-```
+>如果你是Erlang程序员，Elixir中的```and```和```or```其实就是```andalso```和```orelse```运算符。
+
+除了这几个布尔运算符，Elixir还提供```||```，```&&```和```!```运算符。它们可以接受任意类型的参数值。
+在使用这些运算符时，除了 false 和 nil 的值都被视作 true：
+
+```elixir
 # or
 iex> 1 || true
 1
@@ -60,10 +67,12 @@ iex> !nil
 true
 ```
 
-根据经验，当参数返回的是布尔时，使用and，or和not；如果非布尔值，用&&，||和!。
+根据经验，当参数确定是布尔时，使用```and```，```or```和```not```；
+如果非布尔值（或不确定是不是），用```&&```，```||```和```!```。
 
-Elixir还提供了==，!=，===，!==，<=，>=，<和>这些比较运算符：
-```
+Elixir还提供了 ```==，!=，===，!==，<=，>=，<，>``` 这些比较运算符：
+
+```elixir
 iex> 1 == 1
 true
 iex> 1 != 2
@@ -72,16 +81,17 @@ iex> 1 < 2
 true
 ```
 
-==和===的不同之处是后者在判断数字时更严格：
-```
+其中```==```和```===```的不同之处是后者在判断数字时更严格：
+
+```elixir
 iex> 1 == 1.0
 true
 iex> 1 === 1.0
 false
 ```
 
 在Elixir中，可以判断不同类型数据的大小：
-```
+```elixir
 iex> 1 < :atom
 true
 ```
@@ -90,5 +100,4 @@ true
 ```
 number < atom < reference < functions < port < pid < tuple < maps < list < bitstring
 ```
-不用背，只要知道有这么回事儿就可以。
-
+不用强记，只要知道有这么回事儿就可以。
diff --git a/4-pattern-matching.md b/4-pattern-matching.md
@@ -1,23 +1,24 @@
 4-模式匹配
 ==========
-[匹配运算符](#41-%E5%8C%B9%E9%85%8D%E8%BF%90%E7%AE%97%E7%AC%A6)    
-[模式匹配](#42-%E6%A8%A1%E5%BC%8F%E5%8C%B9%E9%85%8D)    
-[pin运算符](#43-pin%E8%BF%90%E7%AE%97%E7%AC%A6)    
 
 本章起教程进入 _不那么基础的_ 阶段，开始涉及函数式编程概念。
-在Elixir中，```=```运算符实际上是一个匹配运算符。
-本章将讲解如何使用=运算符来对数据结构进行模式匹配。
-最后本章还会讲解pin运算符(^)，用来访问某变量之前绑定的值。
+对之前没有函数式编程经验的人来说，这一章是一个基础，需要好好学习和理解。   
+
+在Elixir中，```=```运算符实际上叫做 *匹配运算符*。
+本章将讲解如何使用```=```运算符来对各种数据结构进行模式匹配。
+最后本章还会讲解pin运算符(```^```)，用来访问某变量之前绑定的值。
 
 ## 4.1-匹配运算符
+
 我们已经多次使用```=```符号进行变量的赋值操作：
 ```elixir
 iex> x = 1
 1
 iex> x
 1
 ```
-在Elixir中，```=```号其实称为匹配运算符。下面来学习这样的概念：
+
+在Elixir中，```=```作为 *匹配运算符*。下面来学习这样的概念：
 ```elixir
 iex> 1 = x
 1
@@ -26,18 +27,21 @@ iex> 2 = x
 ```
 
 注意```1 = x```是一个合法的表达式。
-由于前面给x赋值为1，左右相同，所以它匹配成功了。而两侧不匹配的时候，MatchError将被抛出。
+由于前面的例子给x赋值为1，因此在匹配时左右相同，所以它匹配成功了。而两侧不匹配的时候，MatchError将被抛出。
 
 变量只有在匹配操作符```=```的左侧时才被赋值：
 ```elixir
 iex> 1 = unknown
 ** (RuntimeError) undefined function: unknown/0
 ```
-错误原因是unknown变量没有被赋过值，Elixir猜你想调用一个名叫unknown/0的函数，
+错误原因是unknown变量没有被赋过值，Elixir猜你想调用一个名叫```unknown/0```的函数，
 但是找不到这样的函数。
 
+>
+变量名在等号左边，Elixir认为是赋值表达式；变量名放在右边，Elixir认为是拿该变量的值和左边的值做匹配。
+
 ## 4.2-模式匹配
-匹配运算符不光可以匹配简单数值，还能用来解构复杂的数据类型。例如，我们在元组上使用模式匹配：
+匹配运算符不光可以匹配简单数值，还能用来 *解构* 复杂的数据类型。例如，我们在元组上使用模式匹配：
 ```elixir
 iex> {a, b, c} = {:hello, "world", 42}
 {:hello, "world", 42}
@@ -46,20 +50,22 @@ iex> a
 iex> b
 "world"
 ```
-在两端不匹配的情况下，模式匹配会失败。比方说，匹配两端的元组不一样长：
+
+在两端不匹配的情况下，模式匹配会失败。比方说，匹配的两端的元组不一样长：
 ```elixir
 iex> {a, b, c} = {:hello, "world"}
 ** (MatchError) no match of right hand side value: {:hello, "world"}
 ```
 
-或者两端不是一个类型：
+或者两端模式有区别（比如两端数据类型不同）：
 ```elixir
 iex> {a, b, c} = [:hello, "world", "!"]
 ** (MatchError) no match of right hand side value: [:hello, "world", "!"]
 ```
 
-有趣的是，我们可以匹配特定值。
-下面例子中匹配的左端当且仅当右端是个元组，且第一个元素是原子```:ok```。
+利用“匹配”的这个概念，我们可以匹配特定值，或者在匹配成功时。   
+
+下面例子中先写好了匹配的左端，它要求右端必须是个元组，且第一个元素是原子```:ok```。
 ```elixir
 iex> {:ok, result} = {:ok, 13}
 {:ok, 13}
@@ -72,7 +78,7 @@ iex> {:ok, result} = {:error, :oops}
 
 用在列表上：
 ```elixir
-iex> [a, b, c] = [1, 2, 3]
+iex> [a, 2, 3] = [1, 2, 3]
 [1, 2, 3]
 iex> a
 1
@@ -95,7 +101,8 @@ iex> [h|t] = []
 ** (MatchError) no match of right hand side value: []
 ```
 
->[head|tail]这种形式不光在模式匹配时可以用，还可以用作向列表插入前置数值：
+>
+[head|tail]这种形式不光在模式匹配时可以用，还可以用作向列表插入前置数值：
 ```elixir
 iex> list = [1, 2, 3]
 [1, 2, 3]
@@ -106,6 +113,13 @@ iex> [0|list]
 模式匹配使得程序员可以容易地解构数据结构（如元组和列表）。
 在后面我们还会看到，它是Elixir的一个基础，对其它数据结构同样适用，比如图和二进制。
 
+小结：
+* 模式匹配使用```=```符号
+* 匹配中等号左右的“模式”必须相同
+* 变量在等号左侧才会被赋值
+* 变量在右侧时必须有值，Elixir拿这个值和左侧相应位置的元素做匹配
+
+
 ## 4.3-pin运算符
 在Elixir中，变量可以被重新绑定：
 ```elixir
