Align precedence of infix operators with a dot prefix to F# spec

[kevmal]

I propose we adjust the precedence for infix operators with a leading dot, such as (.&&) , (.||), (..&&), etc. , to make them equivalent to their counterparts without the leading dot, such as (&&), as specified in the F# language specification.

The existing way of approaching this problem in F# is to use additional brackets to achieve the correct order of operations, but this does not match the language specification and causes confusion and unexpected behavior.

Pros and Cons

The advantages of making this adjustment to F# are:

• Aligns the behavior of the F# compiler with the language specification.
• Provides a more consistent and intuitive experience for developers.
• Resolves the issue with expressions like a = b .&& b > c not matching a = b && b > c.

The disadvantages of making this adjustment to F# are:

• May introduce breaking changes to existing F# code that relies on the current precedence behavior for infix operators with a leading dot.

Extra information

Estimated cost (XS, S, M, L, XL, XXL): S

Related suggestions: None

Affidavit (please submit!)

Please tick this by placing a cross in the box:

• [x] This is not a question (e.g. like one you might ask on stackoverflow) and I have searched stackoverflow for discussions of this issue
• [x] I have searched both open and closed suggestions on this site and believe this is not a duplicate
• [x] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:

• [ ] This is not a breaking change to the F# language design
• [x] I or my company would be willing to help implement and/or test this

[Tarmil]

For reference, page 38 of https://fsharp.org/specs/language-spec/4.1/FSharpSpec-4.1-latest.pdf:

In the preceding table, leading . characters are ignored when determining precedence for infix operators. For example, .* has the same precedence as *. This rule ensures that operators such as .*, which is frequently used for pointwise-operation on matrices, have the expected precedence.

[dsyme]

We should clarify the specification instead to match the implementation, given the backwards compat constraints involved.

[kevmal]

@dsyme This was per-approved here: https://github.com/dotnet/fsharp/issues/13051 have things changed?

It's a bit awkward since, for example, a neural network lib may want an "and" operator that results in a non-bool type, but the order of operations ends up being off making readability difficult.

[dsyme]

Thanks @kevmal , yes I've reopened.

My bar on breaking changes shifts around a bit - this is right on the margin.

@vzarytovskii Could you bar-check you think this is a reasonable thing to change if placed under a langversion switch? It does make the language more consistent in the area of operators, which have too many corner-cases like this.