在方案中使用 lambda 而不是 let

发布于 2024-09-03 02:31:16 字数 204 浏览 3 评论 0原文

在 SICP 1.2.1 中，有一个生成有理数的函数，如下所示：

(define (make-rat n d)
  (let ((g (gcd n d)))
    (cons (/ n g) (/ d g))))

我只是好奇如何使用 lambda 而不是 let 来实现相同的功能，而无需调用 GCD 两次。我自己也想不通。

原文

In SICP 1.2.1 there is a function that makes a rational number, as follow:

(define (make-rat n d)
  (let ((g (gcd n d)))
    (cons (/ n g) (/ d g))))

I'm just curious how you can implement the same thing using lambda instead of let, without calling GCD twice. I couldn't figure it out myself.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

烟雨凡馨 2024-09-10 02:31:16

查看 SICP 第 1.3.2 节，

(let ((<var1> <exp1>)
      (<var2> <exp2>)
      ...
      (<varn> <expn>))
   <body>)

相当于

((lambda (<var1> ...<varn>)
    <body>)
 <exp1>
 ...
 <expn>)

所以你的程序，

(define (make-rat n d)
  (let ((g (gcd n d)))
    (cons (/ n g) (/ d g))))

应该相当于

(define (make-rat n d)
  ((lambda (g)
    (cons (/ n g) (/ d g)))
  (gcd n d)))

Looking at SICP section 1.3.2,

(let ((<var1> <exp1>)
      (<var2> <exp2>)
      ...
      (<varn> <expn>))
   <body>)

is equivalent to

((lambda (<var1> ...<varn>)
    <body>)
 <exp1>
 ...
 <expn>)

So your procedure,

(define (make-rat n d)
  (let ((g (gcd n d)))
    (cons (/ n g) (/ d g))))

should be equivalent to

(define (make-rat n d)
  ((lambda (g)
    (cons (/ n g) (/ d g)))
  (gcd n d)))

回复收藏 0 原文

记忆之渊 2024-09-10 02:31:16

这两件事是相同的：

((lambda (p1 p2...) body) v1 v2...)

和

(let ((p1 v1) (p2 v2)...) body)

These two things are same:

((lambda (p1 p2...) body) v1 v2...)

and

(let ((p1 v1) (p2 v2)...) body)

回复收藏 0 原文

时光沙漏 2024-09-10 02:31:16

(define-syntax let-as-lambda
  (syntax-rules ()
        ((_ (x value) body)
            (let ((x value))
              body))))

(printf "~s~n" (let-as-lambda (x 1) (+ x 1)))

(define-syntax let-as-lambda
  (syntax-rules ()
        ((_ (x value) body)
            (let ((x value))
              body))))

(printf "~s~n" (let-as-lambda (x 1) (+ x 1)))

回复收藏 0 原文

以可爱出名 2024-09-10 02:31:16

让我们检查两个简单的案例，以便我们能够理解如何重写任何使用 let 和 lambda 的函数：

在第一个案例中，我们有一个 let。这个函数非常简单，它通过添加 10 来返回给定的输入：
<前><代码>（定义（测试x）
（让（（b 10））
(+xb)))

现在让我们使用 lambda 将其转换为表达式：

    (define (test-lambda x)
      ((lambda (b)
         (+ x b))
       10))

正如您所看到的，test-lambda 返回一个 lambda 计算，该计算使用值 10 进行计算。测试这个我们可以说：

    (test-lambda 10)

这将返回 20。

现在，对于多个 let，我们将 lambda 表达式嵌套在 lambda 表达式中。

我们的 let 案例有两个 let 语句：

    (define (lets x)
      (let ((a 10)
            (b 20))
        (+ x a b)))

我们可以像这样用 lambda 来编写它：

    (define (lets-lambda x)
      ((lambda (a)
         ((lambda (b)
            (+ x a b))
          20))
       10))

所以现在我们正在计算每个 lambda 表达式，并给它们一个值，最里面的 lambda 表达式负责使用变量名称计算我们想要计算的内容每个 lambda 表达式都已分配。

希望这很清楚，并可以帮助其他人看得更清楚！

Let us examine two simple cases so that we can understand how we can rewrite any function that uses let with lambda:

In our first case we have one let. This function is very simple, it returns a given input by adding 10 to it:
```
(define (test x)
  (let ((b 10))
    (+ x b)))
```

Now let us turn this into an expression using lambda:

    (define (test-lambda x)
      ((lambda (b)
         (+ x b))
       10))

As you can see, test-lambda returns a lambda evaluation that is evaluated with the value 10. Testing this we can say:

    (test-lambda 10)

which will return 20.

Now for more than one let, we nest lambda-expressions within lambda-expressions.

Our let case we have two let statements:

    (define (lets x)
      (let ((a 10)
            (b 20))
        (+ x a b)))

We can write this with lambda like so:

    (define (lets-lambda x)
      ((lambda (a)
         ((lambda (b)
            (+ x a b))
          20))
       10))

So now we are evaluating each of the lambda expressions giving them a value, and the innermost lambda expression takes care of what we want to compute using the variable names that each lambda expression has been assigned.

Hope this was clear and might help others see more clearly!

回复收藏 0 原文

~没有更多了~