Reinizializzazione corretta di un elenco? Cosa sta succedendo sotto il cofano?

Mi sto insegnando un po 'più elisp e ho riscontrato il seguente problema:

Se voglio ripristinare una variabile di elenco, questa non verrà aggiornata dopo la prima valutazione. Ecco un esempio di codice:

(defun initilize ()
  (setq example '(3)))

(defun modify ()
  (initilize)
  (message "%S" example)
  (setcar example 2))

; M-x eval-buffer RET
(modify) ; message --> (3)
(modify) ; message --> (2)
(modify) ; message --> (2)

Sono interessato a due cose. Il primo è quello di saperne di più su ciò che sta accadendo "sotto il cofano", quindi perché funziona la prima volta e fallisce nelle chiamate successive?

La seconda e più pratica domanda è come reinizializzare correttamente l'elenco o c'è un altro modo comune di fare qualcosa del genere?

Una soluzione alternativa che ho riscontrato è utilizzare un elenco citato e valutare il contenuto in questo modo:

(setq example `(,3)) 

Forse questo chiarirà un po 'di confusione:

• La tua funzione initilizenon inizializza la variabile example. Lo imposta su una particolare cella contro - la stessa cella contro ogni volta che viene chiamata. La prima volta che initilizeviene chiamato, viene setqassegnato examplea una nuova cella contro, che è il risultato della valutazione '(3). Chiamate successive per initilizeriassegnare examplealla stessa cella di contro.

• Poiché initilizeriassegna semplicemente la stessa cella di contro example, modifyimposta semplicemente l'auto della stessa cella di contro 2ogni volta che viene chiamata.

• Per inizializzare un elenco, utilizzare listo cons(o un sexp di backquote equivalente, come `(,(+ 2 1))o `(,3)). Ad esempio, utilizzare (list 3).

La chiave per comprenderlo è sapere che una cella di contro quotata viene valutata una sola volta e, successivamente, viene restituita la stessa cella di contro. Questo non è necessariamente il modo in cui si comportano tutti i Lisps, ma è come si comporta Emacs Lisp.

Più in generale, il comportamento della valutazione di un oggetto mutabile quotato dipende dall'implementazione, se non dalla lingua. In Common Lisp, ad esempio, sono abbastanza sicuro che non ci sia nulla nella definizione (spec) del linguaggio che definisce il comportamento in questo senso - è lasciato all'implementazione.

Riepilogo: non aspettatevi mai "(un elenco) da eq a" (un elenco), mai. In genere, in Lisp non esiste alcuna garanzia che il codice che cita visibilmente un elenco restituisca ogni volta una nuova struttura di elenco. In alcune implementazioni Lisp potrebbe o potrebbe accadere qualche volta. In altri, non lo fa mai. Il codice non dovrebbe comunque dipendere da tali comportamenti dall'implementazione. Se si desidera una nuova struttura di elenco, utilizzare listo conso equivalente.

È possibile utilizzare (setq example (list 3))per evitare questo errore.

Ciò che accade è initcessionari un oggetto che inizialmente contiene (3)a example. Imposta il valore dell'oggetto solo una volta. Successivamente, si modifica questo valore.

Ecco il tuo esempio in C ++, se lo capisci meglio:

#include <stdio.h>
#include <string.h>
char* example;
char* storage = 0;
char* create_object_once (const char* str) {
  if (storage == 0) {
    storage = new char[strlen (str)];
    strcpy (storage, str);
  }
  return storage;
}
void init () {
  example = create_object_once ("test");
}
void modify () {
  init ();
  printf ("%s\n", example);
  example[0] = 'f';
}
int main (int argc, char *argv[]) {
  modify ();
  modify ();
  modify ();
  return 0;
}