Lambda 与此过程的行为相混淆

（上下文）

我定义了一个过程，它将另一个单参数过程对象应用于它的参数两次。以过程inc为例，它的参数加1，（double inc）将加2。因此（（double inc）5）返回7

（问题）

我期望（（（双倍（双倍））inc）5）返回13。由于double double将应用程序4次，因此最左边的double将导致应用单参数程序8次。直线生长

我错了。下面查看过程实际返回的内容

很明显，我遗漏了一些东西，我的理解也有缺陷

(define (double proc)
(lambda (y) (proc (proc y))))

(define (inc x) (+ x 1))

> ((double inc) 5)
7
> (((double double) inc) 5)
9
> (((double (double double)) inc) 5)
21
> (((double (double (double double))) inc) 5)
261    
> 

---

问题在于您对嵌套时

double

扩展到的内容的解释

只需将

y

替换为

inc

，一次替换一个级别，您就会看到发生了什么：

（double inc）

扩展使用

let

使事情更清楚：

(lambda (y)
        (let ([proc inc])
             ((proc (proc y))))

到目前为止，一切顺利

（（双倍）有限公司）

扩展：

     (lambda (y)
        (let ([proc (lambda (y_0) (double (double y_0)))])
             (proc (proc y))))

第一个应用程序按预期工作，但第二个应用程序不是将

inc

函数的应用程序加倍，而是将

double

函数本身加倍，因为您将

double

应用于

（double-double）

中的

double

函数

如果你再做一次，也就是说，

（（double（double-double）inc）

，你会看到它变得一团糟

您可能正在寻找的是将一个应用程序的

double

结果应用于另一个应用程序的结果

例如：

> ((double (double (double inc))) 5)
13
> ((double (double (double (double inc)))) 5)
21

---

这应该是相当容易扣除使用原因或替代模型

原因: 这类似于double，但两次是quadruple。当与函数一起应用时，它将应用该函数4次

(double (double double))

这是加倍的四分组。四分组的结果将是四分组，使其为4*4。当与函数一起应用时，它将应用16次

(double (double (double double)))

这是前一个的两倍。然后再次相同。16*16使其应用结果256次

因此，

（双倍）

是

2^2

，

（双倍）

是

（2^2）^2

，

（双倍）

是

（2^2）^2

或简称

2^8

这与lambda演算有关，其中幂的定义为

λb。λe.eb

或

（lambda（b）（lambda（e）（eb））

。现在

double

是

2

的教堂数字。你看到你在做

（（2^2）^2

替代 下面是简化后的表达式。我有时会在以后跳过步骤，因为这与多次发生的情况几乎相同

((double inc) 5)               ; ==>
((lambda (y) (inc (inc y))) 5) ; ==>
(inc (inc 5))                  ; ==> 7


(((double double) inc) 5)                   ; ==>
(((lambda (y) (double (double y))) inc) 5)  ; ==>
(((lambda (y) (double (double y))) inc) 5)  ; ==>
((double (double inc)) 5)                   ; ==>
((double (lambda (y) (inc (inc y)))) 5)     ; ==>
((lambda (y) ((lambda (y) (inc (inc y))) ((lambda (y) (inc (inc y))) y))) 5) ; ==>
((lambda (y) (inc (inc (inc (inc y))))) 5) ; ==>
(inc (inc (inc (inc 5)))) ; ==> 9


(((double (double double)) inc) 5)                                                                ; ==>
(((double (lambda (y) (double (double y)))) inc) 5)                                               ; ==>
(((lambda (y) ((lambda (y) (double (double y))) ((lambda (y) (double (double y))) y))) inc) 5)    ; ==>
(((lambda (y) (double (double (double (double y))))) inc) 5)                                      ; ==>
((double (double (double (lambda (y) (inc (inc y)))))) 5)                                         ; ==>
((double (double (lambda (y) (inc (inc (inc (inc y))))))) 5)                                      ; ==>
(inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc 5)))))))))))))))) ; ==> 21

我把最后一个留作练习

((double inc) 5)               ; ==>
((lambda (y) (inc (inc y))) 5) ; ==>
(inc (inc 5))                  ; ==> 7


(((double double) inc) 5)                   ; ==>
(((lambda (y) (double (double y))) inc) 5)  ; ==>
(((lambda (y) (double (double y))) inc) 5)  ; ==>
((double (double inc)) 5)                   ; ==>
((double (lambda (y) (inc (inc y)))) 5)     ; ==>
((lambda (y) ((lambda (y) (inc (inc y))) ((lambda (y) (inc (inc y))) y))) 5) ; ==>
((lambda (y) (inc (inc (inc (inc y))))) 5) ; ==>
(inc (inc (inc (inc 5)))) ; ==> 9


(((double (double double)) inc) 5)                                                                ; ==>
(((double (lambda (y) (double (double y)))) inc) 5)                                               ; ==>
(((lambda (y) ((lambda (y) (double (double y))) ((lambda (y) (double (double y))) y))) inc) 5)    ; ==>
(((lambda (y) (double (double (double (double y))))) inc) 5)                                      ; ==>
((double (double (double (lambda (y) (inc (inc y)))))) 5)                                         ; ==>
((double (double (lambda (y) (inc (inc (inc (inc y))))))) 5)                                      ; ==>
(inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc (inc 5)))))))))))))))) ; ==> 21