Correct description in functional_programming.zh.md

site/learn/tutorials/functional_programming.zh.md

@@ -10,32 +10,31 @@
 
 到现在我们已经讲了很多了，但还没有真正涉及到**函数式编程**。
 目前所讲的所有特性 - 丰富的数据类型（rich data types），
-模式匹配（pattern matching）， 类型推导（type inference），
-嵌套函数（nested functions） -
-可以想象它们都可以在一种”超级C“语言中存在。这些特性当然很酷，它们使得代码简洁易读，减少bug，但是它们实际和函数式编程没什么关系。实际上我的
-观点是函数式编程语言的妙处*不是*在于函数式编程，而是因为在我们长年习惯于类C语言编程的时候，编程技术已经提高很多了。因此当我们一次又一次地写`struct { int type; union { ... } }`的时候，ML和Haskell程序员却有着很多安全的变量和数据类型的模式匹配。当我们小心翼翼地
-`free`所有的`malloc`时候，很多语言在上世纪八十年代就有了超越手工管理的内存垃圾收集器。
+模式匹配（pattern matching）， 类型推导（type inference），嵌套函数（nested functions） -
+可以想象它们都可以在一种“超级C”语言中存在。这些特性当然很酷，可以让代码跟家简洁、易读、并具有更少的bug，
+但是实际上这与函数式编程的关系不大。实际上函数式编程语言的妙处*不是*在于函数式编程，而是因为在我们多年来使用类C语言编程的时间里，
+编程的前沿技术已经得到了极大地发展。因此当我们一次又一次地写`struct { int type; union { ... } }`的时候，
+ML和Haskell程序员却有着很多安全的可变类型（Safe Variants）和数据类型的模式匹配（Pattern Matching）。当我们小心翼翼地
+`free`所有的`malloc`时候，很多语言在上世纪八十年代就有了超越手工管理内存的垃圾收集器。
 
 好了，现在是时候告诉你们什么是函数式编程了。
 
-基本的但不是很能说明问题的定义是在**函数式语言中**,
-**函数（functions）**是一等公民。
+最基本的定义是：**函数（functions）**在**函数式语言中**是一等公民。
 
-听上去不是很有用，让我们来看个例子。
+听上去比较抽象，让我们来看一个实际的例子。
 
 ```ocamltop
 let double x = x * 2 in
 List.map double [ 1; 2; 3 ]
 ```
-在这个例子中，我首先定义了一个嵌套函数`double`，它读入一个参数`x`后返回`x * 2`。然后`map`在给定的列表(`[1; 2; 3]`)的每个元素上调用`double`来生成结果：一个每个数都扩大一倍的新的列表。
+在这个例子中，我首先定义了一个嵌套函数`double`，它读入一个参数`x`后返回`x * 2`。然后`map`会对给定的列表(`[1; 2; 3]`)中的每个元素都调用`double`来生成结果：一个每个元素的值都翻倍的新的列表。
 
 `map`被称为**高阶函数（higher-order function）**
-(HOF)。高阶函数是指一个把其他函数作为参数之一的函数。
+(HOF)。高阶函数是指接受函数作为参数的函数。
 
-到现在为止还算简单。如果你对C/C++熟悉的，这就象传递一个函数指针作为参数。Java中有匿名类(anonymous
-class)就像一个低速的闭包（closure）。如果你知道Perl那么你可能已经知道和使用了Perl中的闭包和Perl的`map`函数，这和我们现在所说的完全相同。事实上Perl很大程度上也是一个函数式语言。
+如果你对C/C++熟悉的，可以把高级函数想象为一个接受函数指针作为参数的函数。
 
-**闭包**是那些带着它们被定义时的环境的函数。特别的，一个闭包可以引用它定义时存在的变量。让我们把上面那个函数变得更通用一些，以便我们可以对任何整数列表乘以一个任意值`n`:
+**闭包（Closure）** 是指那些带有它们被定义时的“环境”的函数。特别的，一个闭包可以引用它定义时存在的变量。让我们把上面那个函数变得更通用一些，以便我们可以对任何整数列表乘以一个任意值`n`:
 
 ```ocamltop
 let multiply n list =
@@ -52,7 +51,7 @@ multiply 5 [1; 2; 3];;
 ```
 
 关于`multiply`函数有一点值得注意的是嵌套函数`f`.
-这是一个闭包。我们注意一下`f`怎样使用变量`n`的值，我们并没有把`n`作为显式的参数传递给它。`f`是从它的环境中找到它的。`n`是传递给函数`multiply`的参数，所以在这个函数中都是有效的。
+这是一个闭包。我们注意一下`f`怎样使用变量`n`的值，我们并没有把`n`作为显式的参数传递给它。`f`是从它的“环境”中找到它的。`n`是传递给函数`multiply`的参数，所以在这个函数中都是有效的。
 
 这可能听上去很简单，但让我们更进一步的仔细观察下那个对map的调用`List.map f list`.
 
