Lambda functions in fluent API calls should indent further

[reinux]

I propose we ... indent lambda functions in fluent API calls further.

Examples

Currently, it looks something like this:

something.Add(fun x ->
         x.a <- 1
         x.b <- 2)
         .Add2(fun y ->
         y.a <- 3
         y.b <- 4)

Or in a more practical scenario:

  services.AddAuthentication(fun options ->
          options.DefaultScheme <- "Cookies"
          options.DefaultChallengeScheme <- "oidc").AddCookie("Cookies")
          .AddOpenIdConnect(fun options ->
          options.Authority <- "http://localhost:7001"
          options.ClientId <- "mvc"
          options.ClientSecret <- "secret"
          options.ResponseType <- "code"
          options.SaveTokens <- true)

.AddOpenIdConnect and .AddAuthentication have the same indentation as the content of the function, which makes it harder to understand where the first call ends.

The indentation is nicer when the inner expression is a record, which I think should be a similar scenario visually:

something2.Add({ a_really_long_name = 1
                 another_really_long_name = 2 })
          .Add({ a_really_long_name = 3
                 another_really_long_name = 4 })

I think it should look like either:

something
    .Add(fun x ->
        x.a <- 1
        x.b <- 2)
    .Add2(fun y ->
         y.a <- 3
         y.b <- 4)

services
    .AddAuthentication(fun options ->
        options.DefaultScheme <- "Cookies"
        options.DefaultChallengeScheme <- "oidc").AddCookie("Cookies")
    .AddOpenIdConnect(fun options ->
        options.Authority <- "http://localhost:7001"
        options.ClientId <- "mvc"
        options.ClientSecret <- "secret"
        options.ResponseType <- "code"
        options.SaveTokens <- true)
 |> ignore

or:

something.Add(fun x ->
            x.a <- 1
            x.b <- 2)
         .Add2(fun y ->
            y.a <- 3
            y.b <- 4)

services.AddAuthentication(fun options ->
            options.DefaultScheme <- "Cookies"
            options.DefaultChallengeScheme <- "oidc").AddCookie("Cookies")
        .AddOpenIdConnect(fun options ->
            options.Authority <- "http://localhost:7001"
            options.ClientId <- "mvc"
            options.ClientSecret <- "secret"
            options.ResponseType <- "code"
            options.SaveTokens <- true)
 |> ignore

Pros and Cons

Pros:

• Easier to see how expressions are nested

Cons:

• May need to move indentation back past the dot on the outer expression
• Otherwise the call may get too long horizontally

Extra information

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

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]

At first glance, this is ok to have.
I'm not sure what the impact would be for implementing this though.
Chances are the formatting of the lambda is something common and could impact other areas as well.
This should be investigated.

[reinux]

I see what you mean.

services.AddHttpsRedirection(Action<HttpsRedirectionOptions>(fun options ->
    options.HttpsPort <- Nullable(7002)
)) |> ignore

will end up becoming

services.AddHttpsRedirection(Action<HttpsRedirectionOptions>(fun options ->
          options.HttpsPort <- Nullable(7002)
)) |> ignore

Which is a bit jarring.

Maybe it should only apply when it's otherwise aligned with the dot. It only really looks weird when it's aligned, so that might work.

Not sure how easy that is to check for.

[nojaf]

Hey @reinux, while solving #1202 I saw an opportunity to improve the indentation of lambdas.
See 7f6a833

[reinux]

Nice! Thanks!