Javascript推导Y-Combinator (来自Jim Weirich)

Y-Combinator : 实现在λ演算里面的递归 Y-Combinator, 实现在λ演算里面的递归,通俗地将,实现匿名函数(lambda函数)的递归 阅读详情

        熟悉函数式编程的同学都了解lambda表达式,程序设计语言里的lambda表达式来源于1936年邱奇发明的lambda演算。Y-Combinator正是lambda演算里最富有神秘色彩的一种函数。它的作用是在只有匿名函数的lambda演算里实现递归函数调用。推导Y-Combinator很多人都做过了,比如这篇Javascript推导 Deriving the Y Combinator in 7 Easy Steps(中文) 还有这篇原文使用Scheme中文翻译为Javascript的推导 The Why of Y (中文)。读过我发现推导过程思维跳跃性有点大,且每个步骤没有给出足够的解释。本篇向读者揭示了如何反复重构一个普通的阶乘函数从而推导出Y-Combinator。文章的推导方法来源于Jim Weirich在ruby conference 2012上的一次分享(下载地址 优酷),Jim Weirich是Ruby社区的重要贡献者,开发了非常流行的 Rake —— 几乎被所有Ruby 开发者使用的开发工具。非常可惜的是Jim Weirich已经于今年2月19日离世。这篇推导非常棒,因为在推导前对重构方法进行了充分介绍,推导整个过程就变得非常平坦。于是我也顺便学习了下写了这篇文章。文章分三部分:1关于lambda演算和Y-Combinator的简单介绍,了解的人可以直接跳过;2重构的方法;3推导Y-Combinator过程。后两部分主要摘取自Jim Weirich的分享但是为了便于理解进行一些修改。


1 关于lambda演算

lambda演算

        本文不详细介绍lambda演算和Y-Combinator了,那可能需要相当的篇幅。不熟悉的同学可以自己通过网上材料学习(参考英文wiki 中文wiki Programming Languages and Lambda Calculi G9的blog)。按照wiki的定义:lambda演算(lambda calculus,λ-calculus)是一套用于研究函数定义、函数应用和递归的形式系统。邱奇运用lambda演算在1936年给出判定性问题的一个否定的答案。这种演算可以用来清晰地定义什么是一个可计算函数。lambda演算是一套形式系统,在计算机被建造出之前就已经存在很久了。lambda演算和图灵机是从两个不同方向对计算能力的抽象,前者发源于理论而后者来自硬件设计。比较之下lambda演算更为简单优美并接近数学,一句话能很好的概括它:lambda演算可以被称为最小的通用程序设计语言。

lambda演算与Y-Combinator的关系

        Y-Combinator是一个函数,他可以为匿名函数生成一个递归调用自己的函数。Y-Combinator使得lambda演算有能力表达递归逻辑。因为lambda演算和图灵机具有相同的计算能力,所以lambda演算当然可以表示任何常见的编程概念,比如用来表示自然数的邱奇数和当作谓词使用的邱奇布尔值(参考邱奇数 Church_encoding),或者是用单参数lambda表示多参数函数的Currying(参考 中文wiki 或者 谈谈Currying)。

了解Y-Combinator的意义

        我们了解Y-Combinator有用吗?负能量的答案是:几乎没有任何用处。在具有命名能力的编程语言里完全不需要这种制造递归的函数,且编程语言的底层实现都是基于图灵机模型的,与lambda演算和Y-Combinator没有半点关系。正能量的答案是:有点用处可以帮助你更好的了解函数式编程。

lambda与Javascript

        现代程序语言中的lambda表达式只是取名自lambda演算,已经与原始的lambda演算有很大差别了。而Javascript里没有任何语法专门代表lambda只写成这样的嵌套函数"function{ return function{...} }"


有趣的事

        SICP封面画了lambda,MIT的计算机科学系徽就是Y-Combinator,创业教父Paul Graham的孵化器叫Y-Combinator。

   

2 重构的方法

        下面5种方法都是Jim Weirich提到的,5种方法在后续的推导种都被使用了至少一次。第一种方法使用的最频繁。

1 Tennent Correspondence Principle

        把任何表达式包装在一个lambda里并立刻调用这个lambda表达式,不会对原表达式的值产生影响。这个方法在推导Y-Combinator的过程中被使用了很多次。

