Not sure whom to answer, as this is a very diverse RFC and I have diverse ideas about it:
Language Expressivess
It is not possible to parse some valid Rust syntax like if expr block
, because what may come after expr
is very limited. This may not be generally possible, because an expr can confusingly end with SomeStruct { field }
or an if expression. A solution might be medium greedy expr
, which stops before the next item cannot be matched. I.e. if x == SomeStruct { field }
and if x == SomeStruct { field } {}
would both match upto before the last block.
Generalising this is also ruined by the syntax choice for let
chains, where suddenly &&
is not part of the preceding expr
. A solution might be if let $lhs:pat = $value:min_expr && …
where min_expr
stops capturing before where it first sees the next token.
Type Granularity
You can have a general tt
or be more specific. In the same way I often want to be more specific on other fragment specs.
Strings are syntactically different from numbers. Integers are different from floats. One should be able to choose between literal
, string
, number
and then again integer
, float
(which needs to check for either dot or alas also the four float suffixes like 1f16
.)
Likewise adding _
to expr
really ruined it, because in most contexts that is not a valid expression! Therefore we now need to be able to further distinguish lhs_expr
and rhs_expr
by whatever better name.
Alternatives
I variously find I have to repeat almost the same pattern. We would need $(…$|…$|…)
in which case a repeat suffix would be optional.
Repeat Count
There would need to be a suffix to represent a precise count, e.g. {min, max}
like in regex.
Capture Verbatim Things
This $var:(foo$|bar$|baz)
would put into $var
whichever of the three words (or other things) it found. Otherwise $(x)?
is purely decorative, without being able to know whether it matched.