Review long function definitions

[nojaf]

I propose that Fantomas formats long function definitions by default as described by the Microsoft style guide and place the GR style behind a setting.

The existing way of Fantomas deals with this problem is using the G-Research style guide.

Pros and Cons

The advantages of making this adjustment to Fantomas are that we respect both style guides.

The disadvantages of making this adjustment to Fantomas are an extra setting to maintain.

Examples

Please provide multiple examples (before and after scenarios) and explain what rules did apply to achieve the outcome.

Microsoft:

let fold (funcs: ResultFunc<'Input, 'Output, 'TError> seq)
         (input: 'Input)
         (input2: 'Input)
         (input3: 'Input)
         : Result<'Output list, 'TError list> =
    ()

G-Research

let fold
    (funcs: ResultFunc<'Input, 'Output, 'TError> seq)
    (input: 'Input)
    (input2: 'Input)
    (input3: 'Input)
    : Result<'Output list, 'TError list>
    =
    ()

Extra information

Estimated cost: S

Related suggestions: #935, #492, #769

Affidavit (please submit!)

Please tick this by placing a cross in the box:

• I have searched both open and closed suggestions on this site and believe this is not a duplicate

Please tick all that apply:

• This is not a breaking change to Fantomas
• I or my company would be willing to help implement and/or test this
• This suggestion is part of the Microsoft style guide (please add a link to section if so)
• This suggestion is part of the G-Research style guide (please add a link to section if so)

[nojaf]

@Smaug123 @JackMatusiewiczGR suggestions for a setting name are welcome.
I'm currently thinking about AlternateLongFunctionSignature as boolean.

[Smaug123]

I think AlignFunctionSignatureToIndentation is more descriptive (as opposed to "align function signature to first parameter").

[auduchinok]

What about using a different (well, third already) approach: do double indent for signature continuation and then a single indent for the right-side block?

let internal UpdateStrongNaming (assembly: AssemblyDefinition)
        (key: StrongNameKeyPair option) =
    assembly.Name

I've initially seen this style in Kotlin and really like how it fits in various F# parts too, e.g:

match foo with
| Some x when
        someExpressionHere ||
        andAnotherOne ->
    printfn "%O" x
| _ -> ()

[nojaf]

Hmm, I'm not entirely convinced here. I feel like the alignment of the parameters we currently have in the other styles is more readable, to be honest.
Maybe I'll reconsider in the future but I'd like to wrap up 4.0 so this is not something I want to wait for.

[auduchinok]

Making it double-indent makes it consistent regardless of what was on the previous line, so in this particular case it doesn't matter how long the function name is, you'll see the next parameters at the same indent in any case (and most likely will have much more space in the line left).

[nojaf]

it doesn't matter how long the function name

This is what the GR style guide proposes, regardless of the name the indent will be one in this case.
And the equal sign is on its own line so that makes it clear when the function body is starting.