I am becoming more worried again about the consequences of using a contextual
keyword such as “yield”, especially for IDEs.
It seems to me that this whole discussion kicked off with a discussion of
`yield` as being desirable because, by analogy with `return` being the One True
Way to return a value from a stack frame for an invocation, it might be
desirable to have One True Way to return a value from a statement-like
expression that did not create a stack frame. So if in future we might have a
number of other expressions from which we want to return a value, we might want
to pick a keyword not specifically associated with `switch`.
But I now think that this argument is weak, because I believe it is in fact
unlikely that there will be a large number of other statement types that we
will want to turn into expressions.
* Yes, we may want block expressions.
* We would want `if`-statement expressions _except_ that we already
have the ternary operator ? :, so I don’t really think there is a pressing need.
* As a Common Lisp programmer, I can see the value of having a `for`
loop produce a value. But I very much doubt that Joe Java-programmer wants
that.
* And if we don’t want values from `for` loops, I doubt there will be
much demand for values from `while` loops or `try` statements.
So I really do think that ? : and `switch` expressions and blocks really are
it. Sometimes there really *are* only two or three things of real interest,
even if one could theoretically dream up more.
And if I am wrong, there is still a way out for the rare cases: if we have a
way to do a non-local yield from a block, you can wrap that kind of block
around any statement you like, just as you can `break` from any kind of
statement by wrapping a labeled-statement around it (that is, by giving it a
label).
So I am now leaning toward either `break-with` (or `switch-yield`, but I think
`break-with` is better).
And if we ever do expression blocks, then we could have a special thing for
returning from them. In fact, I have a suggestion:
block expression ({ statements; expression })
labeled block expression (label: { statements; expression })
nonlocal block yield break label: expression;
In fact, if we had those, we wouldn’t need a special way to yield a value from
a switch expression; we could just write
(label: switch { . . . ; case 43: { printf(“foo”); break label: 96; } .
. . })
which in turn suggests that we could omit the label from the `switch` statement
and the corresponding `break` statement if we wanted—in other words, under this
theory a plausible spelling of `break-with` is `break:`. :-)
—Guy
