Record on single line setting

[nojaf]

Proposal

Fantomas currently formats a record on multiple lines if there are multiple fields.
Even though the record itself can still be short.

For example

type A = { A: int; B: int }

let a = { C = 1; B = 2 }

let b = { a with C = 2; B = 3 }

will be formatted as

type A =
    { A: int
      B: int }

let a =
    { C = 1
      B = 2 }

let b =
    { a with
          C = 2
          B = 3 }

If two or more fields are involved, every expression is put on multiple lines.
The suggestion from G-Research is to introduce a new setting to control with maximum allowed record width. And only format on multiple lines if the record exceeds this setting.

Proposed setting name : MaxSingleLineRecordWidth
Default value : 40

Impact

This would introduce a breaking change stylistically speaking.
It would require a change in multiline and has some impact on CodePrinter.

Gains

The outcome would be more concise code.

[jindraivanek]

+1

Actually, I would like global setting like this that would do this for all potentially multiline expressions. (but that is potentially hard to implement)

[auduchinok]

Could it maybe check if the line fits line length with single-line record formatting instead?

[nojaf]

Not sure you would always want this.
For example:

let a = { LongIdentifier = "foo"; X = a; BaaaarrIdentifier = "meeeeeeh"; Meh = FooAgain; A = y; Y = e; C = c; D = dd }

This is 118 long and would in theory fit on a PageWidth 120 setting.
However, for me, this should be on multiple lines.

I think a similar setting could also be useful for deciding when an array should be on multiple lines or not. Debatable whether this should be a separate setting or the same setting.

f.ex.

let a = [ "Fooooooooooooo";  "Baaaaaaaaaaaaaaaaaar"; "Meeeeeeeeeeeeeeeh"; "Turn"; "To"; "Stooooooooooooooooooooonees" ]

This again is 119 characters long and I would use multiple lines instead of placing it on one as it does now.

We could introduce some new construct that tries a naive solution to format an expression and then check if that exceeds a certain length.

Something along the lines of

    let isExpressionLongerThen f maxWidth ctx =
        // create empty context
        let dummyCtx =  f { ctx with
                              WriterModel = WriterModel.init
                              WriterEvents = Queue.empty }
        let writerEvents =
            dummyCtx.WriterEvents
            |> Seq.takeWhile (function | WriteLine _ -> false | _ -> true)
            |> Seq.toArray

        let totalColumnSize events =
            Seq.fold (fun acc ev ->
                match ev with
                | Write w -> String.length w
                | _ -> 0
                |> (+) acc) 0 events
            |> fun total -> total > maxWidth

        let isLonger =
            if dummyCtx.WriterEvents.Length > writerEvents.Length
            then true // multiple lines
            else totalColumnSize writerEvents // checks if single line is longer then maxWidth

        isLonger

    let isLong (ctx: Context) =
        isExpressionLongerThen shortExpr ctx.Config.MaxSingleLineRecordWidth ctx

    (ifElseCtx isLong multilineExpr shortExpr) ctx

[nojaf]

Implemented in #721