Allow juxtaposition of macro and array literal. fixes #23519

[cdsousa]

This is an attempt to implement what I have suggested in #23519:
interpret @foo[1, 2, 3] as @foo([1, 2, 3]).

I have almost (now) zero knowledge of scheme, so pardon me if the implementation is too wrong.
It seems to work ok in many situations, but it doesn't have any test yet.

[JeffBezanson]

Implementation looks fine to me.

[ararslan]

What you've noted in the docs, that @m[x] * v is not the same as @m [x] * v implies to me that this will introduce another subtle "gotcha" for macro invocations. The fact that omitting a space changes the meaning in a subtle way is concerning. Is it really so onerous to use @m([x])?

[cdsousa]

Yes, unfortunately, it adds yet another gotcha, along with @m(1,2) vs. @m (1,2), but it is somehow of the same type and thus hopefully easier to remember...

From my experience, my brain defaults to already interpret @m[x] * v as applying only to [x] although it has never been the case. That was the reason which triggers me to open the issue in the first place.

This desire for a lightweight syntax for "non-standard array literals" comes mainly from static arrays, where, possibly unlike to other custom arrays, it is very common to need small literal arrays with constructors as performant as possible. Indeed StaticArrays is all about the performance of small matrices where stuff like construction, indexing, etc. (and their optimization/inlining) tends to be as much important as matrix algebra and iteration. Also, array literals (excluding concatenations and comprehension) are used almost always for small matrices!

Many discussions have been taken about a more lightweight syntax for custom array literals (notice that array elements don't have to be literal numbers). I referred some in #23519, and another important one happens JuliaArrays/StaticArrays.jl#24 .

The syntax change I'm proposing is a very low-hanging fruit for "something reasonabe".
Having it will readily allow StaticArrays users to simply prefix arrays/vectors/matrices literals with @SArray (or something like @SA) and instantly get small static arrays with types and sizes resolved at compile time solely from the literal.
Maybe, StaticArrays developers, @andyferris, @SimonDanisch, and others (I'm merely a user), can also have something to say here.

[cdsousa]

Rebased.

[cdsousa]

Some people have shown dislike and some people have shown sympathy for this change, both here and in the issue (#23519). How usually are these cases resolved? I think that it is better to either merge or reject the PR, right?

[andyferris]

It can sometimes be a slow process, @cdsousa.

If you want resolution, I'll add some labels which means it will be picked up by what's being called the "triage" process.

[martinholters]

@ararslan The fact that

@m[x] * v is not the same as @m [x] * v

doesn't seem worse than the fact that @m([x]) * v is not the same as @m ([x]) * v to me.

[JeffBezanson]

Needs news, then I will merge this.