A pattern matching parentheses and assotiation question

[En3Tho]

I came to find this stuff when tried to play with ActivePatterns:

let foobar = function // x is val, y is (val, val), z is ((val, val), val) wtf
| "" as x, 0 as y, 0.0 as z -> (x, y, z)
| _ -> failwith "Impossible"

let foobar2 = function // ideally this one should functionally work as foobar3 as we have parentheses to indicate that we are inside the tuple
| ("" as x, 0 as y, 0.0 as z) as tuple -> (x, y, z) // z and tuple are the same thing here :/ Totally unxpected and unintuitive
| _ -> failwith "Impossible"

let foobar3 = function // this is not looking good at all.
| "" as x, (0 as y), (0.0 as z) -> (x, y, z)
| _ -> failwith "Impossible"

let (|Tup3|) abc =
    let (a, b, c) = abc
    a, b, c
    
let foobar4 = function // active patterns require even more parentheses, e.g. this:
| Tup3 ("" as x, (0 as y), (0.0 as z)) -> (x, y, z)
| _ -> failwith "Impossible"

let foobar5 = function // insdead of just this
| Tup3 ("" as x, 0 as y, 0.0 as z) -> (x, y, z) // this can't even be built without adding parentheses
| _ -> failwith "Impossible"

Can these rules be relaxed or is it too much of a breaking change?
Like it's somewhat ambigous when there are no parentheses outlining the tuple itself, but when there are, I think current behaviour is not intuitive at all.

@dsyme @cartermp

[auduchinok]

I personally agree that it's not very intuitive but it'd be a serious breaking change if we change it.