Why don't people use white space inside parentheses? [closed]

Question

Clearly, this:

if( foo( 5, 6, 7 ))
  do_something( arr[ 5 ]);

if more readable than:

if (foo(5, 6, 7))
  do_something(arr[5])

yet very few people use whitespace inside their parens. The venerable indent program doesn't really provide useful options for this behavior (the option to include whitespace inside parens adds a space between consecutive occurrences, which is pretty hideous), and certainly some people will argue that it's a waste of horizontal space (but those same people would probably omit the spaces after the comma as well, so their opinion is clearly suspect), but surely there's some valid reason that this style is not more popular.

Why don't you use any whitespace inside your parentheses and/or braces?

Answer 1

It's clear to me that the only place you did not add whitespace is the only place I might - between the consecutive ones:

  if ( foo(5, 6, 7) )
    do_something(arr[5])

I'll only use whitespace with parens to break up a series of them to make matching easier.

Answer 2

I don't find it more readable at all. In fact, if you are passing a number of arguments, I'd argue the extra white space makes it less readable because it would be more spread out on the line and it could cause wrapping to become a bigger problem.

Answer 3

No, in your current form it is clearly less readable... It's harder to see where the parentheses start and end. Also, the outer parentheses of the statements have an inconsistent amount of spaces. Also, it seems unnatural that the parentheses are touching the if word.

With all these corrections, you are using way too much white space over the place and that would introduce characters shattered all over the place. Hence, the normal way tends to be more readable.

For long if conditions, the distance that you eyes have to travel even comes into play.

Answer 4

I don't use whitespace inside parentheses other than to separate arguments to function calls. However, I do add a whitespace between the parameter list and name of the function, i.e.: foo (a, b, c). Same with indexes into arrays (foo [index]). For me, this makes things a bit more readable. Here's a full example:

if ((a > b) || (d < e)) {
    foo (bar);
    i = f [index];
}

On a side note, I did write a project using the excess-whitespace approach:

if ( ( a > b ) || ( d < e ) ) {
    foo ( bar );
    i = f [ index ];
}

In retrospect, this didn't make the code more readable at all; in fact, it made it less readable since the entire code was usually equally spread out and made it hard to see what belonged with what. Also, it made lines too long and needed to wrap around on the next line, which further decreased readability.

Answer 5

I guess the problem is that it's not clear (to me at least). I find the second snippet much more readable.

I view the opening '[' as belonging to the index '5' - it looks weird (to me) pinned to the variable name and to the closing parenthesis instead of the index.

I was going to say that I like spaces after commas in parameter values, but you included those in both examples "foo( 5, 6, 7 )", and I fully agree that this convention is much easier to read than "foo(5,6,7)"

Answer 6

It makes it look like a list and not like function arguments. It takes you a second or two to realize its functions arguments with out the parenthesis right next to the numbers.