Hello, attached is a proposal on the topic of identifiers inside pattern matching.
It is a section of an old proposal I wrote few months back, which did not account for the existence of p2688, as well as p2211, which renders many sections of it no longer needed.
At a high level, it's difficult to tell what the paper is actually proposing - since first it says talks about naturally introducing relational patterns, then it says it's not proposing them. Then it says it's proposing "== expression" as the expression pattern, but then frequently throughout the paper == isn't used, but then you say it's optional if it's the "last pattern" - But what does last pattern mean? When is == mandatory and when it is optional?
I also can't tell what actual grammar you're proposing, and it doesn't help that throughout the paper you're frequently using the same identifier to mean both a type and a variable name, which makes it hard to tell what the patterns even mean. I'm not sure why that case is interesting to begin with, much less needs to be so prevalent. There's no ambiguity to the compiler in the Alternative Pattern for <x>, it might be ambiguous to the reader, but not to the compiler. In the same way that template <T V> could be a constrained type (if T names a concept), or a non-type template parameter (if T names a type), or a deduced non-type template parameter (if T is a template-id).
I'm assuming that the proposal is:
- the alternate pattern is type-id pattern
- the expression pattern is == expression (except sometimes not? I don't understand when you would need the ==)
- the identifier pattern is either identifier= or &identifier=
P2688 has a lot of examples that are both short and complete. I would encourage you to simply use those.
----
But ultimately we're just talking about a change in syntax? What's wrong with the syntax proposed in P2688? I don't really see much of an argument there, except that you don't like the <>s used by the alternative pattern in P1371/P2688?
Concretely, I don't think the syntax n= syntax for bindings is particularly good. Your model is init-capture in lambdas, but init-capture is lambdas isn't at all the same thing as bindings in a pattern, so I'm not sure that it's a good model. Having a distinct syntax for mutable vs immutable bindings is interesting, but I'm not sure & is a good syntax to indicate mutability. And if you always have a marker for the identifier pattern, we're just talking about the difference between "let x" and "x=", so I don't think you'd need the "==" for the expression pattern ever. The issue largely becomes a question of disambiguating types.
Barry