Como forço a reavaliação de um defvar?

Suponha que eu tenha um buffer lisp do Emacs que contenha:

(defvar foo 1)

Se eu ligar eval-last-sexpou eval-buffer, fooestiver vinculado a 1. Se eu editar esse buffer para:

(defvar foo 2)

eval-last-sexpe eval-buffernão reexecute esta linha, então fooainda é 1.

Isso é particularmente desafiador quando existem várias dessas declarações e eu tenho que rastrear quais linhas não estão sendo reavaliadas.

Eu olhei para reiniciar o Emacs e depois (require 'foo), mas tenho que ter cuidado para evitar o carregamento de arquivos .elc mais antigos.

Como posso ter certeza absoluta e positiva de que as variáveis ​​e funções definidas no arquivo atual estão no mesmo estado que o carregamento do código novamente em uma nova instância do Emacs?

Conforme explicado em outras respostas, a avaliação de um defvarformulário usando eval-last-sexpnão redefine o valor padrão.

Em vez disso, você pode usar eval-defun(vinculado a C-M-xin emacs-lisp-modepor padrão), que implementa o comportamento desejado como uma exceção especial:

Se o desfecho atual for realmente uma chamada para defvarou defcustom, a avaliação dessa forma redefinirá a variável usando sua expressão de valor inicial, mesmo que a variável já tenha algum outro valor. (Normalmente defvare defcustomnão altere o valor se já houver um.)

Se você precisar avaliar o conteúdo completo de um buffer, poderá escrever uma função que percorra os formulários de nível superior por vez e chame eval-defuncada um. Algo assim deve funcionar:

(defun my/eval-buffer ()
  "Execute the current buffer as Lisp code.
Top-level forms are evaluated with `eval-defun' so that `defvar'
and `defcustom' forms reset their default values."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (while (not (eobp))
      (forward-sexp)
      (eval-defun nil))))

Como as outras respostas dizem, é assim que o defvar funciona, mas você pode contornar isso, afinal é o elisp.

Você pode redefinir temporariamente como o defvar funciona, se desejar, e durante esse período, recarregar os pacotes que deseja redefinir.

Escrevi uma macro em que, durante a avaliação do corpo, os valores defvars serão sempre reavaliados.

(defmacro my-fake-defvar (name value &rest _)
  "defvar impersonator that forces reeval."
  `(progn (setq ,name ,value)
          ',name))

(defmacro with-forced-defvar-eval (&rest body)
  "While evaluating, any defvars encountered are reevaluated"
  (declare (indent defun))
  (let ((dv-sym (make-symbol "old-defvar")))
    `(let ((,dv-sym (symbol-function 'defvar)))
       (unwind-protect
           (progn
             (fset 'defvar (symbol-function 'my-fake-defvar))
             ,@body)
         (fset 'defvar ,dv-sym)))))

Exemplo de uso:

file_a.el

(defvar my-var 10)

file_b.el

(with-forced-defvar-eval
  (load-file "file_a.el")
  (assert (= my-var 10))
  (setq my-var 11)
  (assert (= my-var 11)
  (load-file "file_a.el")
  (assert (= my-var 10))

Nota: Isso deve ser usado apenas com a finalidade de reavaliar defvars, pois apenas ignora as doutrinas ao reavaliar. Você pode modificar a macro para dar suporte à reavaliação que também aplica doutrinas, mas deixarei isso para você.

No seu caso, você poderia fazer

(with-forced-defvar-eval (require 'some-package))

Mas saiba o que aqueles que escrevem elisp esperam que o defvar funcione conforme especificado, pode ser que eles usem o defvar para definir e setq em alguma função init para especificar o valor, para que você possa acabar sem variáveis ​​que não pretende, mas isso é provavelmente raro.

Implementação Alternativa

Usando isso, você pode redefinir o defvar globalmente e controlar se ele definirá ou não o valor do símbolo para o argumento INIT-VALUE, mesmo que o símbolo seja definido alterando o valor do novo defvar-always-reeval-valuessímbolo.

;; save the original defvar definition
(fset 'original-defvar (symbol-function 'defvar))

(defvar defvar-always-reeval-values nil
  "When non-nil, defvar will reevaluate the init-val arg even if the symbol is defined.")

(defmacro my-new-defvar (name &optional init-value docstring)
  "Like defvar, but when `defvar-always-reeval-values' is non-nil, it will set the symbol's value to INIT-VALUE even if the symbol is defined."
  `(progn
     (when defvar-always-reeval-values (makunbound ',name))
     (original-defvar ,name ,init-value ,docstring)))

;; globally redefine defvar to the new form
(fset 'defvar (symbol-function 'my-new-defvar))

O defvarestá sendo avaliado e fazendo exatamente o que você especificou. No entanto, defvardefine apenas um valor inicial:

O argumento opcional INITVALUE é avaliado e usado para definir SYMBOL, apenas se o valor de SYMBOL for nulo.

Portanto, para alcançar o que você deseja, você precisará desvincular a variável antes de reavaliar, por exemplo

(makunbound 'foo)

ou use setqpara definir o valor, por exemplo

(defvar foo nil "My foo variable.")
(setq foo 1)

Se você não precisar especificar uma sequência de documentos aqui, poderá pular defvarcompletamente.

Se você realmente deseja usar defvare desvincular automaticamente isso, precisará escrever uma função para encontrar defvarchamadas no buffer atual (ou região, ou último sexp, etc); ligue makunboundpara cada um; e então faça a avaliação real.

A macro a seguir foi criada rastreando eval-defunsuas funções de suporte e modificando-a para que não seja mais necessário avaliar uma região de um buffer específico. Eu precisava de ajuda no thread relacionado Convertendo uma expressão em uma string , e o @Tobias veio em socorro - me ensinando como converter a função imperfeita em uma macro. Não acho que precisamos eval-sexp-add-defvarspreceder elisp--eval-defun-1, mas se alguém achar importante, informe-me.

;;; EXAMPLE:
;;;   (defvar-reevaluate
;;;     (defvar undo-auto--this-command-amalgamating "hello-world"
;;;     "My new doc-string."))

(defmacro defvar-reevaluate (input)
"Force reevaluation of defvar."
  (let* ((string (prin1-to-string input))
        (form (read string))
        (form (elisp--eval-defun-1 (macroexpand form))))
    form))

O problema não é que a linha não esteja sendo reavaliada. O problema é que defvardefine uma variável e seu valor padrão . Se uma variável já existir, a alteração do valor padrão não modifica o valor atual. Infelizmente, acho que você precisará executar um setqpara cada variável cujo valor você deseja atualizar.

Isso pode ser um exagero, mas você pode atualizar seu arquivo assim se quiser atualizar facilmente foopara seu novo valor padrão.

(defvar foo 2)
(setq foo 2)

mas isso exige que você mantenha o valor padrão em dois lugares no seu código. Você também pode fazer isso:

(makunbound 'foo)
(defvar foo 2)

mas se houver uma chance foodeclarada em outro lugar, você poderá ter alguns efeitos colaterais.