[R7RS base] Creates a local scope where var … are bound to the value of expr …, then evaluates body …. vars must be symbols, and there shouldn’t be a duplication. The value(s) of the last expression of body … becomes the value(s) of this form.
The four forms differ in terms of the scope and the order
exprs are evaluated.
Let evaluates exprs before (outside of)
The order of evaluation of exprs is undefined, and the compiler
may reorder those exprs freely for optimization.
Let* evaluates exprs, in the order they appears,
and each expr is evaluated in the scope
where vars before it are bound.
Letrec evaluates exprs, in an undefined order,
in the environment where vars are already bound
(to an undefined value, initially).
letrec is necessary to define mutually recursive local procedures.
letrec* uses the same scope rule as
and it evaluates expr in the order of appearance.
(define x 'top-x) (let ((x 3) (y x)) (cons x y)) ⇒ (3 . top-x) (let* ((x 3) (y x)) (cons x y)) ⇒ (3 . 3) (let ((cons (lambda (a b) (+ a b))) (list (lambda (a b) (cons a (cons b 0))))) (list 1 2)) ⇒ (1 2 . 0) (letrec ((cons (lambda (a b) (+ a b))) (list (lambda (a b) (cons a (cons b 0))))) (list 1 2)) ⇒ 3
You need to use
letrec* if evaluation of one expr requires
the value of var that appears before the expr. In the following
example, calculating the value of a and b requires the value
of cube, so you need
letrec*. (Note the difference from
the above example, where calculating the value of list
doesn’t need to take the value of cons bound in the same
The value of cons isn’t required until list is actually applied.)
(letrec* ((cube (lambda (x) (* x x x))) (a (+ (cube 1) (cube 12))) (b (+ (cube 9) (cube 10)))) (= a b)) ⇒ #t
This example happens to work with
letrec in the current Gauche, but
it is not guaranteed to keep working in future. You just should not
rely on evaluation order when you use
In retrospect, it would be a lot simpler if we only have
letrec preceded for long time in Scheme history
and it’s hard to remove that. Besides,
letrec does have more
opportunities to optimize than
A convenient macro when you have only one variable. Expanded as follows.
(let ((var expr)) body …)
This macro simplifies the following idiom:
(let1 var expr (if var then else))
This macro simplifies the following idiom:
(let1 var expr body … var)
In short, it works like
let*, but returns
whenever the expression in bindings evaluates to
Each binding should be one of the following form:
The expression is evaluated; if it yields true value, the value
is bound to variable, then proceed to the next binding. If
no more bindings, evaluates body …. If expression
#f, stops evaluation and returns
In this form, variable is omitted. Expression is evaluated and the result is used just to determine whether we continue or stop further evaluation.
In this form, bound-variable should be an identifier denoting
a bound variable. If its value is not
#f, we continue
the evaluation of the clauses.
Let’s see some examples. The following code searches key from an assoc-list alist and returns its value if found.
(and-let* ((entry (assoc key alist))) (cdr entry))
If arg is a string representation of an exact integer, returns its value; otherwise, returns 0:
(or (and-let* ((num (string->number arg)) ( (exact? num) ) ( (integer? num) )) num) 0)
The following is a hypothetical code that searches a certain server port number from a few possibilities (environment variable, configuration file, ...)
(or (and-let* ((val (sys-getenv "SERVER_PORT"))) (string->number val)) (and-let* ((portfile (expand-path "~/.server_port")) ( (file-exists? portfile) ) (val (call-with-input-string portfile port->string))) (string->number val)) 8080) ; default
Evaluates test, and if it isn’t
#f, binds var to it
and evaluates exp1 exp2 …. Returns the result(s) of
the last expression. If test evaluates to
This can be easily written by
if-let1 as follows.
However, we’ve written this idiom so many times that it deserves
(and-let1 var test exp1 exp2 …) ≡ (and-let* ([var test]) exp1 exp2 …) ≡ (if-let1 var test (begin exp1 exp2 …) #f)
A macro that emulates dynamic scoped variables.
Vars must be variables bound in the scope including
fluid-let form. Vals are expressions.
Fluid-let first evaluates vals, then
evaluates body …, with binding
vars to the corresponding values during the dynamic
scope of body ….
Note that, in multithreaded environment, the change of the value of vars are visible from all the threads. This form is provided mainly for the porting convenience. Use parameter objects instead (see Parameters) for thread-local dynamic state.
(define x 0) (define (print-x) (print x)) (fluid-let ((x 1)) (print-x)) ⇒ ;; prints 1
[SRFI-8] This is the way to receive multiple values. Formals can be a (maybe-improper) list of symbols. Expression is evaluated, and the returned value(s) are bound to formals like the binding of lambda formals, then body … are evaluated.
(define (divrem n m) (values (quotient n m) (remainder n m))) (receive (q r) (divrem 13 4) (list q r)) ⇒ (3 1) (receive all (divrem 13 4) all) ⇒ (3 1) (receive (q . rest) (divrem 13 4) (list q rest)) ⇒ (3 (1))
call-with-values in Multiple values
which is the procedural equivalent of
You can use
define-values (see Definitions) to
bind multiple values to variables simultaneously.
let-like syntax with multiple values.
vars are a list of variables. expr is evaluated, and
its first return value is bound to the first variable in vars,
its second return value to the second variable, and so on, then
body is evaluated.
The scope of exprs are the outside of
(let-values (((a b) (values 1 2)) ((c d) (values 3 4))) (list a b c d)) ⇒ (1 2 3 4) (let ((a 1) (b 2) (c 3) (d 4)) (let-values (((a b) (values c d)) ((c d) (values a b))) (list a b c d))) ⇒ (3 4 1 2)
vars can be a dotted list or a single symbol, like the lambda parameters.
(let-values (((x . y) (values 1 2 3 4))) y) ⇒ (2 3 4) (let-values ((x (values 1 2 3 4))) x) ⇒ (1 2 3 4)
If the number of values returned by expr doesn’t match what vars expects, an error is signaled.
let-values, but each expr’s scope includes
the preceding vars.
(let ((a 1) (b 2) (c 3) (d 4)) (let*-values (((a b) (values c d)) ((c d) (values a b))) (list a b c d))) ⇒ (3 4 3 4)
[SRFI-31] A macro to evaluate an expression with recursive reference.
In the first form, evaluates expr while var in expr is bound to the result of expr. The second form is equivalent to the followings.
(rec name (lambda vars expr …))
;; constant infinite stream (rec s (cons 1 (delay s))) ;; factorial function (rec (f n) (if (zero? n) 1 (* n (f (- n 1)))))