@@ -82,7 +81,7 @@ end
 现在来看`receiver_fn`的定义。这个函数是一个闭包，因为它含有一个引用,
 这个引用指向它的环境中的`chan`。
 
-## 偏函数应用（Partial function applications）和 currying（科里化）
+## 偏函数应用（Partial function applications）
 
 让我们定义一个加法函数用来相加两个整数。
 
@@ -145,11 +144,7 @@ let plus 2 b =       (* 这不是真正的OCaml代码！ *)
 plus 2 3 : int
 ```
 
-这个过程叫做**currying（科里化）** (或者应该叫 **uncurrying（去科里化）**,
-我一直搞不清这两个定义).这个名字来源与Haskell Curry的与lambda
-calculus有关的重要发现。为了避免进入OCaml背后的数学世界而使这个教程变得过于繁琐，我将不会再进一步地说明这个主题。如果感兴趣，你可以从[用
-Google](http://www.google.com/search?q=currying "http://www.google.com/search?q=currying")
-（译注：国内的小伙伴们可能要自行百度了）来获得更多关于currying的信息。
+这个过程叫做**偏函数的应用（Partial Application）**
 
 还记得开始时候我们的`double`和`multiply`函数吗？ `multiply`是这样定义的:
 
@@ -195,7 +190,7 @@ let plus = ( + );;
 plus 2 3;;
 ```
 
-这里是更多的一些有趣的curring：
+更多关于偏函数应用的例子：
 
 ```ocamltop
 List.map (plus 2) [1; 2; 3];;
@@ -242,43 +237,41 @@ for (i = 0; i < strlen (s); ++i)
 现在流行的做法是由顶至下地计划程序，但是作者的意见是这往往会让整个项目崩盘
 （译注人话：计划赶不上变化，怎么做评估都没用）。
 
-## 非懒惰和懒惰
+## 严格求值（Strictness）和惰性求值（Laziness）
 
-C类和ML类的语言都是非懒惰的（饥饿求值），而Haskell和Miranda都是懒惰的。OCaml是缺省非懒惰，
-但是在需要的时候支持懒惰的风格。
+类C和ML系的语言都是严格求值的，而Haskell和Miranda都是非严格求值的，或者说是惰性的。虽然OCaml默认是严格求值的，
+但需要时也可使用惰性求值风格进行编程。
 
-对于一个非懒惰的语言，参数和函数总是在使用前被求值，然后再传入到函数中。比如
+对于一个严格求值的语言，参数和函数总是在使用前被求值，然后再传给函数。比如
 下面的代码会引起除零错误：
 
 ```ocamltop
 let give_me_a_three _ = 3;;
 give_me_a_three (1/0);;
 ```
 
-如果你用一些传统的语言编程，这就是这么回事，但是你可能会为事情还可以
-以另一个方式发生而惊讶。
+如果使用一些传统的语言编程，可能以上代码会如描述的那样产生错误。但如果使用惰性求值的方式运行这段代码，结果则可能会出人意表。
 
-在懒惰语言中，一些奇怪的事情会发生。函数的参数只有在被使用的时候才会被求值。
-`give_me_a_three`没有使用参数而直接返回3，因而在一个懒惰语言中，这个函数调用
-不会失败，因为这个参数根本没有被求值！因此，也不会引起除零错误。
+在惰性求值的语言中，因为函数的参数只有在被使用的时候才会被求值，所以会有一些不一样的事情发生。
+比如，因为其第一个参数不会被求值，函数`give_me_a_three`会直接返回`3`。因此，除零错误根本不会发生。
 
-懒惰语言允许你定义无限长的链表，只要你不会真的要遍历整个链表（比方说你只要前10个元素）。
+惰性求值的语言允许你定义无限长的链表，只要你不会真的要遍历整个链表（比方说你只要前10个元素）。
 
-OCaml是一个非懒惰的语言，但是`Lazy`模块允许你写懒惰的表达式，下面就是这样一个例子：
+虽然OCaml是一个严格求值的语言，但是`Lazy`模块允许你写惰性求值的表达式，下面是一个示例：
 
 ```ocamltop
 let lazy_expr = lazy (1/0)
 ```
 
 注意到其类型是 `int lazy_t`。
 
-因为`give_me_a_three`的输入是任何类型，所以我们也可以把这个懒惰表达式传入：
+因为`give_me_a_three`的输入可以是任何类型，所以我们也可以把惰性求值的表达式传进去：
 
 ```ocamltop
 give_me_a_three lazy_expr
 ```
 
-如果要求值，我们要用`Lazy.force`函数：
+如果要求值，我们需要使用`Lazy.force`函数：
 
 ```ocamltop
 Lazy.force lazy_expr