RFC: a reserved keyword case for further exploring pattern match in Julia

[Roger-luo]

From JuliaCon 2023, we discussed if we can support a better pattern match in Julia with @NHDaly @c42f and I just chatted with @gafter. And I believe multiple people have realized that it is very hard to support good pattern expression within the current syntax because they tend to have lots of ambiguities semantically. One example is the implementation of guards, currently this is usually done with the following expression in (MLStyle, Match, Rematch, etc.)

pattern && if cond end => expr # MLStyle
pattern where cond => expr # Match, Rematch
pattern, if cond end => expr # Match, Rematch

where the where is usually ambiguous because where may annotate type params, and the first and thrid expression has the extra boilerplates that one needs to type every time, plus it cannot limit one to not write if cond stmts end in the pattern because it's a valid syntax.

So here my proposal is to have a reserved keyword case with the following semantics:

• it should currently error if not generated to other expressions by macros
• the syntax is case <pattern> : <expression> or case <pattern> if <cond>: <expression>

which returns the following syntax object

Expr(:block,
   Expr(:case, <pattern>),
   <expression>,
)

and

Expr(:block,
   Expr(:case, <pattern>, <cond>),
   <expression>,
)

and perhaps the corresponding line number nodes. I think this solves the ambiguity problem and will allow people further exploring pattern match in Julia within packages. I'd like to see what people think? and if there are potential issues with this? Or maybe there are better syntax that resolves the ambiguity when served as a pattern expression? I think in general there aren't much options for arrows, which is why I think an extra (reserved) keyword is needed.

[gafter]

I would like the parser to do this.

I think case <pattern> : <result> could be represented as
Expr(:case, <line_number>, <pattern>, true, <line_number>, <result>)

and case <pattern> if <condition> : <result> could be represented as
Expr(:case, <line_number>, <pattern>, <condition>, <line_number>, <result>)

Where those line numbers are the beginning of the pattern and result.

We would expect to use it in pattern-matching macros like this:

@switch <intput> begin
    case pattern:
        result
    case pattern if condition:
        result
end

or this

@switch <intput> begin
    case pattern: result
    case pattern if condition: result
end

The advantage of including the result as part of the syntax of the case is that the case and result could be placed on the same line or on different lines without affecting the meaning. (If you don't include the result in the syntax then the programmer would have to write a semicolon after the colon to put the result on the same line)