In Scorri tutte le combinazioni di valori da un numero ARBITRARIO di liste Ho pubblicato una risposta che richiedeva l'inserimento di un elenco in un altro elenco di elenchi. La funzione InsertInto decomprime l'elenco inserito in elementi, che non è quello che voglio. Ho usato un'istruzione di assegnazione all'elemento uno oltre la fine dell'elenco, che inserisce l'elenco come elemento. Un'altra scelta è avvolgere l'elenco in un altro elenco prima di inserirlo (quindi decomprime l'elenco avvolto e inserisce l'originale).
C'è un modo migliore per inserire una lista in una lista? result e p sono entrambe liste.
risultato [ N articoli ( risultato ) + 1 ] = P è un po' prolisso ma funziona e sembra abbastanza chiaro che p viene memorizzato subito dopo l'ultimo elemento nell'elenco. Buono per l'estensione, ma non può essere inserito da nessun'altra parte.
risultato={"a"};
p={"b","c"};
risultato[N Elementi( risultato ) + 1] = p; // prolisso, ma l'intento è chiaro
mostra(risultato);
/*:
risultato = {"a", {"b", "c"}}; // Bene
Insertinto( risultato, p ) non funzionerà perché inserisce gli elementi di p, non p.
risultato={"a"};
p={"b","c"};
insertinto( risultato, p ) ; // sembra giusto, ma...
mostra(risultato);
/*:
risultato = {"a", "b", "c"}; // non quello che voglio
inserinto( risultato, evallist( { p } ) ) funziona, ma sembra meno leggibile del compito. Può inserire ovunque ma fa una copia extra.
risultato={"a"};
p={"b","c"};
insertinto( risultato, evallist( { p } ) ) ; // crea una copia extra dell'elenco e difficile da leggere
mostra(risultato);
/*:
risultato = {"a", {"b", "c"}}; // buono: quello che voglio
SÌ. Ho usato l'approccio evallist() e sento sempre che ha bisogno di un commento per spiegare. Nel mio codice originale (link in alto) continuo a cambiare p tra gli inserimenti, quindi non può semplicemente inserire un riferimento a p.
Potrei usarlo la prossima volta. Sembra più semplice, anche se utilizza una struttura dati più complicata (sotto le coperte), e poiché sto già generando un indice con nitems(...)+1 ... sì, potrebbe essere la scelta migliore.
Non è una soluzione diretta, ma più come soluzione tendo a utilizzare array associativi, simili a what @pmroz suggerito nel tuo link.
FWIW Lo faccio sempre nel modo EvalList ( ) nel tuo secondo esempio. Immagino che potresti farlo in questo modo, e non valutare fino a quando non vuoi / devi ... non sono sicuro che questo ti stia comprando molto (?)
result = {"a"};
p = {"b", "c"};
Insert Into( result, {p} ); //don't evaluate p here... but of course p is non-static
show(result[2][1]); //can still access elements of p if desired
Show( Eval List( result ) ); //or can eval to see the whole thing