// Tennent Correspondence Principle
mul3 = function(n) { return n * 3 }
mul3 = function(n) { return function() { return n * 3 }() }

make_adder = function(x) {
  return function(n) { return n + x }
}
make_adder = function(x) {
  return function() { return function(n) { return n + x } }()
}


2 Introduce Binding

        可以为一个无参数的lambda表达式添加一个参数,当然这个参数是未被绑定到任何lambda的,然后就可以在调用的时候为这个新参数传入任何值,这样修改后的代码不会对原表达式产生影响。这个也容易理解,因为新参数是后添加的,lambda里根本没有被用到嘛,没有被用到的值当然不会对表达式产生任何影响了。

// Introduce Binding
make_adder = function(x) {
  return function() { return function(n) { return n + x } }()
}
make_adder = function(x) {
  return function(xyz) { return function(n) { return n + x } }(123456)
}


3 Rebind

        当几个存在嵌套关系的lambda存在时,可以在中间层没有参数的lambda加一个参数,然后把外部的参数通过新加的参数传递给内部lambda,Rebind从名字看就是重新绑定的意思,下面代码里的n原来是绑定到最外层的n的,Rebind修改之后就绑定到中间层的n了,外层的n已经影响不到它,他是通过中间层调用的时候传入的n来获取值的。

// Rebind
mul3 = function(n) { return function() { return n * 3 }() }
mul3 = function(n) { return function(n) { return n * 3 }(n) }


4 Function Wrap

        这和第一种方法Tennent Correspondence Principle有点相似但又不太一样,可以使用一个lambda来包装原有的lambda,只要调用一下被包装的lambda即可。

// Function Wrap
x = function(x) {
  return function(n) { return n + x }
}
x = function(x) {
  return function(z) { return function(n) { return n + x }(z) }
}


5 Inline Function

        内联是最好理解的,把原来有变量名的地方直接用变量的内容替换掉,也就是说把命名变量变成了匿名。

//5 Inline Function
compose = function(f, g) {
  return function(n) { return f(g(n)) }
}
mul3add1 = compose(mul3, add1)

compose = function(f, g) {
  return function(n) { return f(g(n)) }
}
mul3add1 = function(f, g) {
  return function(n) { return f(g(n)) }
} (mul3, add1)

3 推导Y-Combinator过程

        说明一下,每次的结果都是用这样的输出形式,我用nodejs跑挺方便,直接浏览器里也没问题。同时为了便于理解,固定用途的变量从开始到结束尽量不修改命名(Jim Weirich推导时经常重命名变量,容易把人搞晕)。

console.log(function(){
  //return xxx;
}())

        先看看如果推导出了Javascript版的Y-Combinator,它大概是什么样子,后续就可以方便的进行对照。


        第一个版本,这是一个很普通的递归求阶乘函数,没有任何特别之处。

console.log(function(){

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

}())


        我们把fact放到参数中去,这样函数体里就少了一个自由变量,把命名变量从自由变量改成绑定变量是一个很重要的重构手段。
// method ==> parameter
console.log(function(){

  function fact(g, n){
    return n == 1 ? 1 : n * g(g, n-1);
  }
  return fact(fact, 5)

}())


        进一步,我们把fact的返回值从数字改成函数,也就是说fact从“计算一个数的阶乘的函数”,变成了“返回一个可以计算阶乘的函数的函数”,这次重构后,n和fact被分割开了,这样逻辑更清晰,计算阶乘这个动作被分解成了两步:第一步是制造一个能计算阶乘的函数,这由fact(fact)来完成;第二步是让这个函数计算5的阶乘。调用方式发生了细微的变化,从fact(fact, 5)变成了fact(fact)(5)。
// parameter ==> lambda
console.log(function(){

  function fact(g) {
    return function(n) {
      return n == 1 ? 1 : n * g(g)(n-1);
    }
  }
  return fact(fact)(5)

}())


        休息一下,来一个简单的重构,为fact(fact)命个名就叫fx,后面再调用fx。
// naming fact(fact)
console.log(function(){

  function fact(g) {
    return function(n) {
      return n == 1 ? 1 : n * g(g)(n-1);
    }
  }
  fx = fact(fact)
  return fx(5)

}())


        这一步第一次使用了前面学习的重构5方法之Tennent Correspondence Principle,简称TCP了,把return fact(fact)包装起来调用一下。
