本文原发于个人博客
递归 作为盘算机科学中很主要的一个观点，运用局限异常普遍。比较主要的数据结构，像树、图，自身就是递归定义的。
比较罕见的递归算法有阶乘、斐波那契数等，它们都是在定义函数的同时又援用自身，关于初学者来讲也比较好邃晓，然则假如你对编程言语，特别是函数式言语，有所研讨，能够就会有下面的疑问：
一个函数在还没有定义完整时，为何能够直接挪用的呢？
这篇文章主如果解答上面这个题目。浏览下面的内容，你须要有些函数式编程的履历，为了保证你能够比较兴奋的浏览本文，你最少能看懂前缀表达式。置信读完本文后，你将会对编程言语有一全新的熟悉。
本文一切演示代码有Scheme、JS两个版本。
题目形貌
下面的解说以阶乘为例子：
; Scheme
(define (FACT n)
(if (= n 0)
1
(* n (FACT (- n 1)))))
; JS
var FACT = function(n) {
if (n == 0) {
return 1;
} else {
return n * FACT(n-1);
}
} 上面的阶乘算法比较直观，这里就不再举行诠释了。重申下我们要探讨的题目
FACT这个函数为何在没有被定义完整时，就能够挪用了。
题目剖析
处置惩罚一个新题目，罕见的做法就是类比之前处置惩罚的题目。我们要处置惩罚的这个题目和求解下面的等式很相似：
2x = x + 1
在等号双方都涌现了x，要想处置惩罚这个题目，最简朴的体式格局就是将等号右侧的x移到左侧即可。如许就晓得x是什么值了。
然则我们的题目比这个要庞杂些了，由于我们这里须要用if、n、*、-这四个标记来示意FACT，能够这么类比是由于一个递次不过就是经由过程一些具有特定语意的标记（编程言语划定）组成的。
再进一步思索，FACT 须要用四个标记来示意，这和我们求解多元方程组的解不是很像嘛：
x + y = 3
x - y = 1
为了求解上面方程组，平常能够转为下面的情势：
x = 3 - y
y = x - 1
即
(x, y) = T (x, y)
个中的T为一个转换，在线性代数实在就是个矩阵，依据矩阵T的一些性子，我们能够剖断(x ,y)是不是有解，以及解的个数。
对照此，我们能够把题目转化为下面的情势：
FACT = F (FACT)
上面的F为某种转换，在这里实在就是个须要一个函数作为参数而且返回一个函数的函数。假如存在这么个F函数，那末我们就能够经由过程求解F的不动点来求出FACT了。
但这里有个题目，即使我们晓得了F的存在，我们也没法肯定其是不是存在不动点，以及假如存在，不动点的个数又是若干？
盘算机科学并不像数学范畴有那末多能够套用的定理。
寻觅转换函数 F
证实F是不是存在是个比较难的题目，不在本文的议论局限内，这涉及到Denotational semantics范畴的学问，感兴趣的读者能够本身去网上查找相干材料。
这里直接给出FACT对应的函数F的定义：
; Scheme
(define F
(lambda (g)
(lambda (n)
(if (= n 0)
1
(* n (g (- n 1)))))))
; JS
var F = function(g) {
return function(n) {
if (n == 0) {
return 1;
} else {
return x * g(n-1);
}
}
}
能够看到，对照递归版本的FACT更改不大，就是把函数内FACT的挪用换成了参数g罢了，实在我们罕见的递归算法都能够这么做。
寻觅转换函数 F 的不动点
找到了转换函数F后，下一步就是肯定其不动点了，而这个不动点就是我们终究想要的FACT。
FACT = (F (F (F ...... (F FACT) ...... )))
假定我们已晓得了FACT非递归版本了，记为g，那末
E0 = (F g) 这时候(E0 0) 对应 (FACT 0)得值，这时候用不到 g
E1 = (F E0) 这时候(E1 0)、(E1 1)离别对应(FACT 0)、(FACT 1)的值
E2 = (F E1) 这时候(E2 0)、(E2 1)、(E2 2)离别对应(FACT 0)、(FACT 1)、(FACT 2)的值
.....
En = (F En-1) 这时候....(En n)离别对应.... (FACT n)的值能够看到，我们在求出(FACT n)时完整没有用到初始的g，换句话说就是g的取值不影响我们盘算(FACT n)。
那末我们完整能够这么定义FACT：
FACT = (F (F (F ...... (F 1) ...... )))
惋惜，我们不能这么写，我们必需想个办法示意无限。在函数式编程中，最简朴的无限轮回是：
; Scheme
((lambda (x) (x x))
(lambda (x) (x x)))
; JS
(function (x) {
return x(x);
})(function(x) {
return x(x);
});
基于此，我们就获得函数式编程中一主要观点 Y 算子，关于 Y 算子的严厉推导，能够在参考这篇文章 The Y combinator (Slight Return)，这里直接给出：
; Scheme
(define Y
(lambda (f)
((lambda (x) (f (x x))
(lambda (x) (f (x x)))))))
(define FACT (Y F))
; JS
var Y = function(f) {
return (function(x) {
return f(x(x));
})(function(x) {
return f(x(x));
});
}
var FACT = Y(F);如许我们就获得的FACT了，但这里获得的FACT并不能在Scheme或JS诠释器中运转，由于就像上面说的，这实际上是个死轮回，假如你把上面代码拷贝到诠释器中运转，平常能够获得下面的错：
RangeError: Maximum call stack size exceeded正则序 vs. 运用序
为了获得能够在Scheme或JS诠释器中能够运转的代码，这里须要诠释复合函数在挪用时传入参数的两种求值战略：
正则序（Normal Order），完整睁开然后归约求值。惰性求值的言语采纳这类递次。
运用序（Applicative Order），先对参数求值然后运用。我们经常运用的大部分言语都采纳运用序。
举个简朴的例子：
var p = function() {
return (p);
}
var test = function(x, y) {
if(x == 0) {
return 0;
} else {
return y;
}
}
test(0, (p));上面这个例子，采纳运用序的言语会发生死轮回；而采纳正则序的言语能够一般返回0，由于test的第二个参数只要在x不即是0时才会去求值。
我们上面给出的var FACT = Y(F)在正则序的言语中是可行的，由于Y(F)中的返回值只要在真正须要时才举行求值，而在F中，n即是0时是不须要对g(n-1)举行求值的，所以这时候Y(F)(5)就能够一般返回120了。
假如你以为上面这段话很绕，一时不能邃晓，如许很一般，我也是花了良久才弄邃晓，你能够多找些惰性求值的文章看看。
为了能够得出在运用序言语可用的FACT，我们须要对上面的Y做进一步处置惩罚。思绪也很简朴，为了不马上求值表达式，我们能够在其外部包一层函数，假定这里有个表达式p：
var lazy_p = function() { return p; }这时候假如想获得p的值，就须要(lazy_p)才能够获得了。基于这个道理，下面给出终究版本的Y 算子：
; Scheme
(define Y
(lambda (f)
((lambda (x) (x x))
(lambda (x) (f (lambda (y) ((x x) y)))))))
(define FACT (Y F))
(FACT 5) ;===> 120
; JS
var Y = function(f) {
return function(x) {
return x(x)
}(function (x) {
return f(function(y) {
return x(x)(y)
})
})
}
var FACT = Y(F)
FACT(5) ;===> 120好了，到现在为止，我们已获得了能够在Scheme或JS诠释器中运转FACT了，能够看到，这内里没有运用函数名也完成了递归体式格局求阶乘。
本文一开始给出的FACT版本在诠释器内部也会转换为这类情势，这也就诠释了本文所提出的题目。
总结
本文大部分内容由 SICP 4.1 小节延长而来，写的相对照较粗拙，很多点都没有睁开讲的原因是我本身也还没邃晓透辟，为了不误导人人，所以这里就省略了（背面邃晓的更深入后再来填坑?）。愿望感兴趣的读者能够本身去搜刮响应学问点，置信肯定会受益不浅。
末了，愿望这篇文章对人人邃晓编程言语有一些协助。有什么不对的地方请留言指出。
