Perché i letterali di tabella sono trattati in modo diverso dai riferimenti di tabella in Lua?

Question

Ecco una Lua 5.2.2 trascrizione, che mostra la dichiarazione e l'indicizzazione di una tabella:

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

Perché non è la seguente dichiarazione legale?

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

non posso pensare di qualsiasi altra lingua in cui un letterale non può essere sostituito per un riferimento (ad eccezione, ovviamente, quando è necessario un lvalue).

FWIW, mettere tra parentesi la tabella letterale rende la dichiarazione legale:

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

Answer 1

'anche in relazione al fatto che in Lua questa sintassi è valida:

myfunc { 1, 2, 3 } 

ed è equivalente a:

myfunc({ 1, 2, 3 }) 

Pertanto un'espressione quale:

myfunc { 1, 2, 3 } [2] 

viene analizzato come:

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

quindi prima chiamata di funzione viene valutata, quindi l'indicizzazione avviene.

Se {1,2,3}[2] può essere analizzato come operazione di indicizzazione valida, potrebbe portare a delle ambiguità nell'espressione precedente che richiederebbero più lookahead. Il team Lua ha scelto di rendere veloce il compilatore bytecode Lua rendendolo un compilatore a passaggio singolo, quindi esegue la scansione del codice sorgente solo una volta con un minimo di lookahead. This message to lua mailing list from Roberto Ierusalimschy (lead Lua developer) punti in quella direzione.

Lo stesso problema esiste per stringhe letterali e chiamate di metodo. Questo non è valido:

"my literal":sub(1) 

ma questo è valido:

("my literal"):sub(1) 

Anche in questo caso, Lua permette questo:

func "my literal" 

equivalenti al presente:

func("my literal") 

Answer 2

Andando della grammatica definita here, la ragione per cui la versione non tra parentesi è valido ancora la parentesi è, è perché l'albero di sintassi prende un percorso diverso e si aspetta una parentesi di chiusura ) perché ci dovrebbe non essere un altro simbolo in quel contesto.

Nel primo caso:

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 ')' 

D'altra parte con parentesi:

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)