Y-Combinator : 实现在λ演算里面的递归

这个名字和什么孵化器重名。为了澄清，这里的是程序设计里面的Y-Combinator。

使用JavaScript的原因仍然是它适合常人理解，尤其是对函数式编程没有任何概念的人。

引入

在λ演算里面是没有，拥有具体名字的函数的，例如一个最简单的例子——递归求阶乘，你可能会这样写一段代码：

function fact(n)
{return n > 1 ? n * fact(n - 1) : 1;
}

我们现在把它变成λ函数版本的：

function(n)
{return n > 1 ? n * fact(n - 1) : 1;
}

那么问题就来了，fact咋办？在最开始的代码中，fact事实上就是这个被调用的函数。而第二段代码，里面可没有什么fact，而之前的调用fact，现在就变成了调用λ函数本身。但是，λ函数可没有this指针这样的东西，那怎么办嗯？

对应的故事依然存在于λ演算，没法操作一个匿名函数完成递归。这显然令人感到不愉快。

一个很好的想法是我们把这个函数作为另一个匿名函数的参数：

function(fact)
{return function(n){return n > 1 ? n * fact(n - 1) : 1;}
}

但是问题也来了，调用的时候传入的fact是什么呢？。

虚假的Y-Combinator

我们把这个函数叫做h（这样似乎失去了匿名函数的意义，但是它是一个不错的理解方式）:

let h = function(fact)
{// return的这个lambda叫做greturn function(n){return n > 1 ? n * fact(n - 1) : 1;}
}

现在我们要找到一个特殊的函数Y，它能做到这个效果：Y(h) == h内层的λ函数 == g。方便起见，我们把内层的λ叫做g。

而上面的这个h，只需要h(g)即可拿到g。也就是说，h(g) == g。

这条性质类似于f(x) == x，一个函数传入参数x，得到的返回值依然是x。这个x就是函数f的不动点。当然不动点通常是个值，但是它也可以是个函数。

从h(g) == g来看，函数h的不动点就是内层的λ函数g。

那么，Y的工作就变成了拿到函数h的不动点g。这就是所谓的不动点组合子：Y-Combinator。

容易得到：Y(h) == g == h(g) == h(Y(h))。（如果没看出来：Y(h)会得到g，g是函数h的不动点，因此h(g)也得到g，再将Y(h) == g代换到h(g)得到h(Y(h))）。

这样你就能快速得到下面的代码了：

function Y(h)
{return h(Y(h));
}

这就是不严格的Y-Combinator，准确说它压根不是Y-Combinator:

我们用函数式的写法写出来，如果不熟悉下面的语法——Y(h)在下面被写成了Y h，对应的，h (Y h)的意思就是h(Y(h))，括号依然是为了表明运算优先级：

不严格的Y-Combinator懒惰求值版本: g == (Y h) == h (Y h)

试试能用吗？写一下let fact = Y(h); 看看?

可能发现不能用了：

h(Y(h))

-> h(h(Y(h)))

-> h(h(h(Y(h))))

-> h(h(h(h(Y(h)))))

...

这个递归是无法终止的。所以上面的函数是无法在JavaScript中运行的。但是如果你有一个懒惰求值的语言（这类语言通常是函数式语言），可以试试，会发现它确实能得到正确的结果。JavaScript不会懒惰求值，因此我们需要一个小技巧。

回到JavaScript的例子。因为函数g是一个带参数的函数（本文的例子是带一个参数），所以我们可以引入一个新的函数：

function(x)
{return g(x);
}

很显然这个函数是和g等价的，无论g想干什么。试一试是否如此呢？

而g可以替换成Y(h)，因此：

function(x)
{return (Y(h))(x);    // 可以写成Y(h)(x), 这样看着更简洁
}

现在我们可以设计这个函数Y了：

function Y(h)
{return h(function(x){return Y(h)(x);});
}

ok~任务倒此完成一半了，试试下面的代码，是否得到了7的阶乘呢？

function Y(h)
{return h(function(x){return Y(h)(x);});
}
console.log("7! = ", Y(function(fact)
{return function(x){return x > 1 ? x * fact(x - 1) : 1;};
})(7));

我们把上面的式子变成函数式的写法：

不严格的Y-Combinator严格求值版本: g == (Y h) == (h (λx.( (Y h) x ) ) )

真正的Y-Combinator

真正的Y-Combinator是不含有自由变量的Y的，在上面的例子我们一直使用着一个在别处定义的变量Y，用Y(h)(x)来完成一个递归操作，因而不是真正的Y-Combinator。

真正的Y-Combinator是这样的：Y = λf.(λx.f (x x)) (λx.f (x x))

它能够满足Y f = f (Y f)

参考

最大的参考是The Y Combinator (Slight Return)，然后还有各个大佬的文章或博客。