Exception handling in switch (Preview)

[Clement Cherlin]

On Wed, Apr 24, 2024 at 10:08 PM Guy Steele <guy.steele at oracle.com> wrote:

On Apr 24, 2024, at 10:50 PM, Kevin Bourrillion <kevinb9n at gmail.com> wrote:

Hey Angelos!

For whatever my take is worth here, I'm also skeptical. I think the bar for
adding another way to catch exceptions should be really high, and the
benefits here wouldn't clear it. I just don't expect the nested
switch-in-try will be painful enough *often* enough.

This feature would only be applicable when the whole
possibly-exception-producing code can fit into a single expression in the
switch header . . .


This raises a very good question: what do we expect the "whole
> possibly-exception-producing code” to look like in practice?
>
> I conjecture that the attractive situation for using switch-with-“case
> throws"-clauses will NOT involve arbitrarily large expressions that might
> need to be refactored, but rather a single method call (or possibly an
> expression with a single operator) where all argument expressions are
> variables or constants, rather than other stuff that might cause exceptions.
>
> But I am not sure. So maybe this is a conjecture that could be researched.
>
> —Guy
>
>
I expect a major consumer of this feature to be streams and other
functional constructs. Try-catch is an exclusively block-oriented
mechanism. There is as of now no way to catch an exception inside an
expression, which is why I think this feature is valuable. Handling
exceptions inside a switch expression lambda would be a significant
enhancement.

getStream().map(value -> switch(someFunction(value)) {
  case FirstPossibleType fpt -> ...
  case SecondPossibleType spt -> ...
  case catch IOException io -> ...
  case catch IllegalArgumentException ia -> ...
}).filter(...)
  .forEach(...);

is an awful lot shorter, cleaner, and easier to read and write than

getStream().map(value -> {
  final SuperType st;
  try {
    st = someFunction(value));
  } catch (IOException io) {
    ...
  } catch (IllegalArgumentException ia) {
    ...
  }
  return switch (st) {
    case FirstPossibleType fpt -> ...
    case SecondPossibleType spt -> ...
}).filter(...)
  .forEach(...);

Especially given the care that needs to be taken to only catch exceptions
thrown by someFunction() and not the switch arms.

Side note: I agree that "case catch Exception ex" is far more consistent
with the current "catch (Exception ex)" syntax than "case throws Exception
ex" is. The practical familiarity, usability and consistency of "case
catch" trumps any theoretical virtues of "case throws", especially since
grammatical English would demand "case threw Exception ex".

Cheers,
Clement Cherlin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/amber-spec-observers/attachments/20240507/1999f132/attachment.htm>