Switch expressions and pattern matching

[ghost]

We should add (at least) the following patterns to the language:

• Expression patterns, which rely on the matched type being equatable. Denoted by case expr
• Binding patterns, which match anything and put it into a new variable. Can be modified by a mut prefix to make the variable mutable. For example: foo, mut bar
• Catch-all pattern, denoted by an underscore
• Struct patterns, denoted by: StructName { field_a: pattern, field_b: pattern }
  • Or the shorthand StructName { field_a: pattern, .. } when you only care about some fields
  • Or the shorthand StructName { field_a, .. } when you want a binding pattern with the same name as the field
• Enum patterns, denoted by either EnumName.variant, EnumName.tuple_variant(pattern, pattern) or EnumName.struct_variant { field_a: pattern, field_b: pattern } depending on the kind of variant (same shorthands apply to struct variant patterns as struct patterns)
• Composite patterns, for tuples and array-like types: [pattern, pattern]
• Conjunction patterns, denoted pattern2 @ pattern2
• Disjunction patterns, denoted pattern1 ||| pattern 2

To make use of these patterns, we should add a switch expression. It needs to do exhaustiveness checking at compile time, which would benefit from using the refinement checker, I think. In addition to exhaustiveness, if there are two or more equivalent patterns, we should emit an error.

Code sample:

Foo := struct { a: i32 }
val := Option.some(Foo { a: 27 })

// Should warn that all but the case 27 pattern is dead code, but no errors because every possible case is handled:
new_val := switch val {
    Option.some(Foo { a: a @ (case 27 ||| case 35) }) => a / 2
    Option.some(Foo { a }) => a
    Option.none => 2024
}

[zachwolfe]

Idea for destructuring: take a hybrid of Rust and Jai syntax. The new variable declaration syntax would consist of irrefutable-pattern : type? = value. Instead of := for variables and :: for constants, you'd have constname := value for constants and mut varname := value for variables. Then destructuring falls out: [a, mut b] := "string".split("r")