什么时候使用define，什么时候使用let in racket

Question

我正在学习球拍，我有一个关于何时使用define 以及何时使用let 的问题。

我有这个功能：

(define my-function
  (lambda (param1 param2 list1)
    (/
     (count
      (lambda (x)

        (define a (param1 (remove x list1)))

        (define b (drop-right x 1))

        (define c (param2 a x-sin-clase))

        (eq? (last x) (last c)))
      (cdr list1))
     (length (cdr list1))))) 

不知道上面的函数是做什么的。在函数体内使用define是否正确？

我在某处读到define 用于声明全局变量，let 用于声明局部变量。我查看了球拍的文档，但没有说任何区别。

Answer 1

一个区别：内部定义在相互递归的范围内，但 let 绑定不在。

这意味着比let：

(let ([x expr-1] [y expr-2])
  body)

expr-1 和 expr-2 不能引用 x 或 y。更具体地说，

(let ([x (stream-cons 1 y)] [y (stream-cons 2 x)])
  x)
;error=> y: unbound identifier in: y

如果x 或y 在let 之外定义，则expr-1 和expr-2 将引用外部 定义，而不是由let 引入的定义.具体来说：

(define x 'outer)
(let ([x 'inner] [y x]) ; <- this x refers to outer,
  y)                    ;    so y is 'outer
;=> 'outer

但是，内部定义具有相互递归的作用域，这意味着在

(block
  (define x expr-1)
  (define y expr-2)
  body)

expr-1 和expr-2 可以指x 或y。具体来说，

(require racket/block)

(block
  (define x (stream-cons 1 y))
  (define y (stream-cons 2 x))
  (stream->list (stream-take x 5)))
;=> (list 1 2 1 2 1)

define 的作用域

....A....
(define (f)
  (define t1 ..B..)
  (define x ..C..)
  (define t2 ..D..)
  ....E....)
....F....

x 在f 的正文中随处可见，但在此之外不可见。这意味着它在 B、C、D 和 E 中可见，但在 A 或 F 中不可见。

let 的作用域

....A....
(define (f)
  (let ([t1 ..B..]
        [x ..C..]
        [t2 ..D..])
    ....E....))
....F....

这里x 在let 的主体中随处可见，但在其之外不可见。这意味着它在 E 中可见，但在 A、B、C、D 或 F 中不可见。

let* 的作用域

....A....
(define (f)
  (let* ([t1 ..B..]
         [x ..C..]
         [t2 ..D..])
    ....E....))
....F....

这里x 在let* 的主体中和在它之后 的let* 绑定中随处可见，但不在此之外。这意味着它在 D 和 E 中可见，但在 A、B、C 或 F 中不可见。

letrec 的作用域

....A....
(define (f)
  (letrec ([t1 ..B..]
           [x ..C..]
           [t2 ..D..])
    ....E....))
....F....

x 在letrec 的主体和letrec 的绑定中随处可见，但在此之外不可见。这意味着它在 B、C、D 和 E 中可见，但在 A 或 F 中不可见。

letrec 中变量的作用域和本地变量define 的作用域非常相似，因为letrec 和define 都使用相互递归的作用域。

Answer 2

我终于明白我读到的define的变量是“全局变量”。

在《方案编程语言第四版》一书中，R. Kent Dybvig，2.6. Top Level Definitions 部分说：

let 和 lambda 表达式绑定的变量不可见 在这些表达式的主体之外。