Some questions

[miller.pa@Xerox.COM]

	Now that all you people and companies out there are doing all these
common-lisp compilers, I'd like to ask you some questions:

Do you transform the source to continuation passing style before
compiling?  
How happy are you with this decision?  
If you don't, do you do tail-recursion optimizations anyway?
If you do, do you do multiple values by calling the continuation with
multiple arguments?
Should the parameter list in a multiple-value-bind allow :optional,
:rest, etc...

	When the silver book says that something has dynamic extent, it is
allowed for an implementation to provide indefinite extent, since "it is
[only] an error" to try to interact with a value whose extent has
expired.  Providing indefinite extent would be a clean way for an
implementation to offer upwards compatible extensions of the language.
This would be particularly useful for catch tags.

Do you provide indefinite extent for anything for which dynamic extent
is all that's required?
Does a program have any portable way of testing whether such an
extension is available? (e.g. *features*)  
Should there be?

How happy are you with packages?
In particular, for those familiar T's reified lexical environments (aka
LOCALEs), can you think of any reason for preferring packages?
Can the global scoping environment consistently be considered to simply
be the outermost lexical environment?
Can T's LOCALEs be added to the language in an upwards compatible way?

Has anybody given any thought to defining a formal semantics for
common-lisp?
Do you think there is any hope for such a thing?
What about a simple explanatory meta-interpreter (in the Scheme
tradition)?
Any common-lisp partial evaluators out there?

			MarkM