Evolve catch clause to enable pattern matching for more compact catch-when

[Peter-Juhasz]

Motivation

It is quite a common pattern to narrow down a catch clause based on the Exception properties:

try
{
    // ...
}
catch (OperationCanceledException)
{ }
catch (HttpRequestException ex) when (ex.StatusCode is HttpStatusCode.NotFound)
{ }

Compatibility

The way this proposal may be different from others, and what my original intention is to bring value to the language in the smallest, compatible, incremental way without breaking the original try-catch-finally statement structure or introducing different syntaxes other than what we already have.

try-catch statement, not expression

Also, this proposal focuses on improving the try-catch statement, at the statement level, so it can be used in existing control flow, and not at the expression level, like the switch expression.

Description

The catch clause is already pattern-like, because it can behave either as a type filter, or a type filter and a declaration as well.

The when clause was quite useful on its own, but today in many cases these two clauses could be merged into a more powerful catch clause, where not only declaration is allowed, but a pattern:

try 
{
    // ...
}
catch (OperationCanceledException)
{ }
catch (HttpRequestException { StatusCode: HttpStatusCode.NotFound } ex)
{
    // `ex` is available here
}

So, this example is equivalent to the first one, but in a more compact form using a pattern in the catch clause without a when clause.

The when clause could still remain for narrowing down the filter further if non-constant evaluation is necessary.

Detailed design

In language specification: exception_specifier inside a specific_catch_clause could be replaced to a pattern/declaration_pattern.

  specific_catch_clause
      : 'catch' exception_specifier exception_filter? block
      | 'catch' exception_filter block
      ;

  exception_specifier
-     : '(' type identifier? ')'
+     : '(' (type identifier? | pattern) ')'
      ;

Open questions

[333fred]

Similar to #8450.

[zms9110750]

I have a similar idea to yours.

try
{
}
catch switch
{
	case IOException e when （e.Message.Length < i）:
		break;
	case when (i < 3):
	default:
		break;
}

[NN---]

If the language devs need references there are other languages implementing such idea. For instance, Nemerle: https://github.com/rsdn/nemerle/wiki/Quick-guide#user-content-TryCatchFinally

[HaloFour]

They don't really need to go further than F#: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/exception-handling/the-try-with-expression

What I don't like about this take on it is that it's entirely separate from normal pattern matching, which makes it awkward when you're matching against both successful and failure cases. You end up having to nest one within the other, despite the fact that syntactically they are incredibly similar. I prefer what Java is considering here in allowing for exception cases to be caught in normal switch statements/expressions:

var str = ...;
var opt = switch (Integer.parseInt(str)) {
    case int i -> Optional.of(i);
    case throws NumberFormatException _ -> Optional.empty();
};

I've opened a discussion some time ago about this: #989

[Peter-Juhasz]

Thank you for bringing similar proposals to my attention.

The way this proposal can be different, and what my original intention was, to bring value to the language in the smallest, compatible, incremental way without breaking the original try-catch-finally statement structure or introducing different syntaxes other than what we already have.

Looking at the language specification: exception_specifier inside a specific_catch_clause could be replaced to a pattern/declaration_pattern.

  specific_catch_clause
      : 'catch' exception_specifier exception_filter? block
      | 'catch' exception_filter block
      ;

  exception_specifier
-     : '(' type identifier? ')'
+     : '(' (type identifier? | pattern) ')'
      ;

(Based on the Patterns section in the documentation, I'm not sure which is the best choice, but I hope you get the idea.)