MULTPLE-VALUE-OR &rest args

[MURRAY%cs.umass.edu@RELAY.CS.NET]

    >I think more to the heart of the matter is that Common LISP needs a way to grab,
    >inspect, and pass on an unknown number of multiple values without consing
    > (and yes, avoiding consing can be crucial for real applications
    > give the current state of the art for garbage collection
    > on conventional hardware).  It's possible that, using
    >multiple-value-call, simply having some way of 
    >doing non-consing &rest arguments may be sufficient.   ...

    I whole-heartly agree that A) Unneccessary consing should always be avoided,
     B) it would be great to have &rest args that don't cons.
    I currently have plans to have a STACK-LIST declaration that declares that
    a &Rest is stack-allocated (as well as WITH-STACK-LIST, ala Lisp Machines)
    in my system.  I would suggest that others consider this as well, but
    of course, it is only a declaration that could be ignored.
    (I already avoid consing for (&Rest ignore), which should be easy).

    My point is that MULTIPLE-VALUE-OR can only be done efficiently by low-level
    implementation-specific code, and thats why it should be in Common Lisp.

 >I don't think this conclusion follows from your previous paragraph.
 >If the proposed MULTIPLE-VALUE-OR can easily be implemented in terms of
 >existing primitives, such as MULTIPLE-VALUE-CALL, and would be efficient
 >if there were non-consing &rest arguments, and non-consing &rest arguments
 >are desirable for other reasons, then I think a more logical conclusion is
 >"because non-consing &rest arguments can only be done efficiently by low-level
 >implementation-specific code, they should be in Common Lisp."

Are you just pointing out a flaw in my logic, or are you suggesting that
Common Lisp REQUIRE certain &rest args to not cons?  The last sentence
was not meant to logically follow from the previous -- I was merely
re-iterating my point in requesting a MULTIPLE-VALUE-OR form, which is it
can be efficiently implemented WITHOUT non-consing rest args.  I might
also add that using MULTIPLE-VALUE-CALL is going to require both 
a Lambda and a Block, in which the Return-From will end up being a Throw.
It might not Cons, but I wouldn't call that "Efficient" (Maybe Symbolics does
function calls and throws more efficiently than a couple tests and a branch?
If so, that is exactly why it should be in Common Lisp -- You do it your way,
I'll do it mine).

 >By the way, I don't think a declaration for non-consing &rest arguments
 >should be necessary.  It should be simple enough for any compiler to
 >recognize special cases such as the following, once implementors'
 >attention has been drawn to the desirability of such optimizations.  Another
 >way of saying the same thing is that I think consing is an implementation
 >issue, not a language issue, just as much as whether integer multiplication
 >takes 1 microsecond or 10 microseconds.

 >  (lambda (&rest values)
 >    (when (first values)
 >      (return-from block (values-list values))))

I guess you are saying Common Lisp shouldn't REQUIRE any &rest args not to cons.
I certainly agree - it is properly in the domain of Optimizations.  A declaration
may not be always be necessary, but this is just about in the same category
as determining whether a function has side-effects.  You can sometimes prove
it doesn't, but why go to all the bother if a very knowledgable and intelligent
(compared to a compiler) programmer can simply tell you?

- Kelly Murray