Possible unification of type pattern, positional pattern, and property pattern

[gafter]

@gafter commented on Fri Apr 15 2016

This is a possible unification of the syntax for the positional pattern, property pattern, tuple pattern, var pattern, and type pattern.

The syntactic constraints on the syntax for recursive_pattern are as follows:

• At least one of the parts before the identifier is required.
• The pattern_type may not be a tuple type.

Furthermore, when a positional_subpattern is present, a identifier or property_subpattern may only be present if the positional_subpattern binds to a tuple type or a type with a self-typed deconstructor.

recursive_pattern
    : pattern_type? positional_subpattern? property_subpattern? identifier?
    ;

pattern_type
    : `var`
    | type
    ;

positional_subpattern
    :  '(' subpattern_list? ')'
    ;

subpattern_list
    : subpattern
    | subpattern ',' subpattern_list
    ;

subpattern
    : argument_name? pattern
    ;

property_subpattern
    : '{' property_pattern_list? '}'
    ;

property_pattern_list
    : property_pattern
    | property_pattern ',' property_pattern_list
    ;

property_pattern
    : identifier 'is' pattern
    ;

---

@gafter commented on Fri Apr 15 2016

@AlekseyTs @agocke FYI

---

@bbarry commented on Mon Apr 18 2016

Effectively a change something like this to patterns.md?

positional_pattern
    :  type? '(' subpattern_list? ')' identifier?
    ;

property_pattern
    :  type identifier? '{' property_subpattern_list? '}'
    |  '{' property_subpattern_list? '}'
    | var identifier '{' property_subpattern_list? '}'
    ;

edit: added identifier? to positional_pattern; but yes I see how you are combining and this doesn't get you that.

---

@gafter commented on Mon Apr 18 2016

@bbarry No, that wouldn't allow

    Point M() => ...;

    if (M() is (var x, var y) p { Length is 5 }) Console.WriteLine(p);

Note that with this new proposed syntax we would not allow the use of tuple types for the type due to an ambiguity with the positional part of the pattern.

---

@alrz commented on Mon May 09 2016

I believe @bbarry meant the ability to name the whole pattern in positional patterns,

positional_pattern
-   : type? '(' subpattern_list? ')'
+   : type? '(' subpattern_list? ')' identifier?
    ;

Also, I think it reads better if you put the identifier at the end in property patterns,

property_pattern
-   : type? '{' property_subpattern_list? '}'
-   | type identifier '{' property_subpattern_list? '}'
-   | var identifier '{' property_subpattern_list? '}'
+   : type? '{' property_subpattern_list '}' identifier?
    ;

It makes the var unnecessary, regardless of the presence of the type itself. However you might want to consider a keyword or token before the identifier, specially in array patterns, etc because it's almost invisible.

case T id:
case ( .. ) id:
case { .. } id:
case T ( .. ) id:
case T { .. } id:
case T ( .. ) { .. } id:

I'd like to suggest to unify match and case expressions as well,

match_expression
-   : relational_expression 'switch' match_block
+   : relational_expression 'match' match_block
+   | relational_expression 'match' pattern ':' shift_expression
    ;

This probably makes it easier to disambiguate it with the case keywords within match expression.