柯里化函数在Scheme中的实现

Question

当我执行以下操作时会发生什么？

(define ((func x) y)
    (if (zero? y)
        ((func x) 1)
        12))

我知道我可以这样做：

(define curried (func 5))

现在我可以使用柯里化。 我很好奇的是函数的定义。 该行是否

((func x) 1)

创建一个以 x 作为参数的新 lambda，然后在 1 上调用它？ 或者它比这更聪明，它只是重复使用现有的。 （例如，如果我执行 (curried 0)，则 ((func x) 1) 行将相当于 (curried 1) - PLAI计划可以做到这一点吗？）

Answer 1

在Scheme标准中指定了

(define (f x) 42) is short for (define f (lambda (x) 42)) .

自然（非标准）泛化意味着：

(define ((f x) y) (list x y)) is short for (define (f x) (lambda (y) (list x y)))
                which is short for (define f (lambda (x) (lambda (y) (list x y))))

中的示例

为了测试它，让我们尝试DrScheme欢迎使用DrScheme版本4.1.3.3-svn5dec2008 [3m] 。
语言：模块； 内存限制：384 MB。

（定义（（fx）y）（列表xy））
(f 1)

((f 1) 2)
(1 2)

如果我们命名临时值，可能会更容易看出会发生什么：

（定义 h (f 1)）
（小时2）
(1 2)
（小时3）
(1 3)

由于“PLAIScheme”是在DrScheme中实现的，我相信它继承了这个快捷符号。

Answer 2

我已经很久没有使用计划了，但你可能会发现这篇文章< /a> 有帮助。
它描述了两个宏 c-lambda 和 c-define 的实现，这两个宏允许 lambda 表达式的隐式柯里化定义。

Answer 3

soegaard的答案是正确的——这是传统的展开。 不过，drscheme 很聪明！

我发现以下代码在运行时间上是等效的：

原始来源：

(define ((substitute lv value) e)
  (cond [(LogicVar? e)
     (type-case LogicVar e
       [lv-any (id) (if (symbol=? id (lv-any-id lv))
                value
                e)]
       [lv-cons (f r) 
            (lv-cons ((substitute lv value) f)
                 ((substitute lv value) r))])]
    [(cons? e)
     (cons ((substitute lv value) (car e))
           ((substitute lv value) (cdr e)))]
    [else e]))

尝试优化：

(define (substitute lv value)
  (local ([define inner
        (lambda (e)
          (cond [(LogicVar? e)
             (type-case LogicVar e
               [lv-any (id) (if (symbol=? id (lv-any-id lv))
                    value
                    e)]
               [lv-cons (f r) 
                (lv-cons (inner f)
                     (inner r))])]
            [(cons? e)
             (cons (inner (car e))
               (inner (cdr e)))]
            [else e]))])
    inner))

大量使用此函数（多次，而不是一次）的代码对于两个版本都以 1800 毫秒运行。 更有趣的是，这个版本（我对所发生情况的可视化）：

(define (substitute lv value)
  (local ([define inner
        (lambda (e)
          (cond [(LogicVar? e)
             (type-case LogicVar e
               [lv-any (id) (if (symbol=? id (lv-any-id lv))
                    value
                    e)]
               [lv-cons (f r) 
                (lv-cons ((substitute lv value) f)
                     ((substitute lv value) r))])]
            [(cons? e)
             (cons ((substitute lv value) (car e))
               ((substitute lv value) (cdr e)))]
            [else e]))])
    inner))

运行时间为 2000 毫秒。 因此，如果对替换内替换的调用每次都创建一个 lambda，那么速度肯定会变慢，但快捷表示法似乎并非如此。