(define (let-combination exp)
(if (name-let? exp)
(sequence->exp
(list
(list
‘define
(cons (name-let-var exp) (name-let-binding-vars exp))
(name-let-body exp))
(cons (name-let-var exp)
(name-let-binding-values exp))))
(expand-let-clauses (let-clause exp)))) ;; normal let case

(define (expand-let-clauses clauses)
(newline)
(display clauses)
(let ((var-exp (car clauses))
(body (cdr clauses)))
(cons (make-lambda (map car var-exp) body) (map cadr var-exp))))

(define (let-clause exp)
(cdr exp))

(define (name-let? exp) (and (not (null? (cadr exp)))
(not (pair? (cadr exp)))))
(define (name-let-var exp)
(cadr exp))
(define (name-let-binding-vars exp)
(map car (caddr exp)))
(define (name-let-binding-values exp)
(map cadr (caddr exp)))
(define (name-let-body exp)
(cadddr exp))

I believe there is a small problem with your solution to problem 4. Particularly, (and) should return true and (or) should return false. However, simply calling (and) or (or) without any additional parameters will fail the tagged-list? test.

-Matthew

(define x 1)
(cond ((begin (set! x (+ x 1)) x) => display))

would be translated to

(if (begin (set! x (+ x 1)) x)
    (display (begin (set! x (+ x 1)) x))
    ...

which would result in x being set twice.

4.5: why is it evaluated twice, in your opinion? Doesn’t the assignment in let copy it?

4.6: fixed, thanks. For some reason it was already cddr when I looked at the original code – I probably found the bug and forgot to update the blog post.

It would return incorrect answer for following let:
(let ((x 1) (y 2)) (+ x y) (* x y))

I have a question: in exercise 4.8 and 4.9, it appears to me that named-let-name and while-iter procedures, are still visibles out of the scope of the named-let and the while, respectively.

Shouldn’t they be enclosed whithin some sort of scope cage (a lambda expression, maybe) in order to get hidden ?

Sorry for the English,

(1) they may cause side effects which the user would presumably expect to take place if and when the lambda is executed (applied to a set of arguments) — and, in general, it is hard to tell whether an expression has the potential to cause any side effects or not (it would be necessary to check any and all procedures which would be called if the expression was to be evaluated, possibly finding further procedures inside those first ones and so on…);

(2) if they reference free variables, then those variables can hold different values at the time of execution of the procedure created by the lambda form than those they held at the time of evaluation of the lambda form, in which case the new values should be used at the time of execution.

If it was actually possible to determine that a given lambda is `safe’ in the sense that one does not have to worry about (1) and (2) above, or any similar concerns, in its particular case — which may be the case with very simple procedures or if we know beforehand that the environment in which the procedure will be closed has no bindings for any `un-safe’ constructs (no value changes for variables) — then that would mean that we are dealing with a purely functional fragment of Lisp/Scheme and evaluation order is inconsequential anyway.

All best