// Tennent Correspondence Principle
console.log(function(){

  function fact(g) {
    return function(n) {
      return n == 1 ? 1 : n * g(g)(n-1);
    }
  }
  fx = function() { return fact(fact) }()
  return fx(5)

}())


        这一步把自由变量fact换成绑定变量g,之前用过了。
// free variable ==> parameter
console.log(function(){

  function fact(g) {
    return function(n) {
      return n == 1 ? 1 : n * g(g)(n-1);
    }
  }
  fx = function(g) { return g(g) }(fact)
  return fx(5)

}())


        重构5方法之Inline,Inline的结果是fact这个命名变量消失了,在需要fact的地方,用一个lambda表达式代替了。
// Inline
console.log(function(){

  fx = function(g) {
    return g(g)
  } (
    function(g) {
      return function(n) {
        return n == 0 ? 1 : n * g(g)(n-1)
      }
    }
  )

  return fx(5)
}())


        再来一次TCP,把最内层的lambda包裹一下并执行,执行的时候参数是空的。
// Tennent Correspondence Principle
console.log(function(){

  fx = function(g) {
    return g(g)
  } (
    function(g) {
      return function(n) {
        return function() {
          return n == 0 ? 1 : n * g(g)(n-1)
        }()
      }
    }
  )

  return fx(5)
}())


        来一次Rebind,把外层的n传递给内层lambda。
// Rebind
console.log(function(){

  fx = function(g) {
    return g(g)
  } (
    function(g) {
      return function(n) {
        return function(n) {
          return n == 0 ? 1 : n * g(g)(n-1)
        }(n)
      }
    }
  )

  return fx(5)
}())


        再来一次TCP,注意,这次被包裹的lambda是return function(n) { return n == 0 ? 1 : n*g(g)(n-1) },所以第13行写成}()(n)而不是}(n)()。
// Tennent Correspondence Principle
console.log(function(){

  fx = function(g) {
    return g(g)
  } (
    function(g) {
      return function(n) {
        return function() {
          return function(n) {
            return n == 0 ? 1 : n * g(g)(n-1)
          }
        }()(n)
      }
    }
  )

  return fx(5)
}())


        使用Introduce Binding为无参的函数添加一个参数recursion_in_mind,并将其代替g(g),当然了需要把g(g)传递进去。因为recursion_in_mind这个函数是有特殊含义的,所以我们使用了一个特殊的名字,这个变量将代表一个假想中的可以递归计算阶乘的函数。它的用途在后面的步骤中介绍。
// Introduce Binding 
console.log(function(){

  fx = function(g) {
    return g(g)
  } (
    function(g) {
      return function(n) {
        return function(recursion_in_mind) {
          return function(n) {
            return n == 0 ? 1 : n * recursion_in_mind(n-1)
          }
        }(g(g))(n)
      }
    }
  )

  return fx(5)
}())


        再来一次TCP,注意这次被包裹的是整个fx所代表的lambda。所以调用的括号在18行的末尾。
// Tennent Correspondence Principle
console.log(function(){

  fx = function() {
    return function(g) {
      return g(g)
    } (
      function(g) {
        return function(n) {
          return function(recursion_in_mind) {
            return function(n) {
              return n==0 ? 1 : n * recursion_in_mind(n-1)
            }
          }(g(g))(n)
        }
      }
    )
  }()

  return fx(5)
}())


        再来一次Introduce Binding,为上一步18行添加的那个调用传入一个参数,同时这个参数没有使用自由变量,而是直接使用了一个lambda,代码有点拖沓,仔细看就会明白。
