June 25th Thursday (六月 二十五日 木曜日)

Local Binding: let, let*, letrec, ...

(let ([id val-expr] ...) body ...+)
(let proc-id ([id init-expr] ...) body ...+)


The first form evaluates the val-exprs left-to-right, creates a new location for each id, and places the values into the locations. It then evaluates the bodys, in which the ids are bound. The last body expression is in tail position with respect to the let form. The ids must be distinct according to bound-identifier=?.

Examples:

  > (let ([x 5]) x)
  5

  > (let ([x 5])
      (let ([x 2]
            [y x])
        (list y x)))

  (5 2)



The second form evaluates the init-exprs; the resulting values become arguments in an application of a procedure (lambda (id ...) body ...+), where proc-id is bound within the bodys to the procedure itself.

Examples:

  > (let fac ([n 10])
      (if (zero? n)
          1
          (* n (fac (sub1 n)))))

  3628800


(let* ([id val-expr] ...) body ...+)

Similar to let, but evaluates the val-exprs one by one, creating a location for each id as soon as the value is available. The ids are bound in the remaining val-exprs as well as the bodys, and the ids need not be distinct; later bindings shadow earlier bindings.

Examples:

  > (let* ([x 1]
           [y (+ x 1)])
      (list y x))

  (2 1)


(letrec ([id val-expr] ...) body ...+)

Similar to let, but the locations for all ids are created first and filled with #<undefined>, and all ids are bound in all val-exprs as well as the bodys. The ids must be distinct according to bound-identifier=?.

Examples:

  > (letrec ([is-even? (lambda (n)
                         (or (zero? n)
                             (is-odd? (sub1 n))))]
             [is-odd? (lambda (n)
                        (and (not (zero? n))
                             (is-even? (sub1 n))))])
      (is-odd? 11))

  #t