Docs: Record definition style

[matthid]

There are at least 3 ways to define a record:

type Record =
  { clients: int
    field: string }
    member x.MyField = x.field

type Record =
    { clients: int
      field: string }
    member x.MyField = x.field

type Record = {
    clients: int
    field: string 
} with
    member x.MyField = x.field

type Record =
    {
        clients: int
        field: string 
    }
    member x.MyField = x.field

If we cann't recommend a particular style (because people do it differently) we should at least list the common ones to help new-comers (and list advantages and disadvantages...

---

Document Details

⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

• ID: 8c09996f-24ac-cf39-ef43-d7909cbc2b89
• Version Independent ID: 1efdd523-8552-6421-e149-74f76826ef8f
• Content: F# code formatting guidelines
• Content Source: docs/fsharp/style-guide/formatting.md
• Product: dotnet-fsharp
• GitHub Login: @cartermp
• Microsoft Alias: phcart

[cartermp]

The current guidance does not enumerate the various ways to define records, though I'd be open to a PR that does lay out a few of these other styles.

[matthid]

@cartermp Should we discuss and decide on one of the above with some people or just list those three (personally, I don't really like all of them) ?

[vasily-kirichenko]

type Record =
  { Clients: int
    Field: string }
  member x.MyField = x.field

[7sharp9]

The problem is none of them have a particularly nice line up between the end of definition and a member. Having the requirement to use { } seems odd.

[matthid]

@7sharp9 Note that while I completely agree with you that any of the styles "feel" awkward this issue is not really about that. What I'm asking for is: What do we suggest newcomers to use considering the current state of the language.

I think your comment should be a language suggestion or discussed with @dsyme directly ;)

[matthid]

@vasily-kirichenko Now I realize that your suggestion is slightly different:

type Record =
<indent  >{ Clients: int
<indent+2>Field: string }
<indent  >member x.MyField = x.field

vs

type Record =
<indent-2>{ Clients: int
<indent  >Field: string }
<indent  >member x.MyField = x.field

which was my suggestion. It seems your suggestion is also what the compiler uses and looks quite good. Maybe we should just go with that?

[vasily-kirichenko]

@matthid I totally agree :)

[rodrigovidal]

I use the same style that @vasily-kirichenko does.

[cartermp]

One thing to keep in mind about using what the compiler does is documented here: #5552

TL;DR, for beginners who don't know how to please the compiler with indent/outdent rules, this is the best way to do it without getting yelled at by an IDE:

type MyRecord =
    {
        SomeField : int
    }
    interface IMyInterface

@vasily-kirichenko's suggestion is what you'll likely find the most online, which is a virtue. But so is recommending something that is as resilient as possible. The current section shows neither, so I think either of these is an improvement.

[matthid]

@cartermp Yes good feedback and indeed something we want to fix. The syntax you suggest seems the most F# "untypical" of all the suggestions to me as it uses a lot of "blank lines" and noise. Shouldn't we try to improve our tooling instead?

[matthid]

We could also go:

type Record =
    {   clients: int
        field: string }
    member x.MyField = x.field

type Record =
<i  >{<i-1>clients: int
<i  ><i   >field: string }
<i  >member x.MyField = x.field

which I guess would fix this problem as well. But this is never seen anywhere at the moment (or at least I have never seen it).

[AnthonyLloyd]

3 means cleaner git diffs while saving vertical space and having simpler horizontal spacing.

[pblasucci]

In my experience, only two forms work "at scale": the one @vasily-kirichenko suggests (my personal favorite) and the 3rd choice from the original listing. I'd vote for either of those. Note, also, @vasily-kirichenko suggestion works best for _record instances_ (in case having symmetry between definition and instantiation is important).

[AnthonyLloyd]

3's instances are consistent:

let empty = {
    Field1 = 1
    Field2 = "hi"
}

can also be consistent with list / array style:

div [
    firstThing prop1 [
        innerThing prop2 prop3
        inneIinnerThing prop4 prop5 [
            deepThing noProp
        ]
    ]
    secondThing prop6 [
        lastThing prop7 prop8
    ]
] 

as the first can:

div
  [ firstThing prop1
      [ innerThing prop2 prop3
        innerThing prop4 prop5
          [ deepThing noProp  ]  ]
    secondThing prop6
      [ lastThing prop7 prop8  ]  ]

[matthid]

Added a suggestion PR https://github.com/dotnet/docs/pull/6956, which tries to capture this discussion