Why are table literals handled differently than table references in Lua?

Question

Here is the Lua 5.2.2 decryption showing the declaration and indexing of the table:

> mylist = {'foo', 'bar'} > print(mylist[1]) foo 

Why is the expression not legal?

 > print({'foo', 'bar'}[1]) stdin:1: ')' expected near '[' 

I can’t think of any other language where a literal cannot be replaced by a reference (except, of course, when lvalue is required).

FWIW, enclosing a table literal in parentheses, makes the statement legal:

 > print(({'foo', 'bar'})[1]) foo 

Answer 1

This is also due to the fact that in Lua this syntax is valid:

 myfunc { 1, 2, 3 } 

and this is equivalent to:

 myfunc( { 1, 2, 3 } ) 

Therefore, an expression such as:

 myfunc { 1, 2, 3 } [2] 

analyzed as:

 myfunc( { 1, 2, 3 } )[2] 

therefore, the function call is first computed, then indexing is performed.

If {1,2,3}[2] can be analyzed as a valid indexing operation, this can lead to ambiguity in the previous expression, which will require more attention. The Lua team decided to quickly make the Lua bytecode compiler, making it a single-skip compiler, so it scans the source code only once with minimal viewing. This message to the lua mailing list from Roberto Hierasulsky (Lua lead developer) points in that direction.

The same problem exists for string literals and method calls. This is not true:

 "my literal":sub(1) 

but this is true:

 ("my literal"):sub(1) 

Again, Lua allows this:

 func "my literal" 

equivalent to this:

 func( "my literal" ) 

Answer 2

According to the grammar defined here , the reason the version with the unconverted version is invalid but enclosed in brackets is because the syntax tree takes a different path and expects closing brackets ) because there should not be another character in this context.

In the first case:

 functioncall ::= prefixexp args | prefixexp `:´ Name args prefixexp => prefixexp ::= var | functioncall | `(´ exp `)´ var -> print THEREFORE prefixexp -> print args => args ::= `(´ [explist] `)´ | tableconstructor | String match '(' explist => explist ::= {exp `,´} exp exp => exp ::= nil | false | true | Number | String | `...´ | function | prefixexp | tableconstructor | exp binop exp | unop exp tableconstructor => explist-> {'foo','bar'} THEREFORE explist = {'foo','bar'} match ')' ERROR!!! found '[' expected ')' 

On the other hand, with parentheses:

 functioncall ::= prefixexp args | prefixexp `:´ Name args prefixexp => prefixexp ::= var | functioncall | `(´ exp `)´ var -> print THEREFORE prefixexp -> print args => args ::= `(´ [explist] `)´ | tableconstructor | String match '(' explist => explist ::= {exp `,´} exp exp => exp ::= nil | false | true | Number | String | `...´ | function | prefixexp | tableconstructor | exp binop exp | unop exp prefixexp => prefixexp ::= var | functioncall | `(´ exp `)´ var => var ::= Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name prefixexp => prefixexp ::= var | functioncall | `(´ exp `)´ match '(' exp => exp ::= nil | false | true | Number | String | `...´ | function | prefixexp | tableconstructor | exp binop exp | unop exp tableconstructor => THEREFORE exp = {'foo','bar'} match ')' THEREFORE prefixexp = ({'foo','bar'}) match '[' exp => Number = 1 match ']' THEREFORE VAR = ({'foo','bar'})[1] THEREFORE prefixexp = VAR THEREFOER exp = VAR THEREFORE explist = VAR match ')' THEREFORE args = (VAR) => print(VAR)