在Scheme中使用let

发布于 2024-07-23 21:36:41 字数 653 浏览 3 评论 0原文

我想编写一个程序来求Scheme中二次方程的根。 我使用 LET 来进行某些绑定。

(define roots-with-let
  (λ (a b c)
    (let ((4ac (* 4 a c))
          (2a (* 2 a))
          (discriminant (sqrt ( - (* b b) (4ac)))))
      (cons ( / ( + (- b) discriminant) 2a)
            ( / ( - (- b) discriminant) 2a)))))

我用 4ac 定义了判别式,因为我不需要 (* 4 ac)。 即使我已经定义了 (4ac (* 4 ac)),它还是给了我这个错误:

扩展:模块中的未绑定标识符:4ac

我的问题是 let 是如何评估的(什么顺序)? 如果我想在我的 let 中使用 4ac,我应该再写一个内部 let 吗? 有一个更好的方法吗?

I want to write a program to find the roots of the quadratic equation in Scheme. I used LET for certain bindings.

(define roots-with-let
  (λ (a b c)
    (let ((4ac (* 4 a c))
          (2a (* 2 a))
          (discriminant (sqrt ( - (* b b) (4ac)))))
      (cons ( / ( + (- b) discriminant) 2a)
            ( / ( - (- b) discriminant) 2a)))))

I defined the discriminant with 4ac since I did not want (* 4 a c). Even though I have defined (4ac (* 4 a c)), it is giving me this error:

expand: unbound identifier in module in: 4ac.

My question is how is let evaluated (what order)? And if i want 4ac in my let should i write another inner let? Is there a better way to do this?

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

扫码二维码加入Web技术交流群

发布评论

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

评论(4

温柔一刀 2024-07-30 21:36:41

使用 let* 而不是 let

letlet* 之间的区别如下:

let* 从左到右绑定变量。 较早的绑定可以在更右侧(或向下)的新绑定中使用。

另一方面,let 可以被认为是简单 lambda 抽象的语法糖(或宏):

(let ((a exp1)
      (b exp2))
   exp)

相当于

((lambda (a b)
    exp)
 exp1 exp2)

Use let* instead of let.

The difference between let and let* is the following:

let* binds variables from left to right. Earlier bindings can be used in new binding further to the right (or down).

let on the other hand can be thought of as syntactic sugar (or macro) for simple lambda abstraction:

(let ((a exp1)
      (b exp2))
   exp)

is equivalent to

((lambda (a b)
    exp)
 exp1 exp2)
别理我 2024-07-30 21:36:41
  • 4ac是一个数值变量,所以(4ac)没有意义。

  • LET 绑定所有变量,但变量不能用于值的计算。

这是行不通的:

(let ((a 1) (b 1) (c (* a b)))
   c)

使用:

(let ((a 1) (b 1))
  (let ((c (* a b)))
    c))

上面用第一个 LET 介绍了 A 和 B。 在第二个 LET 中,A 和 B 现在都可以用来计算 C。

或者:

(let* ((a 1) (b 1) (c (* a b)))
   c)
  • 4ac is a variable with a numeric value, so (4ac) is not meaningful.

  • LET binds all variables, but the variables can't be used in the computations for the values.

This does not work:

(let ((a 1) (b 1) (c (* a b)))
   c)

Use:

(let ((a 1) (b 1))
  (let ((c (* a b)))
    c))

Above introduces A and B with the first LET. In the second LET both A and B now can be used to compute C.

Or:

(let* ((a 1) (b 1) (c (* a b)))
   c)
∞觅青森が 2024-07-30 21:36:41

您需要一个特殊的let-此处构造 (let*),因为let 定义中的变量相互引用。

这更像是一个定义范围的问题,而不是评估表达式的问题(在通常的 let 定义中,评估的顺序并不重要,因为这些值可能不会互相使用)

You'll need a special let-construct (let*) here since the variables inside the let-definition refer to each other.

It's rather a problem of defining a scope than of evaluating an expression (In usual let-definitions, the order of evaluation doesn't matter since the values may not use each other)

鲜肉鲜肉永远不皱 2024-07-30 21:36:41

当您使用 let 时,绑定在任何主体中都不可见。 请改用 let* 并参阅 RNRS 文档了解详细信息。

When you use let, the bindings are not visible in any of the bodies. Use let* instead and see the RNRS docs for details.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文