Relax of indentation rules to allow tuples to have newline after the comma

[et1975]

Relax of indentation rules to allow tuples to have newline after the comma

So that one could write something like:

let v : _*_ =
    1,
    2

instead of:

let v : _*_ =
    1
    ,2

Currently it is possible to wrap the tuple in () and get the desired newlines that way, but it seems noisy and it introduces itsown tab stop.

Pros and Cons

Pros: Less noise and more consistency with how commas are usually placed.

The disadvantages of making this adjustment to F# are ...
None that I can think of.

Extra information

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

Related suggestions:
#724
#470

Affidavit

Please tick this by placing a cross in the box:

• This is not a question (e.g. like one you might ask on stackoverflow) and I have searched stackoverflow for discussions of this issue
• I have searched both open and closed suggestions on this site and believe this is not a duplicate
• 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
• I or my company would be willing to help implement and/or test this

[cartermp]

I'd like to see this if possible

[dsyme]

I just checked master and both work today:

let v : _*_ =
    1,
    2

giving

val v : int * int = (1, 2)

[et1975]

I thought I oversimplified the example, but it looks like I just haven't tried writing it like that in a while.

[Happypig375]

Please reopen. This should also apply for
static member M(a:int->int, b:int) and

M(a=fun a -> a + 1,
  b=1)

Currently disallowed.

[dsyme]

That one is by design, because of the undentation rule for fun

[dsyme]

The only solution that would not require parens would be to allow a a => b function syntax where => had higher precedence than ,, e.g.

M(a=a=>a + 1, b=1)

or

M(a=a=>a + 1,
  b=1)

I don't think simply dropping the fun can be made to work with the right precedences but I may be wrong - but in any case changing the precedence of -> when the fun is dropped seems wonky

M(a=a->a + 1, b=1)

[Happypig375]

But the b=1 is one level lower in indentation, so tuple shouldn't be considered