Something unclear in the Common Lisp standard
There is what I think is a confusion as to bound declarations in the Common Lisp standard. I may be wrong about this, but I think I’m correct.
Bound and free declarations
Declarations in Common Lisp can be either bound or free:
- a bound declaration appears at the head of a binding form and applies to a variable or function binding made by that form;
- a free declaration is any declaration which is not bound.
There are declarations which do not apply to bindings, such as
optimize: these are always free.
Examples of bound and free declarations
In the form
(let ((x 1)) (declare (type integer x)) ...)
the declaration is bound and applies to the binding of
x. In the form
(let ((/x/ 1)) (declare (special /x/) (optimize (speed 3))) ...)
special declaration is bound and applies to the binding of
/x/, while the
optimize declaration is free.
In the form
(let ((x 1)) (locally (declare (type integer x) (optimize speed)) ...) ...)
Both declarations are free and apply only to the body of the
Declarations which may not be ignored
Most declarations may be ignored by the implementation: this is the case for all type declarations, for instance. Two may not be:
notinlineforbids inline compilation of the functions it names;
specialrequires dynamic bindings to be made when it is bound, and requires references to be to dynamic, not lexical bindigns when it is free.
I’m going to exploit the non-ignorability of
special declarations to show a case where the confusion arises.
let* bind sequentially:
(let* ((x 1) (y x)) ...)
x and then binds
y to the value of
x. Now, I am not sure of the standard ever says this, but all implementations I have tried take this to mean that the same name can be bound several times by
(let* ((x 1) (x x)) ...)
is legal, if stylistically awful. That’s because the obvious transformation of
let* into nested
lets turns this into:
(let ((x 1)) (let ((x x)) ...))
which is clearly fine.
So now we come to the problem: what should this mean?
(let* ((x 1) (x x)) (declare (type fixnum x)) ...
Which binding of
x does the declaration apply to? The standard does not say. In this case it might not matter, because this declaration can be ignored, but here is a case where it does matter:
(let (c) (let* ((/x/ 1) (/x/ (progn (setf c (lambda () /x/)) 2))) (declare (special /x/)) (values c (lambda () /x/))))
This expression returns two values, both of which are functions:
- if the first
/x/is special then calling the first function will result in an error;
- if the second
/x/is special then calling the second function will result in an error.
So using this trick you can know whether the first binding, second binding, or both bindings are affected by the
And, again, the standard does not say which binding is affected, or whether both should be. And implementations differ. Given the following file
(in-package :cl-user) (defun call-ok-p (f) (multiple-value-bind (v c) (ignore-errors (funcall f) t) (declare (ignore c)) v)) (defun ts () (multiple-value-bind (one two) (let (c) (let* ((/x/ 1) (/x/ (progn (setf c (lambda () /x/)) 2))) (declare (special /x/)) (values c (lambda () /x/)))) (values (call-ok-p one) (call-ok-p two)))) (multiple-value-bind (first-lexical second-lexical) (ts) (format t "~&first ~:[special~;lexical~]~%~ second ~:[special~;lexical~]~%" first-lexical second-lexical))
first lexical second special
first special second special
first special second special
What should the answer be?
I think that the interpretation taken by CCL and LispWorks is better: in forms like this declarations should apply to all the bindings made by the form. An alternative answer is that the declarations should apply to the visible bindings at the point of the declaration, which is the approach taken by SBCL.
It’s tempting to say that the obvious rewrite of
let* as nested
lets gives you the SBCL answer, but it does not. In a form like
(let* ((x 3) (y x)) (declare (type integer x) (type (integer 0) y)) ...)
This must be rewritten as
(let ((x 3)) (declare (type integer x)) (let ((y x)) (declare (type (integer 0) y)) ...))
So the declaration for
x must be raised out of the inner
let so it remains bound: the implementation already has to do work to get declarations in the right place and can’t just naïvely rewrite the form.
I prefer the first interpretation both because I think it represents what people are likely to want more closely, but also because I think the standard could be interpreted as meaning that without being rewritten.
Does this matter?
Probably only in very obscure cases! I just thought it was interesting.
Thanks to vrious people on the Lisp-HUG mailing list for coming up with this.