Por que “setf” não funciona ao usar “let”?

Common Lisp é uma das primeiras linguagens a exibir call-by-sharing , um paradigma que agora é extremamente comum em linguagens de programação de tipo dinâmico e de nível superior. Em uma linguagem de chamada por compartilhamento, os valores vinculados a uma variável passam implicitamente por uma espécie de cópia superficial, pegando uma nova versão do ponteiro ou dos dados superiores, mas deixando quaisquer dados aninhados idênticos.

Em um Lisp, essa distinção é realmente mais fácil de ver. A célula cons de nível superior é copiada, mas quaisquer ponteiros aninhados são deixados de lado.

(defun to-temp-field (lst)
  (let ((old-value (nth 2 l))
        (new-value 'hello))
    (progn
      (setf old-value new-value)
      lst)))

Aqui, nãoold-value há referência a uma posição na lista. É uma cópia superficial do valor na posição 2 da lista. Conforme indicado na resposta de khachik, na verdade é apenas uma macro muito complicada, e as macros despacham seu comportamento de acordo com a sintaxe que veem. Então, o que é visto como seu primeiro argumento é . Isso está acontecendo em tempo de compilação, então não tem como saber se veio de uma lista, ou de uma chamada, então basta definir a variável local (usando basicamente ).setfsetfold-valuesetfold-valuenthsetq

Agora, considere seu segundo exemplo,

(defun to-temp-field (lst)
  (let ((new-value 'hello))
    (progn
      (setf (nth 2 lst) new-value)
      lst)))

Aqui, setfvê (nth 2 lst)como seu primeiro argumento. Esta não é uma variável local. Na verdade, esta é uma expressão semelhante a uma chamada de função. E como podemos ver no hyperspec , nthna verdade tem duas entradas: uma para uma chamada de função normal e outra para quando é usada em setf. Isso porque, assim como podemos definir funções normais como

(defun nth (n lst)
  ...)

Podemos definir separadamente um setfacessador como

(defun (setf nth) (n lst)
  ...)

Isso não é pseudocódigo. defunna verdade, aceita (setf whatever)como um nome de função declarado válido e, quando você usa setfem uma chamada de função, a macro procura uma função com esse nome.

setfpega um lugar e um valor, ou uma série de pares de lugar/valor, e altera o valor do lugar para o novo valor.

No primeiro exemplo de código old-valuehá uma variável lexical vinculada ao letformulário. Variáveis ​​lexicais são lugares , então chamar (setf old-value new-value)define o valor de old-valueto new-value.

Os formulários de função também podem ser locais e nthé uma função que pode especificar um local. No segundo exemplo de código, a chamada (setf (nth 2 lst) new-value)define o valor do local (nth 2 lst)como valor new-value.

Assim no primeiro exemplo o place old-value, uma variável lexical, é atualizado, enquanto no segundo exemplo o place (nth 2 lst), um elemento da lista lsté atualizado.

Algumas coisas a serem observadas:

• O segundo exemplo atualiza o terceiro elemento, lstuma vez que as listas são indexadas em zero no Common Lisp.

• Não há necessidade do prognformulário dentro de let, pois o corpo de um letformulário é implícito progn.

• A tentativa de modificar um literal causa um comportamento indefinido no Common Lisp, então você não deve chamar a segunda função com uma lista entre aspas como esta: (to-temp-field '(1 2 3))ou com uma variável vinculada a uma lista literal, mas sim assim: (to-temp-field (list 1 2 3))ou com uma variável vinculada a um lista que foi recentemente construída.

setfé uma macro que, simplesmente, entende o que está sendo definido e chama o conjunto correspondente com base nisso, então (setf old-value new value)simplesmente define o valor, enquanto no segundo caso ele se comporta conforme o esperado.

setfé uma macro e faz coisas completamente diferentes quando o primeiro argumento é um símbolo do que algum acessador para uma estrutura de lista.

É muito fácil ver que quando você fornece um símbolo, ele faz algo completamente diferente do que se você fornecesse o nthformulário:

> (get-setf-expansion '(setf (nth 2 lst) new-value))
(#:TEMP-2859 #:TEMP-2858 #:TEMP-2857) ;
(2 LST NEW-VALUE) ;
(#:NEW-2856) ;
(FUNCALL #'(SETF SYSTEM::%SETNTH) #:NEW-2856 #:TEMP-2859 #:TEMP-2858 #:TEMP-2857) ;
(SYSTEM::%SETNTH #:TEMP-2859 #:TEMP-2858 #:TEMP-2857)

>  (macroexpand-1 '(setf (nth 2 lst) new-value))
(SYSTEM::%SETNTH 2 LST NEW-VALUE) ;
T

A última linha que você vê chama internal function %setnth. Isso é específico da implementação, então o SBCL faz outra coisa. No entanto; Isso claramente busca o local e faz o mesmo que (rplaca (cddr lst) new-value)quando você armazenou em cache o valor de (nth 2 lst)to old-value:

$(get-setf-expansion '(setf old-value 99))
(#:TEMP-3005 #:TEMP-3004) ;
(OLD-VALUE 99) ;
(#:NEW-3003) ;
(FUNCALL #'(SETF SETQ) #:NEW-3003 #:TEMP-3005 #:TEMP-3004) ;
(SETQ #:TEMP-3005 #:TEMP-3004)

> (macroexpand-1 '(setf old-value 99))
(SETQ OLD-VALUE 99) ;
T

Isso setqapenas religará a variável local old-valuepara apontar para 99. Você não pode armazenar em cache o local antigo, pois a macro não o compreenderá mais.