按语：我从悬崖上跳了下去，在除了坠落没别的事可干的过程中为「不懂编程的人」写了这一系列文章的第八篇，整理于此。它的前一篇是《周游抑或毁灭世界》，讲述了递归函数的基本用法。
警告，这一篇很长。若不能坚持看到最后，最好还是别看了。更何况，不看它，也没啥损失。
下面这个函数，可以对自然数求和：
(defun sum (n)
(if (= n 0)
0
(+ n (sum (- n 1)))))传说数学界的大宗师高斯同学上小学的时候，曾因飞快地算出从 1 到 100 的自然数之和而震惊四座。
在计算机里不需要精巧，只需要笨拙，所以上述的 sum 函数就是从大到小，将数字逐一累加。例如：
(sum 100)在 sum 这台发动机周而复始的运转中，每次都将自己的参数减去 1，然后与自己下一次的运行结果相加，最终发动机的运转轨迹形成了 100 + 99 + ... + 1 + 0 这样的表达式，当然在 Emacs Lisp 里是这样的：
(+ 100 (+ 99 (+ ... (+ 1 0) ...)))当 sum 发现自己的参数为 0 时，它就停止转动，此时 Emacs Lisp 就得到了上述的表达式，接下来，Emacs Lisp 解释器就开始对这个很长的表达式求值，不过就是逐一完成数字累加的这种粗笨的工作，结果为 5050，跟高斯算出来的一样，而且可能比高斯算得还要快许多倍。
不过，这篇文章不是再次重复发动机啊发动机啊的，而是开始思考怎么去定义一个不知道名字的发动机。
再看一遍 sum 函数的定义：
(defun sum (n)
(if (= n 0)
0
(+ n (sum (- n 1)))))要让一个发动机周而复始地运转，必须得知道它的名字。有了名字，sum 函数方能在自己的定义中对自己进行求值。
于是，问题就来了。倘若宇宙的一切运动是由一台发动机驱动起来的，那么这台发动机是如何运转的呢？这台发动机没有名字，因为它比我们这些命名者先出现。这台发动机的存在，暗示着，没有名字也能周而复始。
所谓函数，本质上就是值与值的映射，它有没有名字，无关紧要，关键在于能否在不依赖名字的前提下精确描述映射关系。为此，Emacs Lisp 语言提供了让函数匿名的语法——Lambda 表达式。对于函数 f(x, y) = x + y，用 Lambda 表达式可表示为：
(lambda (x y) (+ x y))倘若 x = 1, y = 2，那么如何通过这个 Lambda 表达式对 f(x, y) 进行求值呢？像下面这样做：
(funcall (lambda (x y) (+ x y)) 1 2)在 Emacs Lisp 程序中，需要借助 funcall 方能对匿名函数进行求值。在其他的一些 Lisp 语言里，可不必如此。没错，世界上不止一种 Lisp，Emacs Lisp 不过是 Lisp 语言世界里的一种方言。在 Scheme 这种 Lisp 方言里，对上述的匿名函数进行求值，只需：
((lambda (x y) (+ x y)) 1 2)没有名字，会让世界变得更混乱一些，不过这反而是世界原本的样子。从这个角度去探索世界的本原会更为客观，可能也更为奇妙。
当我们仰望星空，俯瞰大地，感觉冥冥中有一种力量在驱动着或者支配着这个世界的运行，我们没法给这种力量取名，即使取了名，似乎也没有用，因为没法根据所取的名字去描述它的运作原理。智慧如老子，也只能勉强给这种力量取个名字，叫作「大」。大，就是没有边界。没有边界，就是非常遥远。非常遥远，就是自己的后脑勺——你向任何一个方向看去，距离你最远的地方是你的后脑勺。
不能给这种力量取名，就没法描述它的运作原理了吗？倘若世界受一台没有名字的发动机的驱动而运转，那么我们随便从这个世界里找一台发动机，然后利用匿名函数消除这台发动机的名字，结果是不是就能够切实感受到它的存在呢？
试试看：
(lambda (n)
(if (= n 0)
0
(+ n (sum (- n 1)))))很好，已经消除掉外层的 sum 了，但是里面的 sum 怎么消除？这需要借助一个小技巧，即它虽然在那里，但是我们可以装作看不见它。就像房间里有一个人，你不喜欢他，但是又没有能力让他消失，所以只好装作没看见他。每个人应该都具备这种技能。那么，怎样对上面这个匿名函数里面的 sum 视而不见呢？把它当作房间里一种没有意义的物件就可以了，像下面这样：
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (thing (- n 1))))))没有意义，就是意义不确定。意义不确定的东西，就是变量。函数的参数是变量。所以，只需要将 sum 变成一个函数的参数，就相当于对它视而不见处了。
现在已经成功地将所有的 sum 消除了，我们得到了一个没有名字的函数。不过，再仔细看一下，真的得到了一个没有名字的函数吗？在上述函数的定义中，(thing (- n 1)) 显然是一个函数求值表达式，因此我们不经意间依然将 thing 当成了一个有名字的函数了。要彻底的消除名字，必须将 thing 当成一个匿名函数，对它进行求值要借助 funcall，因此上述函数应当改成：
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))注：在一些其他 Lisp 方言里，例如 Scheme，不需要这一步。
现在算是彻底消除了名字。现在，我们将这个函数视为我们所创造的第一个没有名字的函数，但是为了便于描述，姑且将其称为 X。对 X 进行求值，需要向它传递一个匿名函数，求值结果是一个匿名函数，就这么奇怪。
X 能够用于自然数序列的求和吗？试试看：
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1)))))) ...)注：SegmentFault 网站的 Markdown 解析器可能有 Bug。以单个字母 + 1 个空格开头的文本，会被误认为是带编号的列表，从而变成 1. ... ...。写着写着就发现，在省略号的地方写不下去了，不知道该向这个函数传递什么样的参数。虽然我们很清楚，thing 应该是一个匿名函数，但是我们现在并没有这个函数。因此，不妨试着随便定义一个，将它作为 thing 传给 X，看看会发生什么：
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1)))))) (lambda (m) m))新定义的匿名函数就是 (lambda (m) m)，这个函数什么也没做，就是把自己接受的参数作为求值结果。将它作为参数传递给 X 之后，X 的求值结果就是下面这个匿名函数：
(lambda (n)
(if (= n 0)
0
(+ n (funcall (lambda (m) m) (- n 1)))))倘若将 100 传递给这个匿名函数，即：
(funcall (lambda (n)
(if (= n 0)
0
(+ n (funcall (lambda (m) m) (- n 1))))) 100)结果得到 199，而不是 5050。看来这个匿名函数只能算 100 + 99。不要沮丧，因为我们现在又得到了一个可以作为 thing 传给 X 的匿名函数了。把它传给 X：
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1)))))) (lambda (m) m)))现在，得到的是能够计算 100 + 99 + 98 的匿名函数。
是不是发现了一点玄机了？我们一开始随便定义了一个匿名函数，把它传给 X，结果得到了一个新的匿名函数，然后再将这个新的匿名函数传递给 X。
再试试用同样的手法， 将能够计算 100 + 99 + 98 的匿名函数传给 X：
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1)))))) (lambda (m) m))))结果就得到了一个能计算 100 + 99 + 98 + 97 的匿名函数。
继续将能计算 100 + 99 + 98 + 97 的匿名函数传给 X：
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1))))))
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing (- n 1)))))) (lambda (m) m)))))结果就得到了一个能计算 100 + 99 + 98 + 97 + 96 的匿名函数了。
只要你不怕麻烦，可以将上述过程继续下去，最终 X 就能算出 100 + 98 + ... + 1 + 0。最后一次传给 X 的匿名函数必定是体积极为庞大的怪物。
为了更便于理解，我们用 X 这个名字，将能计算 100 + 99 + 98 + 97 + 96 的匿名函数简写成：
(funcall X
(funcall X
(funcall X
(funcall X (lambda (m) m)))))利用 X 生成匿名函数，再将这个匿名函数传递给 X，这个想法很好，只是在实现上有些愚蠢。这个过程类似于为了实现 1 个发动机运转 100 圈的效果，制造了 100 个发动机，让它们的每一个只运转一圈。即使这样做，也不是太难，但是倘若要实现 1 个发动机转无数圈的效果呢？好办，制造无数个发动机，让每一个只运转一圈。倘若你真的这样想，那就对了。制造无数个发动机，每一个只运转一圈，这不就是相当于将 X 作为参数传给自己，然后让它运转一圈吗？这个过程应该像下面这样描述：
(funcall X X)当然，在 X 的定义中，需要让作为参数的 X 运转一圈，以便生成像 (lambda (m) m) 这样的匿名函数。因此，将 X 的定义修改为：
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1))))))然后按照 (funcall X X) 这样写：
(funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1))))))
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1)))))))上述表达式的求值结果是一个匿名函数。个匿名函数是什么呢，就是 sum 函数。不信的话，就用它来计算 0 到 100 的和：
(funcall (funcall (lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1))))))
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1))))))) 100)这个表达式看上去很复杂，把它理解为 (funcall (funcall X X) 100) 会更清楚。这样，我们就构造了一个比上文用 X 构造的匿名函数再传给 X 的代码简洁了将近 100 倍的可对自然数序列求和的匿名函数。
看，我们没有使用 defun，单纯借助匿名函数就实现了一个递归函数。这说明了什么？这说明了，即使这个世界没有任何名字，它依然能够运转，亦即世界只能感受或描述，而不能定义。
一个周而复始的发动机，它之所以能够如此，不是因为它有了名字，而是因为它的本质在于将自己作为参数传递给自己。这就是函数递归求值的本质。
虽然我说的天花乱坠，但上面那个表达式实际上是无法求值的，Emacs Lisp 解释器会报错，说 thing 符号作为变量是无效的。这是因为，Emacs Lisp 语言由于历史太过于悠久，而 Lisp 的世界里许多好东西出现的比较晚，为了兼容过去的程序，导致 Emacs Lisp 解释器不得不墨守成规。要让上述表达式能够正确求值，需要在它之前使用下面的语句开启开启词法域模式：
(setq lexical-binding t)Emacs Lisp 解释器默认在动态作用域模式下工作，不能正确识别作为参数传递的匿名函数，而词法域模式却可以。关于动态作用域与词法域，以后再作介绍。
现在，我们仅实现了一个特定功能的匿名函数的递归求值，还没有真正达成我们的目标，即寻找一个通用的匿名函数递归机制。只有这种发动机能够驱动整个世界。不过，我们似乎已经有了一个正确的方向，现在要做的就是，继续前进。
重新观察 X：
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1))))))位于内层的匿名函数是与特定功能相关的部分，我们可以用前文已经使用了多次的手法，将这部分代码提出来，作为一个单独的匿名函数，称之为 F，然后想办法将它作为参数传给 X 即可。
F 的定义如下：
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1)))))这个定义是错的，因为 thing 原本是 X 的参数。之前， F 位于 X 内部，它认识 thing，现在它脱离了 X，就不认识它了。该怎么办呢？用老办法，凡是自己不喜欢的或者不认识的，统统提升为参数，装作没看见它们……于是，我们将 F 修改为：
(lambda (thing)
(lambda (n)
(if (= n 0)
0
(+ n (funcall (funcall thing thing) (- n 1))))))等会！这东西似曾相识，它不就是 X 么？没错……X 的引力太大，F 似乎无法挣脱它而孤立地存在。
再仔细研究一下，F 之所以难以摆脱 X，主要是因为 (funcall (funcall thing thing) (- n 1)) 的制约。这是个函数求值表达式，(funcall thing thing) 是一个函数，它接受一个参数。我们想办法把它作为 F 的参数如何？
试试看：
(lambda (thing*)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing* (- n 1))))))为了与 X 的参数 thing 有所区分，我特意将 F 的参数命名为 thing*，而实际上，继续用 thing 也没事。
倘若我们对 F 像下面这样求值：
(funcall (lambda (thing*)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing* (- n 1))))))
(lambda (m) (funcall (funcall thing thing) m)))看上去有点乱，这样看就比较清楚了：
(funcall F (lambda (m) (funcall (funcall thing thing) m)))就是向 F 传递了一个具有 1 个参数的匿名函数，函数体中的 thing 是 X 的参数，所以我们可以将上述表达式扔到 X 的定义里：
(lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))看，现在 X 里面不再有任何特定功能的代码了。我们已经成功地将原先的自然数求和的代码从 X 中分离了出来，这部分代码构成了匿名函数 F。
现在，我们再用 (funcall X X) 的办法对 X 进行求值，即：
(funcall (lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))
(lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m)))))这样，就可以得到一个递归的匿名函数，而且这个匿名函数里面没有任何特定功能的代码，它是一个通用的匿名递归函数。不过，现在它还不知道 F 是什么。用老办法，凡是你不喜欢的或者你不知道的，若你不想因为它们而坏掉好心情，就将它们统统提升为函数的参数：
(lambda (F)
(funcall (lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))
(lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))))我们将这个函数称为 Y。
还记得上面所定义的含有自然数求和代码的那个 F 吗？
(lambda (thing*)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing* (- n 1))))))以它为参数，对 Y 进行求值，即
(funcall (lambda (F)
(funcall (lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))
(lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))))
(lambda (thing*)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing* (- n 1)))))))看着挺复杂，实际上不过是 (funcall Y F)，求值结果是什么呢？一个匿名的自然数序列求值函数。倘若不信，那么用它算一下 0 到 100 的和：
(funcall (funcall (lambda (F)
(funcall (lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))
(lambda (thing)
(funcall F
(lambda (m) (funcall (funcall thing thing) m))))))
(lambda (thing*)
(lambda (n)
(if (= n 0)
0
(+ n (funcall thing* (- n 1))))))) 100)结果为 5050。
上述的匿名函数 Y，由于它所接受的参数是一个匿名函数。按照数学家们的说法，不管函数是不是匿名的，只要是参数为函数的函数，就叫算子。所以，函数 Y 应该叫 Y 算子，当然更多的人愿意称它为 Y 组合子，并将这个算子视为匿名函数世界中的神迹。发现这个算子的那个数学家，将这个算子的数学公式 Y = λf. (λx. f(x x)) (λx. f(x x)) 纹在了自己的胳膊上。
这个 Y 组合子，也就是我们一开始想要寻找的那个驱动整个世界的无名发动机。不过，现在它看上去还有点不够理想。因为它的参数 F 只是具有 1 个参数的函数，这意味着 Y 组合子构造的匿名递归函数只能接受 1 个参数。不过，这不是什么大问题，多个参数的函数总是能通过单个参数的函数构造出来，不过，这是另外一个话题了。
这篇文章可能你看不懂。没关系，不懂这个，不影响学会编程。类似于不懂汽车发动机原理，一样可以驾驶汽车。虽然数学家发现了 Y 组合子，但他们也不会真的在编程中使用这种东西来写递归函数。倘若你真的很想看懂这篇文章，唯一的办法是，集中精力，动手动脑，逐步推导。
下一篇：长长的望远镜
在写这篇文章时，参考了以下网络文档：
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。