this has nothing to do with software. It is about syntax.

Not necessarily possible, at least not easily. The `=>`

from match is not just a binary operator, so this is not your usual operator expression parsing anymore. To make it even more complicated, the match-arm-`=>`

is either `PAT if EXPR => EXPR`

or `PAT => EXPR`

while the `matches`

-`=>`

would be `EXPR => PAT`

. Total madness to apply any kind of associativity.

Approaching `a if b => c => d`

you would at least need to try parsing `c => d`

as an expression which can either fail (when `c`

is only valid syntax for a pattern) or succeed but then be immediately discarded because you actually need to parse it as a pattern followed by `=>`

instead *(and make sure to discard it quickly, crucially before fully parsing d, otherwise you’re quickly in quadratic complexity land)*. Also imagine the inconsistency if the match arm

`a if b => c => d`

is supposed to mean `a if (b => c) => d`

but the match arm `a => c => d`

probably still means `a => (c => d)`

(since the left hand side of the arm can only be a pattern).And taking any anology to `==`

would suggest to have no associativity but require parentheses anyways.