javascript - Lambda 演算——用 Mocking Bird 表达的函数看起来应该是递归的，但事实并非如此

Question

使用 JavaScript。让我们定义以下内容:

M = f => f(f)  // Mocking Bird
I = a => a  // Identity

假设现在我们写这个表达式

M( f => M( x => f) ) 

这似乎是递归的并且达到了最大调用堆栈。让我们扩展一次

( f => M( x => f) )  (f => M( x => f) )

我们看到我们可以继续前进

(f => (x => f)( x => f))(f => (x => f)( x => f))

(x => (f => (x => f)( x => f)))(x => (f => (x => f)( x => f)))

...等等。但在浏览器或节点中，这不是递归的。它是一个行为类似于 Identity

的函数

I('foobar')
// returns 'foobar'

M( f => M( x => f) )('foobar')
// returns 'foobar'

(x => (f => (x => f)( x => f)))(x => (f => (x => f)( x => f))) ('foobar')
// returns 'foobar'

请解释为什么该函数不会继续调用自身直到达到最大调用堆栈，而是返回一个行为类似于 Identity 的函数

同样的现象可以用Python来表达

M = lambda f: f(f)
I = lambda a: a

M( lambda f: M(lambda x: f)) ('foobar')
# returns 'foobar'

I('foobar')
# returns 'foobar'

<小时/>

更新

开始于

M( f => M( x => f) ) 

如果我们写出内部M( x => f)

M( f => ( x=> f )(x => f) )

我们看到，传入 (x => f)(x => f) 的内容并不重要，x 会被忽略并仅返回 f

M( f => f ) 

这很简单

f => f

Answer 1

 M(/*a*/ f => M( /*b*/ x => f) )('foobar')

a 通过 f = a 调用:

M(/*b*/ x => *a*) 

b 被调用，x 为 b，它返回 a :

/*a*/ f => M(/*b*/ x => f)

用“foobar”调用，所以f是“foobar”:

M(/*b*/ x => "foobar")

返回“foobar”

<小时/>

基本上它有效是因为:

M( x => f)

始终返回f，因此整个结果等于

M( f => f )

然后:

(f => f)(f => f)

这是

f => f