[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [Scheme-reports] Technical question
On Thu, 2011-05-26 at 23:03 -0400, Anton van Straaten wrote:
> On 05/26/2011 07:06 PM, Jay Reynolds Freeman wrote:
> > I am *not* in WG1, but Aaron has asked for comments that contrast
> > with his opinion, so I shall risk speaking up ...
> The reason the semantics lead to a single interpretation here is simple:
> continuations in the semantics involve multiple values by default. This
> is represented by all the e* terms scattered throughout the definitions.
> Even when a single value is passed to a function, as in the expression
> (f x), at the semantic level this corresponds to (applicate f <x>),
> where <x> is a "sequence". Sequences have zero or more values. It is
> then up to a called procedure to test that it receives the number of
> arguments it is expecting. This test can be found in the semantics for
> lambda terms, as e.g. #e* = #I*.
I'm pretty strongly of the opinion that procedure calls and procedure
returns are "dual" -- that is to say, although appearing different at
first impression, they are instances of the same thing. In fact,
call-cc works *because* a procedure return can be converted directly
into a procedure call.
In my mind, this duality forms the single strongest argument for
multiple-value returns - If a procedure call can have multiple
arguments, then logically, if the two are (or ought to be)
interconvertible, then a procedure return can return multiple
results. In R4RS/IEEE1178 Scheme, a procedure can only return a
single value, and therefore a continuation can only be called with
a single argument. R5RS introduced multiple-value returns (and with
them multi-argument continuations) and at least some of the arguments
in favor of doing so were about the 'symmetry' between procedure calls
and procedure returns.
But we haven't achieved symmetry yet. Functions can report an arity
error when called with the wrong number of arguments. According to
the formal semantics they have to wait until the arguments have been
evaluated before doing so, but one of the first things that the code
for a two-argument function does is to check and make sure that it
has two arguments. That being the case, it seems to me that by some
kind of parallel rule, a continuation expecting a certain number of
arguments ought to report an arity error when it gets a wrong number
And this leads to the pragmatic question, "Well, how do we determine
how many arguments a particular continuation expects, anyway?" In
Scheme, there are procedures that expect exactly N arguments, and
procedures that expect at least N arguments (for various nonnegative
Because we have a longstanding tradition of simply ignoring the
single result of procedures called for side effects, the logical
generalization seems to be that continuations require "N or
more" arguments, with "extra" arguments ignored. A 4-value return
from a procedure, in a context that requires 2 arguments is like
((lambda (a b . c) (+ a b)) 1 2 3 4), and evaluates without a problem.
((lambda (a b . c) (+ a b) 1), however, should report an arity error
when the anonymous function gets control (and not before), and
therefore I believe that for consistency, continuations requiring
some positive number of arguments should report an arity error
on gaining control (and not before) when called with less than
that number of arguments.
What do I mean when I say "and not before"? I mean that the
system is not allowed to throw an error without evaluating the
return expressions based on the arity of the return context.
It may turn out that one of the return expressions is a continuation
that does a non-local exit, or has a visible side effect, and in
that case an "eager" arity error would break program semantics.
Under my language-design hat, I think that we should consider
ways to create continuations with a definite (maximum) number
of required arguments and enable too-many-returns arity
errors, fleshing out the parallelism with function calls.
Under my language-standardization hat, I note that no such
work is now tested or implemented, and that therefore
standardization of such a thing would be premature.
Scheme-reports mailing list