Comportamento di carico() quando la funzione pezzo ritorna nil

Question

Dal Lua 5.1 documentation for load():

carichi un pezzo utilizzando la funzione func per ottenere i suoi pezzi. Ogni chiamata a func deve restituire una stringa che concatena con i risultati precedenti. Un ritorno di una stringa vuota, nil, o nessun valore indica la fine del blocco.

Dal mio test, questo non è effettivamente vero. O, piuttosto, la documentazione è almeno fuorviante.

considerare questo script di esempio:

function make_loader(return_at) 
    local x = 0 

    return function() 
     x = x + 1 

     if x == return_at then return 'return true' end 

     return nil 
    end 
end 

x = 0 
repeat 
    x = x + 1 
until not load(make_loader(x))() 

print(x) 

L'uscita è il numero di chiamate successive alla funzione restituita da make_loader() che ha restituito nil prima load() dà e restituisce una funzione che restituisce nulla.

Uno si aspetterebbe che l'output qui sia "1" se la documentazione deve essere presa al valore nominale. Tuttavia, l'output è "3". Ciò implica che l'argomento load() viene chiamato finché non restituisce niltre volte prima che load() si arrenda.

D'altra parte, se la funzione di blocco restituisce immediatamente e poi nil sulle chiamate successive una corda, ci vuole solo un nil Per interrompere il caricamento:

function make_loader() 
    local x = 0 

    return { 
     fn=function() 
      x = x + 1 

      if x == 1 then return 'return true' end 

      return nil 
     end, 
     get_x=function() return x end 
    } 
end 

loader = make_loader() 
load(loader.fn) 
print(loader.get_x()) 

Questo stampa "2" come mi sarei aspettato.

Quindi la mia domanda è: la documentazione è sbagliata? Questo comportamento è desiderabile per qualche motivo? È semplicemente un bug in load()? (Sembra apparire intenzionale, ma non riesco a trovare alcuna documentazione che spiega perché.)

Answer 1

Questo è un bug in 5.1. È stato corretto in 5.2, ma non è stato possibile incorporare la correzione in 5.1.

Answer 2

ottengo risultati leggermente diversi dal vostro, ma sono ancora non del tutto ciò che la documentazione implica:

function make_loader(return_at) 
    local x = 0 
    return function() 
     x = x + 1 
     print("make_loader", return_at, x) 
     if x == return_at then return 'return true' end 
     return nil 
    end 
end 

for i = 1, 4 do 
    load(make_loader(i)) 
end 

Questa operazione riporta la seguenti risultati:

make_loader 1 1 
make_loader 1 2 
make_loader 2 1 
make_loader 2 2 
make_loader 2 3 
make_loader 3 1 
make_loader 3 2 
make_loader 4 1 
make_loader 4 2 

Per 1 da essere chiamato due volte, perché il primo era return true e la seconda pari a zero. Per 2 viene chiamato tre volte perché il primo era nil, quindi return true e quindi nil nuovamente. Per tutti gli altri valori è chiamato due volte: sembra che il primissimo nil sia ignorato e la funzione venga chiamata almeno un'altra volta.

Se è davvero così, la documentazione deve riflettere questo. Ho guardato il codice sorgente, ma non ho visto nulla che potesse spiegare perché il primo restituito nil viene ignorato (ho anche provato con una stringa vuota e nessun valore con lo stesso risultato).