// Introduce Binding
console.log(function(){

  fx = function(f) {
    return function(g) {
      return g(g)
    } (
      function(g) {
        return function(n) {
          return f(g(g))(n)
        }
      }
    )
  }(
    function(recursion_in_mind) {
      return function(n) {
        return n==0 ? 1 : n * recursion_in_mind(n-1)
      }
    }
  )

  return fx(5)
}())


        用一个变量temp来指代上一步直接传入的lambda,同时把fx改名为Y,是的这个Y就是Y-Combinator的一种形式了。同时为了代码便于阅读,多行的代码被整理到一行里。推导到这一步,代码结构突然变的和之前不太一样了,可以看到现在有两个命名函数存在,一个是temp,另一个是Y。计算过程是清晰的两个步骤,第一步是fact = Y(temp),这是以temp为原料,以Y为制作工艺,产出了一个fact函数,这一步是在制造函数。第二步使用5来调用这个刚制作好的函数。temp函数也非常特别,它接收一个递归函数recursion_in_mind,然后调用这个函数来计算n-1的阶乘。推导到这一步,可以认为Y-Combinator已经推导出来了,但是对照lambda演算里Y-Combinator的标准形式会发现,现在的Y的样子明显跟它不符,所以要进一步推导。
// naming function(recursion_in_mind) {...}
// Y is form one of Y-Combinator
console.log(function(){

  temp = function(recursion_in_mind) {
    return function(n) {
      return n == 0 ? 1 : n * recursion_in_mind(n-1)
    }
  }

  Y = function(f) {
    return function(g) { return g(g) } (
      function(g) { return function(n) { return f(g(g))(n) } }
    )
  }

  fact = Y(temp)

  return fact(5)
}())

        这一步推导稍微麻烦,因为之前的重构5种方法都不管用了,需要新引入了一个叫做”函数的不动点“的概念,函数f的不动点是一个值x使得f(x) = x。例如,0和1是函数f(x) = x^2 (计算平方的函数)的不动点,因为0^2 = 0而1^2 = 1。鉴于一阶函数(在简单值比如整数上的函数)的不动点是个一阶值,高阶函数f的不动点是另一个函数g使得f(g) = g。

        回到推导中来,现在需要一个有关不动点的结论来完成后续的推导,那就是temp(fact) = fact(可以先不考虑为什么需要这样一个中间结论,现在的任务是要证明这个结论的正确性,等到结论被使用时就可以知道为什么需要它了),这代表什么意思呢?套用刚刚说过的定义,高阶函数temp的不动点是另一个函数fact,使得temp(fact) = fact,只要这一步相等能达成。后续推导就没问题。

        回头看看19行的return fact(5)可以知道fact就是一个可以独立计算出5的阶乘的函数了。而temp是什么呢,temp是一个接收一个函数作为参数,并返回一个函数的函数。temp(fact)就是把fact传入temp喽,也就是把一个计算阶乘的函数传入进去了,而通过查看temp的函数实现发现,temp正好利用这个阶乘函数来计算n-1的阶乘了。最后再乘上n,返回的正好是一个计算n!的函数,而刚才我们根据return fact(5)已经得出过结论了fact()也是一个计算n!的函数,所以可以得出这个中间结论了,那就是temp(fact) = fact。中间结论成立!

        按照原计划我们应该赶紧拿着这个得来不易的 temp(fact) = fact 结论继续上路开始推导了,上路之前再插播一个有趣的现象,因为这个中间结论,fact是函数temp的不动点了,而函数fact又是由Y函数对原料temp进行加工而成,所以我们可以从另一个角度为Y-Combinator下定义,Y-Combinator可以计算出一个函数(也就是temp函数)的不动点函数(也就是fact)。

        继续上路,查看上面代码17行可以知道fact函数正是12行的这个g(g),因为return g(g) 就是赋值给fact了,而Y函数在17行被调用,传入的是temp,也就是Y函数里的f就是temp。拿出刚刚出炉的中间结论 temp(fact) = fact 一用,我们可以把第12行的return g(g) 替换为return f(g(g)),因为fact是temp的不动点,所以g(g)就是f的不动点,所以f(g(g)) == g(g)是成立的。所以这一步推导只修改了一行,也就是上面的12行。至此,这步重构算是完成了。

// fixed point refactor g(g) ==> f(g(g))
console.log(function(){
  
  temp = function(recursion_in_mind) {
    return function(n) {
      return n == 0 ? 1 : n * recursion_in_mind(n-1)
    }
  }

  Y = function(f) {
    return function(g) { return f(g(g)) } (
         function(g) { return function(n) { return f(g(g))(n) } }
    )
  }

  fact = Y(temp)
  // temp(fact) = fact

  return fact(5)

}())

        最后一步,需要为上面11行的return f(g(g))来一次5重构法之Function Wrap,传入的参数是n,通过这次修改,当前Javascript版本的Y函数与标准lambda演算里的Y完全相同了,非常好。再次对照我们在推导前给出的样子


