make `f (a,b)` an error

[StefanKarpinski]

See https://groups.google.com/forum/#!topic/julia-users/ysc9loSduN0

We would want to make it a warning first, then an error later on.

[goszlanyi]

This would be a future-proof decision.

[stevengj]

It seems odd to me to disallow this. Has there ever been a programming language that disallowed whitespace before parentheses in function calls?

There are certainly people out there who habitually put spaces between the function and arguments; e.g. the GNU Coding Standards recommends this ("We find it easier to read a program when it has spaces before the open-parentheses and after the commas."), although that style always felt weird to me.

[BobPortmann]

It seems to me that the problem in the link above is not that function calls allow an optional space, but that macro calls consider the parens optional. If macro calls forced the parens then there would be no ambiguity between @printf("%f",42.0) and @printf ("%f",42.0). With the present system the 1st is a macro call with two inputs and the 2nd is a macro call with one tuple as input.

Note that I hate the f (a,b) style, but it feels a bit extreme to exclude it.

[stevengj]

Requiring parens in a macro call would be a major change, and would change the flavor of the language somewhat. The optional parens in a macro call allow the macro calls to look more like syntax and less like function calls. e.g. @inbounds and @parallel and so forth would be a lot uglier with parens.

[goszlanyi]

Macros without parentheses
and function calls with parentheses but no space before them
seems to be a good balance to me.

[StefanKarpinski]

Title changed to reflect the bigger issue.

[StefanKarpinski]

We could, deprecate the @f (a,b) syntax for a while and then change it to mean @f(a,b) and require people to write @f((a,b)) if they really want to pass a tuple to a macro, but that feels pretty awkward for macros – sometimes you want to just pass a tuple to a macro. The style of writing f (a,b) is really awful, imo, and if getting rid of that is the cost we pay to avoid confusion but still allow easily passing tuples to macros, I'm ok with that.

[nalimilan]

+1

It will also help enforcing a common coding style.

[JeffBezanson]

I'm ok with disallowing f (x). The macro thing is a bit of a distraction; one more serious issue is the difference between f (x) and [f (x)]. If you're in the habit of writing the extra space, adding square brackets doesn't do what you'd expect.

[porterjamesj]

+1 for disallowing

[vtjnash]

julia is more space-sensitive than many other languages, so I think think is very reasonable

[StefanKarpinski]

There has to be a pretty long deprecation period because a lot of people have code that looks like this.