[Poll] Consider changing the default of fsharp_multiline_bracket_style

[nojaf]

Hello everyone,

I recently had a conversation about how Fantomas formats records by default (fsharp_multiline_bracket_style = cramped).

There’s a configuration setting for this: fsharp_multiline_bracket_style.

The benefit of the cramped style is that it’s compact and may feel familiar to developers coming from OCaml or Haskell.

let myRecord =
    { Level = 1
      Progress = "foo"
      Bar = "bar"
      Street = "Bakerstreet"
      Number = 42 }

type Range =
    { From: float
      To: float
      FileName: string }

let a =
    [| (1, 2, 3)
       (4, 5, 6)
       (7, 8, 9)
       (10, 11, 12)
       (13, 14, 15)
       (16, 17, 18)
       (19, 20, 21) |]

The main drawback of this style is that it’s harder to manipulate record fields during copy/paste operations.
Indentation can also feel slightly off:

// indent_size = 4
let myRecord =
// Start of { at 4 spaces
    { Level = 1
// Start of record field at 6 spaces
      Progress = "foo"

This breaks what I call the “indentation flow.”
_{This topic deserves its own discussion, but it’s not the main focus here.}

The other available styles (aligned and stroustrup) do not have this issue:

// aligned
let myRecord =
    {
        Level = 1
        Progress = "foo"
        Bar = "bar"
        Street = "Bakerstreet"
        Number = 42
    }

type Range =
    {
        From: float
        To: float
        FileName: string
    }

let a =
    [|
        (1, 2, 3)
        (4, 5, 6)
        (7, 8, 9)
        (10, 11, 12)
        (13, 14, 15)
        (16, 17, 18)
        (19, 20, 21)
    |]

// stroustrup
let myRecord = {
    Level = 1
    Progress = "foo"
    Bar = "bar"
    Street = "Bakerstreet"
    Number = 42
}

type Range = {
    From: float
    To: float
    FileName: string
}

let a = [|
    (1, 2, 3)
    (4, 5, 6)
    (7, 8, 9)
    (10, 11, 12)
    (13, 14, 15)
    (16, 17, 18)
    (19, 20, 21)
|]

These styles make it easier to add or remove record fields, and indentation stays consistent with multiples of the indent_size.

The F# style guide mentions all three of these styles.

So, the key question is:

Should we reconsider the default style?

We (the Fantomas core team) would like to get a sense of how the community feels about this.
We are not promising any changes, but if there is strong community consensus in favour of something else, we will consider it seriously.

This has been the default for many years, so we will not make any changes lightly.

That said, we’d love to hear your preference.
Please react to the first message in this issue with:

• 👀 if you prefer to keep the current default (cramped)
• 🎉 if you’d prefer aligned
• 🚀 if you’d prefer stroustrup

We’ll only count reactions to the first post in this issue.
Reactions or opinions elsewhere will not be included.

//cc @dawedawe @josh-degraw

[charlesroddie]

Cramped has inconsistent indentation, sometimes 4, 3, or 2 spaces, so should be binned.

[richardcox13]

As a proponent of the One True Brace Style in C family languages I would prefer the Stroustrup option.
It offers the same vertical space saving as compact vs. aligned, while avoiding the odd indentation.

[WillEhrendreich]

I find stroustrop the nicest to work with.

Switching the order of things is great with every line then, it doesn't matter which comes first or last, I can swap lines without doing extra work to move the bracket.

It's also has the best trade off for indent vs number of lines I think.

[pkese]

In F# you can also add methods to a record type,
which is also not standardized.

I'm writing it as:

type Range = {
    From: float
    To: float
    FileName: string
} with
    member this.FromToString() =
        $"{this.From}-{this.To}"

[ursenzler]

I'm team "aligned" because I like the symmetry that helps my eyes parse code faster - even if the code is one line longer per record.
As long as there is a setting for the style, I'm totally okay with a different default style.

[ShalokShalom]

I decided to choose stroupstrup, since it is the closest to the indendation based style that we are used from FSharp otherwise.

Its also the easiest to read, I think.

[auduchinok]

Just to add a bit from the tooling and language design perspective. F# is indentation sensitive, and there are many cases where allowing something to be less indented makes it less suitable for the editor tooling. In the last couple of years we've significantly improved quality of the parser recovery during typing and many of these improvements assume that inner parts of expressions/statements are always more indented.

Stroustrup looks great and has many advantages, but out of these three styles it works the worst with the F# parser, because it was invented with a different language family in mind.

[siwatanejo]

From the current vote count (24-aligned, 84-stroustrup, 10-keepCurrentDefault) seems clear to me that the default should change. However, I'd argue that @auduchinok's input here is important, so maybe stroustrup should not be the default to switch to? (I'm biased, I'm team-aligned)

[nojaf]

From the current vote count

We need more input before deciding. So far the votes suggest a different option is preferred as the default, but that is relative: Fantomas averages about 500 downloads per day according to the NuGet stats. The NuGet numbers don't show the full picture of all users. It's hard to reach everyone, which is why we want to hear enough voices before making a decision.

[Martin521]

Just to add a bit from the tooling and language design perspective. F# is indentation sensitive, and there are many cases where allowing something to be less indented makes it less suitable for the editor tooling. In the last couple of years we've significantly improved quality of the parser recovery during typing and many of these improvements assume that inner parts of expressions/statements are always more indented.

Stroustrup looks great and has many advantages, but out of these three styles it works the worst with the F# parser, because it was invented with a different language family in mind.

The parser has to support all three options anyway. This is just about the Fantomas default.

[nojaf]

The parser has to support all three options anyway. This is just about the Fantomas default.

"Has to" is a bit of an assumption. The parser mostly supports three styles until it doesn't. You can probably write some extreme Stroustrup-style code that will hit parser limitations.

Overall, and I don't mean to be negative, F# wasn't designed with a formatter in mind. The parser accepts certain constructs, but code styling was never part of its original design, so these behaviors are more accidental.

Eugene's remark is valuable input. If we make Stroustrup the default, I expect more issues from people exploring uncharted territory where parser limitations may come into play.

[Martin521]

"Has to" is a bit of an assumption. The parser mostly supports three styles until it doesn't.

As far as I know, Stroustrup style has been valid F# since the "lightweight syntax" was introduced and was always part of the spec (§15.1.4). I have a hard time imagining the parser will stop to support it.