// Function Wrap
// Y is form two of Y-Combinator
console.log(function(){

  temp = function(recursion_in_mind) {
    return function(n) {
      return n == 0 ? 1 : n * recursion_in_mind(n-1)
    }
  }

  // λg.(λx.g(x x))(λx.g(x x))
  Y = function(f) {
    return function(g) { return function(n) { return f(g(g))(n) } } (
         function(g) { return function(n) { return f(g(g))(n) } }
    )
  }

  fact = Y(temp)

  return fact(5)

}())


        按理说到此为止Y的推导过程已经结束了,但是我觉得这还不够完美,因为出现了一个命名变量temp,Y就是为实现匿名函数的递归调用而生的,我们这里放了temp是什么意思,男女授搜不亲啊,所以好人做到底,我们最后再使用一次Inline,直接把temp所代表的lambda丢给Y函数好了,这也就正好完美的演示了Y的真正用途:为匿名函数制造一个递归调用自己的函数(fact函数),全文完。

// Inline
console.log(function(){

  // λg.(λx.g(x x))(λx.g(x x))
  Y = function(f) {
    return function(g) { return function(n) { return f(g(g))(n) } } (
         function(g) { return function(n) { return f(g(g))(n) } }
    )
  }

  fact = Y(
    function(recursion_in_mind) {
      return function(n) {
        return n == 0 ? 1 : n * recursion_in_mind(n-1)
      }
    }
  )

  return fact(5)

}())
《Kotin 极简教程》第8章 函数式编程(FP)(1) 函数式编程思想是一个非常古老的思想。我们简述如下:我们就从1900 年 David Hilbert 的第 10 问题(能否通过有限步骤来判定不定方程是否存在有理整数解?) 开始说起吧。1920,Schönfinkel,组合子逻辑(combinatory logic)。直到 Curry Haskell 1927 在普林斯顿大学当讲师时重新发现了 Moses Schönfinkel 关于组合子逻辑的成果。 阅读详情

相关推荐

小龙虾 OpenClaw 安装全攻略:本地部署 AI 智能体一步到位

OpenClaw(昵称小龙虾)是一款 MIT 开源协议的本地优先 AI 智能体执行网关,支持多平台接入、本地部署,能实现自然语言驱动的设备自动化操作,区别于纯对话 AI,可直接操控系统执行实际任务,数据全程本地存储更安全。本文带来 2026 最新版 OpenClaw 安装教程,适配 Windows/macOS/Linux 全系统,新手也能一键搞定。

lujiawei00的专栏 1976

轻松理解Y结合子——Javascript推导

Y结合子(Y Combinator,也译作Y组合子),是在原生不支持递归的编程语言中利用lambda演算实现递归的一种方式,Y结合子在支撑递归的语言中没有什么实际的用途,更多是为了锻炼大家的程序逻辑思维,通过推演充分理解lambda和闭包。下面我们利用Javascript来一步步推导Y结合子。 原生递归 先一个经典的递归算法——斐波那契数列讨论,以下是Javascript原生支撑的递归

尘埃 2206

合规批量下载美国上市公司年报数据的一些经验和总结

本文总结了使用Python脚本批量下载和处理美国上市公司SEC报告的技术经验。通过CIK代码查询SEC EDGAR系统,生成特定日期和报告类型的URL,并使用Selenium和Requests库下载报告内容。流程包括数据获取、文件下载、Excel处理和多线程优化,确保高效处理几百条数据。关键技术挑战包括SEC访问限制、动态网页内容和数据完整性,解决方案包括设置合规的User-Agent、使用Selenium模拟浏览器行为以及错误日志记录。最佳实践包括模块化设计、多线程优化和严格遵守SEC合规性。该自动化流程

jyfool的博客 1641

javascript上通过YCombinator实现递归

如果js在语言层面不支持递归调用,我们可以自己来实现! 比如阶乘是这样来实现的 function _fact(self,n){ if(n==2)return 2; else return n*self(n-1); } var fact=Y(_fact); <==通过YCombinator实现递归 fact(5); <==等于120,正确递归! 来一起看看Y函数的实现吧......

gordonAt优快云的博客 1183

