Just add WITH-VALUES and VALUES.

[jar (Jonathan Rees)]

I like the brevity of your proposal, but the proposal should
explicitly say something about what the arity of implicit
continuations (into argument positions for calls, test position of if,
etc.) is.  I.e. whether (list (foo)) is equivalent to

    (list (with-values foo (lambda (x) x)))

or

    (list (with-values foo (lambda (x . ignore) x)))

or something else.  As I remember, the near-consensus at Snowbird was
for the second.  (That was also the near-consensus at the MIT meeting
of 1987 (?), except that I disagreed; I changed my position later when
I saw that I was outnumbered and when I could understand the semantics
of the other position better.  Now I don't much care, I just would
like to see multiple values in some form.)

As long as I'm babbling, my problem with ACCEPTS? or
PROCEDURE-ACCEPTS? is that there is no inverse for it -- no general
way to construct a procedure that can advertise how many arguments it
would like to accept.  In particular, it makes invalid Scheme's
currently useful eta-expansion rule: if x is a procedure, then x can
be replaced by (lambda args (apply x args)) [modulo EQ?].  We could
recover some kind of eta rule if we had some way to associate an
ACCEPTS? "method" with a procedure, e.g. maybe (ACCEPTING proc1 proc2)
would return a procedure p that behaved the same as proc1 except that
(ACCEPTS? p n) would return the value returned by (proc2 n).
(You can do this kind of thing in T, which has a crude analogue of
ACCEPTS?.)  Then we would have x equivalent to

(accepting (lambda args (apply x args)) (lambda (n) (accepts? x n))).

I'm not proposing ACCEPTING, and I'm not saying that I would veto any
proposal that has ACCEPTS? in it.