javascript上通过YCombinator实现递归
- 前言
- 问题-递归的支持
- 答案-part1-使用YCombinator来自制递归
- 第一次尝试
- 第二次尝试
- 第三次尝试
- 第四次尝试
- 最终次尝试
- 答案-part2-YCominator的实现
前言
这是一篇很干很干的货~
问题-递归的支持
如果一个编程语言，函数是一等公民，比如javascript，但是在语言层面就不支持递归（这是一个蛋疼的假设），那该怎么办？
比如下面这个阶乘的例子（为了简单起见，假设了入参n是>=2的正整数，函数定义里就不检查了）
//如果javascript支持递归我们会这样定义阶乘函数
function factorial(n){
if (n==2) return 2;
else return n*factorial(n-1);
//上一行根据我们蛋疼的假设，代码中的factorial要报错，
//因为翻译器/编译器认定factorial函数的调用
//在factorial函数的定义内部不可被执行
}
console.log(factorial(5));
//上一行如果语言层面支持递归，此处本应打印120答案-part1-使用YCombinator来自制递归!
假设有一个伪装得很像递归函数的函数
//此处多传入一个很神奇的入参self，self是一个函数
function fakeFactorial(self,n){
if (n==2) return 2;
else return n*self(n-1);
//上一行使用self就像使用递归函数factorial一样，
//假装此处self(n-1)的调用等同于递归调用factorial(n-1)
}假设再有一个更神奇的Y函数，也就是YCombinator了，简称Y
//通过伪装递归函数fakeFactorial获得真正的递归函数factorial
var factorial = Y(fakeFactoial);
console.log(factorial(5));
//上一行打印120！我们在语言层面不支持的情况下自己实现了递归！
//不论fakeFactorial还是factorial还是Y的定义里面都不存在递归调用我们写的每个伪装递归函数（包含真正递归逻辑的）都统称为F，上面例子里F就是fakeFactorial
然后通过神奇的Y函数就可以得到一个真正的递归函数f，上面例子里f就是factorial
利用Y函数实现递归的统一写法就是 f=Y(F)，上例里就是factorial=Y(fakeFactorial)
然后我们就可以直接使用f了
这样的Y函数存在吗？是咋实现的？里面是不是偷偷使用了递归？是不是！
根据不动点理论，任何一个…（此处省略1万字理论）…，所以Y函数是存在的。
呃~~~~ 作为资深码农，我们还是来看程序怎么一步一步实现这个Y函数吧
第一次尝试
既然在factorial里面不能调用factorial，那我把factorial作为参数一起传给factorial函数自己不就可以了么。
function factorial(self,n){
if (n==2) return 2;
else return n*self(self,n-1);//此处太丑陋
//上一行我们想要n*self(n-1),不是n*self(self,n-1)
}
console.log(factorial(factorial,5));
//此处打印了120！程序正确运行了！把这个版本改名如下
function fakeFactorial(uglySelf,n){
if (n==2) return 2;
else return n*uglySelf(uglySelf,n-1);
//上一行的uglySelf的值是实际上是fakeFactorial函数，
//而我们想要的是factorial函数
}
console.log(fakeFactorial(fakeFactorial,5));
//此处打印了120！程序正确运行了！那Y的实现就很简单了
//入参F是伪装递归函数，比如例子里的fakeFactorial
function Y(F){
return function(n){
return F(F,n);
};
}
var factorial = Y(fakeFactorial);
console.log(factorial(5));
//打印120了，程序正确好像很简单嘛，但是仔细看和最终的正确答案还是不太一样啊，我们再重新审视第一次尝试里的fakeFactorial的实现
function fakeFactorial(uglySelf,n){
if (n==2) return 2;
else return n*uglySelf(uglySelf,n-1);
//上一行我们目标是n*self(n-1)而不是
//丑陋的n*uglySelf(uglySelf,n-1)
}目标是n*self(n-1)，如果我们能把其中的
...
else return n*uglySelf(uglySelf,n-1);
...先变成
var self=uglySelf(uglySelf);
...
else return n*self(n-1);
...不就可以了么，easy。
第二次尝试
鉴于uglySelf其实就是fakeFactorial，那我们只要改造fakeFactorial，接受uglySelf（也就是fakeFactorial）作为参数，返回一个接受n作为参数的self（也就是factorial）函数就ok了
function fakeFactorial(uglySelf){
var factorial = function(n){
var self=uglySelf(uglySelf);
if(n==2)return 2;
else return n*self(n-1);
}
return factorial;
}
var factorial = fakeFactorial(fakeFactorial);
console.log(factorial(5));
//又打印120了，程序正确那么Y的实现就更简单了
//此处入参F就是伪装递归函数fakeFactorial
function Y(F){
return F(F);
}
var factorial=Y(fakeFactorial);
console.log(factorial(5));
//打印120，妥妥的我们再来回顾一下第二次尝试里面的fakeFactorial
function fakeFactorial(uglySelf){
var factorial = function(n){
var self=uglySelf(uglySelf);
//***以下两行就是最终正确的递归实现***
if(n==2)return 2; //<==正确的递归书写逻辑
else return n*self(n-1); //<==正确的递归书写逻辑
//***以上两行就是最终正确的递归实现***
}
return factorial;
}我们把fakeFactorial函数里“两行正确的递归书写逻辑”放入真正的“fakeFactorial”函数里，然后把第二次尝试里的fakeFactorial改个名字，比如generateFactorial
第三次尝试
首先是正确的我们要的最终的fakeFactorial函数定义
function fakeFactorial(self,n){
if(n==2)return 2; //<==我们要的正确的递归书写
else return n*self(n-1); //<==我们要的正确的递归书写
}然后是generateFactorial函数
function generateFactorial(uglySelf){
var factorial = function(n){
var self=uglySelf(uglySelf);
//***以下调用正确的fakeFactorial替换之前的正确书写的两行递归实现***
return fakeFactorial(self,n);
}
return factorial;
}测试一下
var factorial = generateFactorial(generateFactorial);
console.log(factorial(5));
//输出120，成功正确的答案越来越近了
回顾第三次尝试中的generateFactorial函数和fakeFactorial函数，我们发现在generateFactorial函数里是写死了对fakeFactorial函数的调用的，如下
function generateFactorial(uglySelf){
var factorial = function(n){
var self=uglySelf(uglySelf);
//***以下调用正确的fakeFactorial替换之前的正确书写的两行递归实现***
return fakeFactorial(self,n);//此处写死了对fakeFactorial的调用
}
return factorial;
}在这里我们需要把fakeFactorial函数作为参数绑定到generateFactorial函数里面，另外有那个已经快要被忘却的Y函数
第四次尝试
先保持正确的fakeFactorial函数不变
function fakeFactorial(self,n){
if(n==2)return 2;
else return n*self(n-1);
}然后是把fakeFactorial绑定到generateFactorial函数里的函数
//bind的入参F就是正确的伪装递归函数fakeFactorial
function bindFactorial(F){
var generateFactorial=function(uglySelf){
var factorial = function(n){
var self=uglySelf(uglySelf);
return F(self,n);//此处就是对fakeFactorial的调用
}
return factorial;
}
return generateFactorial;
}测试一下
var generateFactorial = bindFactorial(fakeFactorial);
var factorial = generateFactorial(generateFactorial);
console.log(factorial(5));
//打印了120上面的测试代码已经说明了Y函数应该是怎么样的了
//此处入参F就是fakeFactorial函数
function Y(F){
var generateFactorial = bindFactorial(F);
var factorial = generateFactorial(generateFactorial);
return factorial;
}再测试一下
var factorial = Y(fakeFactorial);
console.log(factorial(5));
//输出120，正确！此时此刻我们已经得到了正确的fakeFactorial，和正确的Y函数，并且通过Y(fakeFactorial)的返回值得到正确的factorial递归函数。
不过bindFactorial函数是个中间产物，完全可以合并到Y的逻辑里面，这样整个儿世界就清爽了
最终次尝试
首先还是正确的fakeFactorial逻辑
function fakeFactorial(self,n){
if(n==2)return 2;
else return n*self(n-1);
}然后我们来合并Y，先简单copy&paste，然后看看哪些地方可以精简的
function Y(F){
var bindFactorial=function(F){//bindFactorial的定义可以删掉
var generateFactorial=function(uglySelf){
var factorial = function(n){
var self=uglySelf(uglySelf);
return F(self,n);
}
return factorial;
}
return generateFactorial;//bindFactorial的return也可以去掉
}//bindFactorial定义结束的花括号可以删掉
var generateFactorial = bindFactorial(F);//bindFactorial去掉后此行调用也可以去掉了
var factorial = generateFactorial(generateFactorial);
return factorial;
}初步简化后的版本
function Y(F){
var generateFactorial=function(uglySelf){//generateFactorial可以替换为fGen更通用
var factorial = function(n){//factorial可以替换为f就通用了
var self=uglySelf(uglySelf);
return F(self,n);
}
return factorial;
}
var factorial = generateFactorial(generateFactorial);//generateFactorial可以替换为fGen
return factorial;
}再把变量名替换成通用的版本
function Y(F){
var fGen=function(uglySelf){
var f = function(n){
var self=uglySelf(uglySelf);
return F(self,n);
}
return f;
}
var f = fGen(fGen);
return f;
}测试一下
var factorial = Y(fakeFactorial);
console.log(factorial(5));
//输出120，全无意外如有代码洁癖可以再来个脱水版本的Y函数
function Y(F){
var fGen=function(uglySelf){
return function(n){
return F(uglySelf(uglySelf),n);
}
}
return fGen(fGen);
}答案-part2-YCominator的实现
通过上面总共五次的尝试，我们得到了神奇Y函数的实现，在一个函数作为一等公民的语言里，如果这个语言层面不支持递归（又见蛋疼假设），我们就可以用Y函数配合伪装递归函数来实现递归逻辑的编写。
Y函数如下
function Y(F){
var fGen=function(uglySelf){
return function(n){
return F(uglySelf(uglySelf),n);
}
}
return fGen(fGen);
}阶乘的伪装递归函数如下
function fakeFactorial(self,n){
if(n==2)return 2;
else return n*self(n-1);
}真正的阶乘函数可以通过运行Y得到
var factorial = Y(fakeFactorial);
console.log(factorial(5));//打印120，正确完成递归函数的调用