PLCopen运动控制避坑指南:单轴功能块常见报错排查(基于SM3_Basic函数库)

本文深入解析PLCopen运动控制中单轴功能块的常见报错问题,基于SM3_Basic函数库提供实用排查指南。从功能块逻辑错误与硬件报错的甄别技巧到高频报错场景的解决方案,帮助工程师快速定位并解决运动控制系统中的稳定性问题,提升工业自动化设备的运行效率。

weixin_33686714的博客 319

如何用abaqus软件做GUI插件

在Abaqus GUI程序开发中,可以使用两种方法来创建GUI图形界面。第一种方法是使用RSG对话框构造器创建。RSG对话框构造器是Abaqus/CAE内嵌的GUI插件开发辅助工具,可以在Abaqus/CAE主视图的"Plug-ins"菜单下的"Abaqus"子菜单中找到"RSG dialog Builder"。点击后,进入一个界面,用户可以在该界面中创建新的对话框,选择和编辑控件,查看对话框的效果,以及关联插件执行的内核文件等。

qq_25486359的博客 2763

Y combinator 的 javascript实现

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34114823的博客 361

利用树莓派制作智能音箱

利用树莓派制作智能音箱

qq_61803022的博客 1779

Lambda演算之Y-Combinator的推导

上一节中,我们讲到了如何使用λ演算来描述自然数,可以看出λ演算的表现力确实非常强大,然而遗憾的是,由于lambda演算中使用的都是匿名函数,所以它无法很直观地表述递归。 如果缺少了递归,λ演算的能力无疑会大打折扣。 所有基于λ演算的语言中,其实都是支持对过程进行命名的,那为什么这里我们还需要探讨匿名函数的递归呢? 为了保持纯洁性,我们希望仅仅通过λ演算...

weixin_34194087的博客 693

uniapp [全端兼容] - 实现全景图Vr 720°全景效果查看预览功能,3D全景图流畅不卡顿渲染+手势拖拽+悬浮工具按钮,uniAPP实现vr看720度全景效果示例代码(H5小程序APP全兼容)

uniapp显示720度全景图,720°全景图显示,在h5中展示720°全景图,浏览全景图,基于uniApp实现vr全景预览,加载全景图,uni-app全景预览插件,UNI-APP实现3D全景图,实现720°全景图展示,uniapp全景视频播放,uniapp项目实现vr720度全景图片预览,在网页上展示760全景图片和视频,全景图场景切换,UNIAPP全景VR图,uniapp加载720全景图_uniapp怎么加载vr图片,uniapp实现vr全景看房,uni-app实现全景效果,加载很慢卡怎么办,实现全景预

🏆 前端领域优质创作者 1万+

1、信息与物理世界:“It from Bit”还是“Bit from It”?

这篇博文探讨了物理学与信息理论之间的深刻联系,从惠勒提出的“It from Bit”概念出发,讨论了信息是否是物质世界的基础,或者物质是否是信息的来源。文章回顾了2013年举办的征文竞赛以及众多学者对这一问题的不同观点,涵盖了量子理论、热力学、计算机科学、黑洞物理以及时空本质等多个领域。同时,文章还分析了信息理论在哲学层面的含义,并展望了其在未来理论、实验和应用研究中的潜力与方向。

water的专栏 299

理解 Y Combinator:函数式编程中的递归技巧(中英双语)

The Y Combinator is an elegant solution to the problem of recursion in the absence of named functions.

阿正的梦工坊 1810

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

The Y Combinator

In this file we derive the Y combinator, one of the fundamental results of recursive procedure theory. You already know that in some cases it is not necessary to give a procedure a name. For example,

Lu_ming的专栏 1104

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

JavaScript 原型详解

全面分析下JavaScript的原型系统。 1 原型 2 继承属性的写入 3 添加还是覆盖 4 创建对象的方法 5 __proto__属性 6 内置对象的创建

voidccc的专栏 1159

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

C++没有Y Combinator?使用 C++ 实现 Y Combinator(中英双语)

Normally, lambda expressions in C++ cannot call themselves by name. The Y Combinator solves this by injecting recursion externally.

阿正的梦工坊 1577

Jim Weirich Discusses Rake, the Ruby Make Tool

Summary Jim Weirich, is the Chief Scientist for EdgeCase LLC and thecreator of rake, the popular make-like build tool written in Ruby. In this interview with InfoQ, Jim disccusses the birth of rake, D

