Defvarın yeniden değerlendirilmesini nasıl zorlayabilirim?

Diyelim ki aşağıdakileri içeren bir Emacs lisp tamponu var:

(defvar foo 1)

Eğer ararsam eval-last-sexpveya eval-buffer, 1 foo'e bağlanırsa. Bu tamponu şu şekilde düzenlerseniz:

(defvar foo 2)

eval-last-sexpve eval-bufferbu satırı tekrar çalıştırmayın foo, yine de 1'dir.

Bu, çok sayıda ifade olduğunda ve özellikle hangi satırların yeniden değerlendirilmediğini izlemem gerektiğinde, bu özellikle zordur.

Sadece (require 'foo)Emacs'ı yeniden başlatmaya baktım ve sonra , daha eski .elc dosyalarını yüklemekten kaçınmak için dikkatli olmalıyım.

Geçerli dosyada tanımlanan değişkenlerin ve fonksiyonların, yeni bir Emacs örneğinde yükleme kodunun yenisiyle aynı durumda olduğundan kesinlikle, pozitif olarak nasıl emin olabilirim?

Diğer cevaplarda açıklandığı gibi, bir defvarformu kullanarak değerlendirme eval-last-sexpvarsayılan değeri sıfırlamaz.

Bunun yerine, kullanabilirsiniz eval-defun(bağlı C-M-xiçinde emacs-lisp-modeözel bir istisna olarak istediğiniz davranışı uygular, hangi varsayılan):

Geçerli defun aslında bir çağrıysa defvarveya defcustombu şekilde değerlendirildiğinde, değişken zaten başka bir değere sahip olsa bile, başlangıç ​​değer ifadesini kullanarak değişkeni sıfırlar. (Normalde defvarve defcustomzaten bir tane varsa değeri değiştirmeyin.)

Tamponun tüm içeriğini değerlendirmeniz gerekirse, üst düzey formları sıralı ve eval-defunher birini çağıran bir fonksiyon yazabilirsiniz . Böyle bir şey çalışması gerekir:

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

Diğer yanıtların söylediği gibi, bu defvar'ın çalışma şeklidir, ancak bunun üstesinden gelebilirsiniz, sonuçta bu açıktır.

İsterseniz ve bu süre zarfında defvarın nasıl çalıştığını geçici olarak yeniden tanımlayabilirsiniz, sıfırlamak istediğiniz paketleri yeniden yükleyin.

Vücudun değerlendirilmesi sırasında, defvars değerlerinin her zaman yeniden değerlendirileceği bir makro yazdım.

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

Örnek Kullanım:

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

Not: Bu sadece yeniden değerlendirme yaparken sadece docstrings'i görmezden geldiğinden defvarları yeniden değerlendirmek amacıyla kullanılmalıdır. Makroları, dokümanlar için de geçerli olan yeniden değerlendirmeyi desteklemek için değiştirebilirsiniz, ancak bunu size bırakacağım.

Senin durumunda yapabilirsin

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

Ancak elisp yazanların defvar'ın belirtildiği gibi çalışmasını beklediklerini biliyorlar, değeri belirtmek için bazı init fonksiyonlarında tanımlamak ve setq olarak tanımlamak için defvar kullanıyor olabilirler, bu yüzden niyet etmeyeceğiniz değişkenleri bitirebilirsiniz. Bu muhtemelen nadirdir.

Alternatif Uygulama

Bunu kullanarak defvar'ı global olarak yeniden tanımlayabilir ve sembolün değerini, yeni defvar-always-reeval-valuessembolün değerini değiştirerek tanımlanmış olsa bile sembolün değerini INIT-VALUE değişkenine ayarlayıp ayarlamayacağını kontrol edebilirsiniz .

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

Bu defvardeğerlendiriliyor ve tam olarak belirttiğiniz şeyi yapıyor. Ancak, defvaryalnızca bir başlangıç ​​değeri belirler:

İsteğe bağlı argüman INITVALUE değerlendirilir ve sadece SYMBOL değeri geçersiz ise SYMBOL ayarlamak için kullanılır.

Yani istediğinizi elde etmek için, ya yeniden değerlendirmeden önce değişkeni serbest bırakmanız gerekir, örneğin;

(makunbound 'foo)

veya setqdeğeri ayarlamak için kullanın ;

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

Burada bir dokümanı belirtmeniz gerekmiyorsa, defvartamamen atlayabilirsiniz .

Bunu gerçekten kullanmak defvarve otomatik olarak açmak istiyorsanız defvar, geçerli arabellekte (veya bölgedeki veya son seksp, vb.) Çağrıları bulmak için bir işlev yazmanız gerekir ; makunboundher birini arayın ; ve sonra gerçek değerlendirmeyi yap.

Aşağıdaki makro, eval-defundestekleyici işlevlerini izleyerek ve belirli bir tamponun bir bölgesini değerlendirmenin artık gerekli olmayacağı şekilde değiştirerek yaratıldı . İlgili iş parçacığında yardıma ihtiyacım vardı Bir ifadeyi dizgeye dönüştürme ve @ Tobias kurtarmaya geldi - bana kusurlu işlevi bir makroya nasıl dönüştürebileceğimi öğretti. eval-sexp-add-defvarsÖncesinde olmamız gerektiğini düşünmüyorum elisp--eval-defun-1, ancak birileri bunun önemli olduğunu düşünüyorsa, lütfen bana bildirin.

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

Sorun, hattın yeniden değerlendirilmemesi değil. Sorun, defvarbir değişkeni ve varsayılan değerini tanımlamasıdır . Bir değişken zaten mevcutsa, varsayılan değerini değiştirmek geçerli değeri değiştirmez. Ne yazık ki, setqdeğerini güncellemek istediğiniz her değişken için a çalıştırmanız gerekeceğini düşünüyorum .

Bu aşırı olabilir, ancak fooyeni varsayılan değerine kolayca güncelleme yapabilmek istiyorsanız dosyanızı bu şekilde güncelleyebilirsiniz .

(defvar foo 2)
(setq foo 2)

ancak bu, varsayılan değeri kodunuzda iki yerde tutmanızı gerektirir. Bunu da yapabilirsiniz:

(makunbound 'foo)
(defvar foo 2)

ancak foobaşka bir yerde bildirilen bir şans varsa, başa çıkmanız gereken bazı yan etkileri olabilir.