Reinicialização adequada de uma lista? O que está acontecendo sob o capô?

Estou me ensinando um pouco mais sobre elisp e encontrei o seguinte problema:

Se eu quiser redefinir uma variável de lista, ela não será atualizada após a primeira avaliação. Aqui está um exemplo de código:

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

Estou interessado em duas coisas. A primeira é aprender mais sobre o que está acontecendo "oculto", então por que funciona pela primeira vez e falha nas chamadas subseqüentes?

A segunda e mais prática questão é como reinicializar a lista corretamente ou existe outra maneira comum de fazer algo assim?

Uma solução alternativa que encontrei é usar uma lista citada e avaliar o conteúdo assim:

(setq example `(,3)) 

Talvez isso esclareça parte da confusão:

• Sua função initilizenão inicializa variável example. Ele o define como uma célula de contras específica - a mesma célula de contras cada vez que é chamada. Na primeira vez que initilizeé chamado, ele setqatribui examplea uma nova célula de contras, que é o resultado da avaliação '(3). Chamadas subsequentes para initilizereatribuir exampleà mesma célula de contras.

• Como initilizeapenas reatribui a mesma célula de contras example, modifyapenas define o carro dessa mesma célula de contras a 2cada vez que é chamada.

• Para inicializar uma lista, use listou cons(ou um sexp equivalente de uma cota posterior, como `(,(+ 2 1))ou `(,3)). Por exemplo, use (list 3).

A chave para entender isso é saber que uma célula de contras citada é avaliada apenas uma vez e, em seguida, a mesma célula de contras é retornada. Não é necessariamente assim que todos os Lisps se comportam, mas é como o Emacs Lisp se comporta.

De um modo mais geral, o comportamento de avaliar um objeto mutável citado depende da implementação, se não da linguagem. No Common Lisp, por exemplo, tenho certeza de que não há nada na definição (especificação) da linguagem que defina o comportamento a esse respeito - isso fica por conta da implementação.

Resumo: Não espere que '(alguma lista) seja igual a' (alguma lista) - sempre. Geralmente, não há garantia no Lisp de que o código que cita visivelmente uma lista retorne sempre uma nova estrutura de lista. Em algumas implementações do Lisp, pode ser, ou pode ser por algumas vezes. Em outros, isso nunca acontece. De qualquer forma, seu código não deve depender de nenhum comportamento da implementação. Se você deseja uma nova estrutura de lista, use listou consou equivalente.

Você pode usar (setq example (list 3))para evitar esse erro.

O que acontece é initatribui um objeto que inicialmente contém (3)a example. Ele define o valor do objeto apenas uma vez. Posteriormente, você modifica esse valor.

Aqui está o seu exemplo em C ++, se você entender isso melhor:

#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;
}