F# style guide question - Space before parenthesis in pattern in F# code

[nojaf]

Hello @dsyme,

Should there be a space after a pattern (SynPat.LongIdent if you will) that has a parenthesis argument.

match x with
// with a space
| Foo (a, b) -> ()
// without a space
| Bar(c,d,e) -> ()

//cc @auduchinok

---

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: dotnetcontent

---

Associated WorkItem - 496845

[auduchinok]

I've seen some projects preferring not to have the space, so I think having this as a Fantomas setting would be good.

The defaults have to be chosen carefully, though.
Does it have to mimic expressions, where space is added based on the name? Union cases and active patterns always start with uppercase, and these currently are the only patterns that may have parameters.

match Some(1, "") with
| Some(a, b) -> ()
| Some (a, b) -> ()

[dsyme]

Should there be a space after a pattern (SynPat.LongIdent if you will) that has a parenthesis argument.

I believe we have to prefer consistency and have the default settings should be identical to expressions, so if expressions are set to format like this:

SomeUpperCaseFunction(a, b)   // expression
SomeType(a, b)   // expression
Some(a, b)   // expression
SomeCurriedThing arg (a, b)   // expression

then patterns format similarly:

| Some(a, b) ->  // pattern
| SomeActivePattern arg (a, b) ->  // active pattern with parameter

The value of consistency seems just too high to do much else.

That said I personally prefer expression formatting where single identifier upper case identifiers get spaces just like lower case, e.g.

SomeType.Method(a,b) // two identifiers in dot notation, uppercase last = method

Some (a, b)   // expression

| Some (a, b) ->  // pattern

But that would be up to me to advocate such a separate rule for expressions - and again for patterns the key thing is consistency I think.

As an aside I also remove parentheses for single atomic arguments, e.g. as follows, though that's somewhat orthogonal and Fantomas currently preserves whatever is in the source code:

SomeType "abc"
SomeType.Method "abc"
someObject.Method "abc"

Some "abc"   // expression

| Some "abc" ->  // pattern

[nojaf]

From a Fantomas point of view, it feels like we can re-use the settings fsharp_space_before_uppercase_invocation and fsharp_space_before_lowercase_invocation to determine if there should be a space or not.

That said I personally prefer expression formatting where single identifier upper case identifiers get spaces just like lower case

This was suggested in the past before (at Fantomas side) but again might not cover all cases.
If you have something like:

[<RequiredQualifiedAccess>]
type SomeType=
    | Method of string * string

let a = SomeType.Method (a, b) // would you want the space here? As DU are an F# thing, maybe you do.

[dsyme]

From a Fantomas point of view, it feels like we can re-use the settings fsharp_space_before_uppercase_invocation and fsharp_space_before_lowercase_invocation to determine if there should be a space or not.

Yes, you should reuse whatever settings are used for expression formatting.

This was suggested in the past before (at Fantomas side) but again might not cover all cases.

Agreed it doesn't cover that case (and not proposing that we should)

[BillWagner]

As noted, the F# style should not recommend different styles for patterns and expressions. This article should clearly state that the recommended F# style places a high value on consistency (per @dsyme 's comments). Therefore, the additional spaces aren't recommended.