How to deal with spaces inside of parens

[avh4]

Parens are used in many different ways. Should the same rule apply to all? What should the rules be?

module Main (parens, here, And(Here)) where

import Foo exposing (moreParens, More(..))

type MyType
    = A (Int, Float)

fn (tuple,pattern) =
    (1, 2, 3)
        |> (\(a, b, c) -> a)
        |> (+) 10

[avh4]

@Apanatshka:

I don’t know what to think of removing the spaces between the round brackets and the imports in the list.

@rtfeldman:

The rule of thumb that I've followed is "spaces for data structures" - e.g.

{ foo = 1, bar = 2 }
[ foo, bar ]
( foo, bar )

...but not

(foo bar)
(foo == bar)

However, I wonder if a simpler rule might be "spaces if there are commas" - in other words, all of the above cases plus import lists.

From an end user perspective, I like the simplicity of that rule. Thoughts?

[Apanatshka]

I think the best way to resolve this is to try some different options.

[rtfeldman]

Since we need to pick one to start, I'd say let's start with "spaces if there are commas," in other words:

( foo, bar )
(foo bar)
(foo == bar)

...or perhaps more precisely "spaces if there could be commas," so in other words:

import Foo exposing ( bar )
import Bar exposing ( baz, qux )

I've never tried that style with imports, but at first glance I like how it looks!

[avh4]

Okay, let's try @rtfeldman's most recent suggestion and see how it looks on real examples.

[avh4]

Another possibility could be: no spaces if the parens are within a single line, spaces if they span multiple lines, so:

module Foo (a, b) where

module Foo
    ( a
    , b
    ) where

(foo == bar)

( foo
    == bar
)

(foo, bar)

( foo
, bar
)

[rtfeldman]

I could see that, although I'd still keep the spaces for tuples in order to be consistent with the spaces lists and records have.

I do like tuples with spaces and function application without, because it helps distinguish the two in a more identifiable way at a glance than a tiny comma.

[avh4]

Will implement #20 for now.