Comment forcer la réévaluation d'un defvar?

Supposons que j'ai un tampon lisp Emacs qui contient:

(defvar foo 1)

Si j'appelle eval-last-sexpou eval-buffer, fooest lié à 1. Si j'édite alors ce tampon à:

(defvar foo 2)

eval-last-sexpet eval-bufferne réexécutez pas cette ligne, il en fooest de même pour 1.

Cela est particulièrement difficile lorsqu'il existe plusieurs déclarations de ce type et je dois déterminer quelles lignes ne sont pas réévaluées.

J'ai regardé le redémarrage d'Emacs, puis (require 'foo), mais je dois faire attention à ne pas charger de fichiers .elc plus anciens.

Comment puis-je être absolument, positivement sûr que les variables et les fonctions définies dans le fichier actuel sont dans le même état que le chargement de code à nouveau dans une nouvelle instance Emacs?

Comme expliqué dans d'autres réponses, l'évaluation d'un defvarformulaire à l'aide de eval-last-sexpne réinitialise pas la valeur par défaut.

À la place, vous pouvez utiliser eval-defun(lié à C-M-xin emacs-lisp-modepar défaut), qui implémente le comportement que vous souhaitez comme exception spéciale:

Si le defun actuel est en fait un appel à defvarou defcustom, son évaluation de cette façon réinitialise la variable en utilisant son expression de valeur initiale même si la variable a déjà une autre valeur. (Normalement defvaret defcustomne modifiez pas la valeur s'il y en a déjà une.)

Si vous devez évaluer le contenu complet d'un tampon, vous pouvez écrire une fonction qui parcourt tour à tour les formulaires de niveau supérieur et appelle eval-defunchacun d'eux. Quelque chose comme ça devrait fonctionner:

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

Comme le disent les autres réponses, c'est exactement ainsi que fonctionne defvar, mais vous pouvez le contourner, c'est clair après tout.

Vous pouvez redéfinir temporairement le fonctionnement de defvar si vous le souhaitez et pendant ce temps, rechargez les packages que vous souhaitez réinitialiser.

J'ai écrit une macro où lors de l'évaluation du corps, les valeurs de defvars seront toujours réévaluées.

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

Exemple d'utilisation:

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

Remarque: ceci ne doit être utilisé que dans le but de réévaluer les defvars, car il ignore simplement les docstrings lors de la réévaluation. Vous pouvez modifier la macro pour prendre en charge la réévaluation qui applique également les docstrings, mais je vous laisse le soin de le faire.

Dans votre cas, vous pourriez faire

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

Mais sachez ce que font ceux qui écrivent elisp en s'attendant à ce que defvar fonctionne comme spécifié, il se peut qu'ils utilisent defvar pour définir et setq dans une fonction init pour spécifier la valeur, de sorte que vous pouvez finir par des variables nulles que vous n'avez pas l'intention mais c'est probablement rare.

Mise en œuvre alternative

En utilisant cela, vous pouvez simplement redéfinir defvar globalement et contrôler s'il définira ou non la valeur du symbole sur l'argument INIT-VALUE même si le symbole est défini en modifiant la valeur du nouveau defvar-always-reeval-valuessymbole.

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

Le defvarest en cours d'évaluation et fait exactement ce que vous avez spécifié. Cependant, defvarne définit qu'une valeur initiale:

L'argument facultatif INITVALUE est évalué et utilisé pour définir SYMBOL, uniquement si la valeur de SYMBOL est nulle.

Donc, pour obtenir ce que vous voulez, vous devez soit délier la variable avant de réévaluer, par exemple

(makunbound 'foo)

ou utilisez setqpour régler la valeur, par ex.

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

Si vous n'avez pas besoin de spécifier ici une docstring, vous pouvez ignorer le defvartout.

Si vous voulez vraiment utiliser defvaret dissocier automatiquement cela, vous devrez écrire une fonction pour trouver les defvarappels dans le tampon actuel (ou région, ou dernier sexp, etc.); appeler makunboundpour chacun; puis faites l'évaluation réelle.

La macro suivante a été créée en traçant eval-defunses fonctions de prise en charge et en la modifiant de sorte qu'il n'est plus nécessaire d'évaluer une région d'un tampon particulier. J'avais besoin d'aide dans le sujet connexe Conversion d'une expression en chaîne , et @Tobias est venu à la rescousse - m'enseignant comment convertir la fonction imparfaite en macro. Je ne pense pas que nous devions eval-sexp-add-defvarsprécéder elisp--eval-defun-1, mais si quelqu'un pense que c'est important, faites-le moi savoir.

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

Le problème n'est pas que la ligne ne soit pas réévaluée. Le problème est que defvardéfinit une variable et sa valeur par défaut . Si une variable existe déjà, la modification de sa valeur par défaut ne modifie pas la valeur actuelle. Malheureusement, je pense que vous devrez exécuter un setqpour chaque variable dont vous souhaitez mettre à jour la valeur.

Cela peut être exagéré, mais vous pouvez mettre à jour votre fichier comme celui-ci si vous souhaitez pouvoir facilement mettre fooà jour sa nouvelle valeur par défaut.

(defvar foo 2)
(setq foo 2)

mais cela nécessite que vous conserviez la valeur par défaut à deux endroits dans votre code. Vous pouvez également faire ceci:

(makunbound 'foo)
(defvar foo 2)

mais s'il y a une chance qui fooest déclarée ailleurs, vous pouvez avoir des effets secondaires à gérer.