Смущает разница между let и let * в схеме

Question

Может ли кто-нибудь объяснить разницу просто? Я не думаю, что понимаю концепцию из учебников/сайтов, с которыми я консультировался.

Answer 1

Если вы используете let, вы не можете ссылаться на привязки, ранее определенные в том же выражении let. Например, это не будет работать:

(let ((x 10) 
     (y (+ x 6))) ; error! unbound identifier in module in: x 
    y) 

Но если вы используете let*, то можно сослаться на предыдущие привязки в том же let* выражение:

(let* ((x 10) 
     (y (+ x 6))) ; works fine 
    y) 
=> 16 

Это все here в документации.

Answer 2

Let параллельно, ^{(вид; смотри ниже)}let* является последовательным. Let переводится как

((lambda(a b c) ... body ...) 
    a-value 
    b-value 
    c-value) 

но let*, как

((lambda(a) 
    ((lambda(b) 
     ((lambda(c) ... body ...) 
     c-value)) 
    b-value)) 
    a-value) 

и, таким образом, создавая вложенные блоки области действия, где b-value выражение может относиться к a и c-value выражение может относиться как к b и a. a-value относится к внешнему виду. Это также эквивалентно

(let ((a a-value)) 
    (let ((b b-value)) 
    (let ((c c-value)) 
     ... body ...))) 

Существует также letrec, что позволяет рекурсивные привязки, где все переменные и выражения принадлежат к одному общему объему и могут относиться друг к другу (с некоторыми оговорками, относящихся к инициализации). Это эквивалентно либо

(let ((a *undefined*) (b *undefined*) (c *undefined*)) 
    (set! a a-value) 
    (set! b b-value) 
    (set! c c-value) 
    ... body ...) 

(in Racket, также доступен как letrec* на схеме, так как R6RS), или

(let ((a *undefined*) (b *undefined*) (c *undefined*)) 
    (let ((_x_ a-value) (_y_ b-value) (_z_ c-value)) ; unique identifiers 
    (set! a _x_) 
    (set! b _y_) 
    (set! c _z_) 
    ... body ...)) 

(in Scheme).

обновление: let фактически не оценивает свои значения-выражения параллельно, это просто, что все они оцениваются в той же начальной среде, где появляется форма let. Это также видно из перевода на основанное lambda: сначала значение выражения вычисляются каждый в той же среде, внешней, и полученные значения собраны, и только затем новые места создаются для каждого идентификатора и значения ставятся каждый в своем местоположении. Мы все еще можем видеть последовательность, если одно из значений-выражений мутирует хранилище (т. Е. Данные, такие как список или структура), к которым обращается последующий.