Yield as contextual keyword (was: Call for bikeshed -- break replacement in expression switch)

[Guy Steele]

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