Hi Jochen,

yes newline is a whitespace in Groovy, but not every whitespace is a newline. For me that is why Daniel's Ruby counter-example does not fit in my case, since a newline is much more visible than a space (or tab). Answering "how likely is something" with "in [0,1]" is always correct, yes. But have you (or anyone else on this list) ever seen an index access that goes over multipe lines ?

It is about the example I gave (which is actually from a Groovy test I am working on), not about println, and the method accepting the List is not always under your control, so changing it to accepting Object... instead is not always possible (also what if someone has a List, then he has to convert it to an Object array).

In your println example, why would people not assign the list to a variable - since it is now used 2x that makes sense, also with regard to the classic error of not updating what you print in relation to what you return from the method.

I would also require one or more space or tab characters after the "list" in your multiline example, i.e.

// Compiles to list([0])
list [
  0
]

instead of

// Does not compile
list[
  0
]

Cheers,
mg



On 06.04.2018 23:29, Jochen Theodorou wrote:
On 06.04.2018 21:21, MG wrote:
My suggestion was not to consider allowing any whitespace to break syntax ambiguity here, but only a newline after the opening square bracket, i.e.:

whitespace in terms of the groovy grammar includes newline usually.

// Still does not compile
final result = foo [ "some rather long literal string argument",
     "another long literal string argument",
     "and so on and so forth...",
]

// Parsed as foo([ ... ])  (not foo-index-access)
final result = foo [
      "some rather long literal string argument",
     "another long literal string argument",
     "and so on and so forth...",
]

so you want

list[0]

keep as is now and

list[
  0
]

be instead list([0])?

If the parser can do it, it would feel Groovy to me to allow it for this use case (Of course it could still mean "index access", but how many people would really write an index access on foo that way ?).

asking "but how many people would" is always to be answered with "potentially many"

Groovy 3.0 is the place to ponder such questions, imho, because breaking changes will come anyway afaiks (Java 9 modules), so you do it here, or not for a long time...

Would be interested what others think, or if someone has a counter example that makes it clear it is a bad idea to go down that route,

why not use

final result = foo (
     "some rather long literal string argument",
     "another long literal string argument",
     "and so on and so forth..."
)

instead and make foo use Object...? The real problem is a different one imho.

people try things and start debugging code with println. They have for example

return [x,y]

and change this now to

println [x,y]
return [x,y]

or log it...

Obviously they started with a list and do not want indexing at all. They want the method call variant you propose. But in my experience this has really been the only case where it plays a role. And I think to give it up just because of that... give up I mean because I prefer having to write println([x,y]) to simulate the method call, than having to write... println.getAt([x,y]) to simulate the index. Especially since the later requires people to actually now the method name used for the index operation, which in most cases, they will not care about really. And do you really want to write

println [
 x,y]

to get a method call?

bye Jochen


Reply via email to