showdian的专栏 377

用Python的函数式编程特性解释Y Combinator(仿JavaScript版)

函数式编程曾经火过一阵,但是一直没有在工业领域流行起来,其实函数式编程的思想早就融入工业语言,常见的JavaScript,Python,Ruby都支持函数式编程特性,甚至C++11标准也引入了匿名函数。过去曾看到过介绍【lambda算子】的一系列文章,当时有种大开眼界的感觉,原来计算能以这种方式表达,可惜没有进一步学习FP的零零总总。这一向又偶然瞥见一篇文章用JavaScript模拟Y组合子,心想着既然最近的工作都在用Python,干脆依葫芦画瓢用Py也来实现一遍吧。

白鼠的学习足迹 1687

Y Combinator的各种实现

1.JavaScript: Rossetta Code: function Y(f) { var g = f((function(h) { return function() { var g = f(h(h)); return g.apply(this, arguments); } })(funct

coolaaron的专栏 1132

[摘录]JS版本的Y组合子(Y combinator)

[code="javascript"] var Y = function(f){ return (function(g){ return g(g); })(function(h){ return function(x){ return f(h(h))(x); }; }); }; [/code] 有关于 Y 的最让人沮丧是,当你推导出它后,完全没法儿通过...

wmingjian的专栏 256

JS笔记 数组篇

理解length 和其他语言一样,js的数组索引是从0开始的,但是我在文档上看到一些我看到的有意思的操纵 写一个小于数组元素数量的值会缩短数组,写0会彻底清空数组 var arr = ['a','b','c']; console.log(arr.length); //输出3 对arr的length属性赋值 arr.length = 2; console.log(arr) // 可以发现输出的数组中只有a和b arr.length = 0; console.log(arr); //arr被清空

big_gg的博客 266

Y combinator的简单理解

Y combinator本身是一个无状态函数,当用于另一个无状态的函数时,将返回该函数的递归版本。比如定义Y:(为了说明方便,用λi代替lambda关键字) (defun y (f)     ((λ1 (x) (funcall x x))      (λ2 (y)          (funcall f (λ3 (&rest args)              (apply (

自由程序人(卍) 5509

Y 组合子详解 (The Y Combinator)

Y 组合子详解 (The Y Combinator) 如何实现一个匿名递归函数? Is there any way to make an anonymous function call itself? 不动点 f(g)=g 这个 g 就是 f 的不动点(Fixed Point)。 A fixed point of a function g , is a value that is mappe...

AI天才研究院 1万+

函数式编程Y Combinator解疑

偶然在一篇文章中看到Y Combinator,对于其对lambda函数的不动点的证明,从两条非常简洁的公理出发,巧妙地得出了匿名函数的递归表示,表示非常的感兴趣。但是,对于计算机理论没什么研究的人来说,虽然好像看懂了它是怎么证明出匿名函数的递归,但是如果不深入了解下Y Combinator的背景,就不知道它到底是用来干嘛的,对于个人知识体系来说,它就是一个孤立的点,没法与学到的计算机知识建立任何联

papamilk的博客 2039

Y-Combinator不同语言实现方案

递归和定点 纯λ演算的一大特色是可以通过使用一种自应用技巧来书写递归函数。 f(n) = if n = 0 then 1 else n*f(n-1) f = λn.if n = 0 then 1 else n*f(n-1) 把f移到等式的后面,得到函数G G = λf.λn.if n = 0 then 1 else n*f(n-1) 很显然有: f...

weixin_34001430的博客 443

JavaScript—数组推导式(Array comprehensions)

数组推导式(Array comprehensions)EDIT 在JavaScript 1.7 被介绍并计划在 ECMAScript 7, array comprehensions 被规范化并提供一个有用的快捷方式,用来实现如何在另一个数组的基础上构造一个新的数组。推导式可以经常被用在那些需要调用 map() 和 filter()函数的地方,或作为一种结合这两种方式。 下面的推导式

此博客已停用,博文会逐渐转移到新地址,http://blog.youkuaiyun.com/liupeifeng3514 6859
上一篇: tcpdump重要笔记
下一篇: Paxos历史回顾
voidccc
博客等级 码龄14年 149粉丝 28原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值