函数式编程语言曲高和寡？

[quote]
看到作者 lichray 忙于研究数理逻辑，其父发出了由衷的感叹：你学的东西没人用啊。“谁说没人用？自己看不懂罢了。Haskell 的语法是‘写意’了点，但其中的思想清澈见底。”
[/quote]
[quote]
本文以一个函数式风格的快速排序算法为例，把它从 Haskell 代码改写为 大家所熟知的 JavaScript 代码，试图说明 FP 绝对是表达思想的最强工具。不要被那些 FP 语言们的语法所迷惑。终有一天，你会发现，原来这才是编程啊。
[/quote]

下面是一个 Haskell 写的快速排序算法，一共四行（想想学校里教的一般是多少行~）：
[code]
qsort [] = []
qsort (x:xs) = qsort lt ++ [x] ++ qsort st
where lt = [y | y <- xs, y < x]
st = [y | y <- xs, y >= x]
[/code]
想理解它是再简单不过的事：首先确定递归下界——排序空列表的结果为空列表本身。
qsort [] = []
然后把快速排序算法的目的描述一下：
把一个选出的元素（这里是第一个元素 x）作为“中间元素”，同时把剩余元素组成的列表记作 xs，将所有小于中间元素的元素组成的列表排序 qsort lt 连接上 ++ 这个元素“组成的列表”[x] 再连接上 ++ 所有大于等于这个元素的其它元素排序后的列表 qsort st；这里用到的 where 变量 it 指的是 = 所有小于它的元素组成的列表 [y | y <- xs, y < x]，st 指的是 = 所有大于等于这个元素的其它元素的列表 [y | y <- xs, y >= x]。

下面把它转换为较低级的 Scheme 代码。先分析一下这里用到的 Haskell 语言的特性：
[list=1]
[*]第一句，指定函数取值点。相对于数学中描述函数在某点取值的语法。对于普通的语言，可以用 if 语句代替。
[*]参数 (x:xs)，是参数领悟特性。指的是，此参数是一个由元素 x 开头，剩余部分为 xs 组成的列表。对于普通的语言，可以用在函数内部绑定参数的分解结果的方法代替。
[*]列表连接运算符 ++，用 append 函数代替。
[*]where 语句，后置变量说明。用前置 let 绑定代替。
[*]类似 [y | y <- xs, y < x] 的列表领悟。对于单元素的领悟，用 filter 函数过滤，过滤规则表示为 lambda 函数，它对于 y < x 返回 true。
[/list]
下面是转换后的 Scheme 版本的程序：
[code]
;; 使用 SICP 中描述的 filter 函数，就不抄在这儿了
(define (qsort ls)
(if (null? ls) '()
(let
((x (car ls))
(xs (cdr ls)))
(let
((lt (filter (lambda (y) (< y x)) xs))
(st (filter (lambda (y) (>= y x)) xs)))
(append (qsort lt) (list x) (qsort st))))))
[/code]

下面把它转换为我们需要的 JavaScript 代码。先分析一下这里用到的 Scheme 语言的能力：
[list=1]
[*]取列表首项函数 car，用 [i]Array[/i][0] 代替。
[*]取列表剩余项函数 cdr，用 [i]Array[/i].slice(1) 代替。
[*]判断列表是否为空函数 null?，用 ls == false 代替（JS 的特殊之处）。
[*]变量绑定语法 let，仅用声明变量语法 var 代替（千万不能不用）。// 在 JavaScript 1.6 中加入了 let 关键字，爽一点；还有列表领悟，无语了！
[*]过滤器函数 filter。为快一点起见，自己用命令式风格写一个绑定在 Array.prototype 上。
[*]匿名函数 lambda，不就是匿名 function 嘛！
[*]列表连接函数 append，用 [i]Array[/i].concat() 代替。
[/list]
OK。下面是要用到的、对 JavaScript 1.5 作出的扩展：

// 把要用到的表达式抽象出来
Array.prototype.head = function () {
    return this[0];
}

Array.prototype.tail = function () {
    return this.slice(1);
}

Array.prototype.filter = function (proc) {
    var tmpArr = [];
    for (var i = 0; i < this.length; i++)
	if (proc(this[i]) == true)
	    tmpArr.push(this[i]);
    return tmpArr;
}

这样就可以写出转换后的 JavaScript 代码了：

Array.prototype.qsort = function () {
	if (this == false) return []
	var x, xs, lt, st
	x = this.head()
	xs = this.tail()
	lt = xs.filter(function (y) {return y < x})
	st = xs.filter(function (y) {return y >= x})
	return lt.qsort().concat([x], st.qsort())
}

最后试一下：
js> [4,7,9,1,3,5].qsort()
1,3,4,5,7,9
是不是有一种“终于找到组织了”的感觉呢？

题外话：
对比一下用命令式方法写成的 JavaScript 版的快速排序：

function qsort (arr, l, u) {
    l = l || 0;
    u = ((u != 0) && (u == undefined)) ? arr.length : u;
    if (l >= u) return;
    var m = l;
    for (var i = l+1; i <= u; i++)
	if (arr[i] < arr[l])
	    arr.swap(++m, i);
    arr.swap(l, m);
    qsort(arr, l, m-1);
    qsort(arr, m+1, u);
}

代码好像少一点，但我没看懂——虽然是我自己写的，3 个月前写的——要是有 bug 我就直接 faint 了...
JavaScript 真是一个站在函数式编程语言与命令式编程语言之间的奇特生物——包容任何思想，这也是我钟爱 JavaScript 的一个重要原因。

函数式编程语言曲高和寡，谁说的？掌握其思想是重要的，也是容易的；语言是其次，只是表达思想的工具罢了。