Bagaimana cara saya memaksa evaluasi ulang defvar?

Misalkan saya memiliki buffer Emacs lisp yang berisi:

(defvar foo 1)

Jika saya menelepon eval-last-sexpatau eval-buffer, footerikat ke 1. Jika saya mengedit buffer ini ke:

(defvar foo 2)

eval-last-sexpdan eval-bufferjangan mengeksekusi ulang baris ini, jadi foomasih 1.

Ini sangat menantang ketika ada beberapa pernyataan seperti itu dan saya harus melacak garis mana yang tidak dievaluasi kembali.

Saya melihat hanya me-restart Emacs dan kemudian (require 'foo), tetapi kemudian saya harus berhati-hati untuk menghindari memuat file .elc yang lebih tua.

Bagaimana saya bisa benar-benar yakin bahwa variabel dan fungsi yang didefinisikan dalam file saat ini berada dalam keadaan yang sama seperti memuat kode baru dalam contoh Emacs baru?

Seperti yang dijelaskan dalam jawaban lain, mengevaluasi defvarformulir menggunakan eval-last-sexptidak mereset nilai default.

Sebaliknya, Anda dapat menggunakan eval-defun(terikat C-M-xdi emacs-lisp-modesecara default), yang mengimplementasikan perilaku yang Anda inginkan sebagai pengecualian khusus:

Jika pembelotan saat ini sebenarnya adalah panggilan ke defvaratau defcustom, mengevaluasinya dengan cara ini me-reset variabel menggunakan ekspresi nilai awal bahkan jika variabel sudah memiliki beberapa nilai lainnya. (Biasanya defvardan defcustomjangan ubah nilainya jika sudah ada.)

Jika Anda perlu mengevaluasi konten lengkap dari buffer, Anda dapat menulis fungsi yang berjalan di formulir tingkat atas secara bergantian dan memanggil eval-defunmasing-masing. Sesuatu seperti ini seharusnya bekerja:

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

Seperti jawaban yang lain katakan, ini hanya cara defvar bekerja, tetapi Anda dapat mengatasinya, ini adalah hal yang paling sulit.

Anda dapat mendefinisikan kembali sementara bagaimana defvar bekerja jika Anda ingin dan selama waktu itu, memuat ulang paket yang ingin Anda atur ulang.

Saya menulis makro di mana selama evaluasi tubuh, nilai-nilai defvars akan selalu dievaluasi kembali.

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

Contoh penggunaan:

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

Catatan: Ini hanya digunakan untuk tujuan mengevaluasi kembali defvars, karena hanya mengabaikan dokumen ketika mengevaluasi ulang. Anda dapat memodifikasi makro untuk mendukung evaluasi ulang yang menerapkan dokumen juga, tapi saya akan menyerahkannya kepada Anda.

Dalam kasus Anda, Anda bisa melakukannya

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

Tapi ketahuilah apa yang dilakukan oleh elisp agar mengharapkan defvar berfungsi seperti yang ditentukan, bisa jadi mereka menggunakan defvar untuk mendefinisikan dan setq dalam beberapa fungsi init untuk menentukan nilainya, sehingga Anda bisa berakhir dengan nil'ing variabel yang tidak Anda inginkan tetapi ini mungkin jarang terjadi.

Implementasi Alternatif

Dengan menggunakan ini, Anda bisa mendefinisikan ulang defvar secara global dan mengontrol apakah itu akan menetapkan nilai simbol ke argumen INIT-VALUE bahkan jika simbol tersebut didefinisikan dengan mengubah nilai defvar-always-reeval-valuessimbol baru .

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

The defvarsedang dievaluasi dan melakukan apa yang telah Anda tentukan. Namun, defvarhanya menetapkan nilai awal:

Argumen opsional INITVALUE dievaluasi, dan digunakan untuk mengatur SYMBOL, hanya jika nilai SYMBOL batal.

Jadi untuk mencapai apa yang Anda inginkan, Anda harus melepaskan ikatan variabel sebelum mengevaluasi ulang, mis

(makunbound 'foo)

atau gunakan setquntuk mengatur nilai, mis

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

Jika Anda tidak perlu menentukan docstring di sini, Anda dapat melewati defvarsemuanya.

Jika Anda benar-benar ingin menggunakan defvardan melepaskan ikatan ini secara otomatis, Anda harus menulis fungsi untuk menemukan defvarpanggilan di buffer saat ini (atau wilayah, atau sexp terakhir, dll); panggilan makunbounduntuk masing-masing; dan kemudian melakukan eval yang sebenarnya.

Makro berikut dibuat dengan menelusuri eval-defunfungsi pendukungnya dan memodifikasinya sehingga tidak perlu lagi mengevaluasi wilayah buffer tertentu. Saya membutuhkan bantuan di utas terkait. Mengubah ekspresi menjadi string , dan @Tobias datang untuk menyelamatkan - mengajari saya cara mengubah fungsi tidak sempurna menjadi makro. Saya tidak berpikir kita harus eval-sexp-add-defvarsmendahului elisp--eval-defun-1, tetapi jika seseorang berpikir itu penting, beri tahu saya.

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

Masalahnya bukan bahwa garis tidak dievaluasi kembali. Masalahnya adalah bahwa defvarmendefinisikan suatu variabel dan nilai defaultnya . Jika variabel sudah ada, maka mengubah nilai defaultnya tidak mengubah nilai saat ini. Sayangnya, saya pikir Anda perlu menjalankan setquntuk setiap variabel yang nilainya ingin Anda perbarui.

Ini mungkin berlebihan, tetapi Anda dapat memperbarui file seperti ini jika Anda ingin dapat dengan mudah memperbarui fooke nilai default yang baru.

(defvar foo 2)
(setq foo 2)

tetapi itu mengharuskan Anda mempertahankan nilai default di dua tempat dalam kode Anda. Anda juga bisa melakukan ini:

(makunbound 'foo)
(defvar foo 2)

tetapi jika ada kesempatan yang foodinyatakan di tempat lain Anda mungkin memiliki beberapa efek samping untuk dihadapi.