Saya sedang berupaya mengoptimalkan konfigurasi emacs saya di mana saya dapat secara dinamis membuat fungsi interaktif untuk semua tema yang saya miliki dalam daftar.

Di bawah ini adalah versi sederhana dari konstruk yang saya coba buat.

;; List containing names of functions that I want to create
(setq my/defun-list '(zz-abc
                      zz-def
                      zz-ghi))

;; Elisp macro to create an interactive defun whose name
;; is passed as the macro argument
(defmacro my/create-defun (defun-name)
  `(defun ,defun-name ()
     (interactive)
     (let ((fn-name (symbol-name ',defun-name)))
       (message "Testing creation of function %s" fn-name))))

;; Loop to call the above macro for each element in the list
;; DOES *NOT* WORK
(dolist (name my/defun-list)
  (my/create-defun name))

Tetapi jika saya membuka gulungan secara manual, itu bekerja:

;; WORKS
(my/create-defun zz-abc)
(my/create-defun zz-def)
(my/create-defun zz-ghi)

Tetapi di bawah ini tidak berfungsi di mana saya memberikan nama simbol (yang mungkin adalah apa yang terjadi ketika loop terbuka dengan sendirinya). Catat kutipan sebelum argumen makro.

;; DOES *NOT* WORK
(my/create-defun 'zz-abc)
(my/create-defun 'zz-def)
(my/create-defun 'zz-ghi)

Memperbarui

Terima kasih atas bantuan @wvxvw , akhirnya saya berhasil !

Seperti yang disarankan @wvxvw, saya tidak akan menjadi penggila batch untuk setiap kasus penggunaan. Ini adalah kasus penggunaan khusus di mana untuk tema bernama XYZ, saya ingin menghasilkan defun disebut load-theme/XYZyang melakukan pekerjaan

• Menonaktifkan semua tema lain yang mungkin aktif
• Memanggil load-themeuntukXYZ
• Melakukan beberapa hal khusus yang terkait dengan tema itu; Saya melewati pengaturan khusus untuk setiap tema melalui daftar my/themesalist.

Berikut adalah upaya menjelaskan dan beberapa saran.

(defmacro my/create-defun (defun-name)
  `(defun ,defun-name ()
     (interactive)
     (let ((fn-name (symbol-name ',defun-name)))
       (message "Testing creation of function %s" fn-name))))

(dolist (name my/defun-list)
  ;; Macros are meant to create code, not execute it.  Think
  ;; about simply substituting the contents of your macro here
  ;; what would you expect it to do?
  (my/create-defun name))

(dolist (name my/defun-list)
  ;; This is not something a compiler (or interpreter)
  ;; can work with, it needs all sources of the code it
  ;; is going to execute
  (defun defun-name ()
    (interactive)
    (let ((fn-name (symbol-name 'defun-name)))
      (message "Testing creation of function %s" fn-name))))

;; This works because you, indeed created three defuns
(my/create-defun zz-abc)
(my/create-defun zz-def)
(my/create-defun zz-ghi)

;; This doesn't work because `defun' macro expect the name of
;; the function to be a symbol (but you are giving it a list
;; `(quote zz-abc)'.
(my/create-defun 'zz-abc)
(my/create-defun 'zz-def)
(my/create-defun 'zz-ghi)

Sekarang, mari kita coba perbaiki ini:

;; Rewriting the original macro as a function and using a
;; macro to collect the generated forms gives:
(defun my/create-defun (defun-name)
  `(defun ,defun-name ()
     (interactive)
     (let ((fn-name (symbol-name ',defun-name)))
       (message "Testing creation of function %s" fn-name))))

(defmacro my/create-defuns (defuns)
  `(progn ,@(mapcar 'my/create-defun defuns)))

(macroexpand '(my/create-defuns (zz-abc zz-def zz-ghi)))
;; Just to make sure
(progn
  (defun zz-abc nil
    (interactive)
    (let ((fn-name (symbol-name (quote zz-abc))))
      (message "Testing creation of function %s" fn-name)))
  (defun zz-def nil
    (interactive)
    (let ((fn-name (symbol-name (quote zz-def))))
      (message "Testing creation of function %s" fn-name)))
  (defun zz-ghi nil
    (interactive)
    (let ((fn-name (symbol-name (quote zz-ghi))))
      (message "Testing creation of function %s" fn-name))))

Contoh dengan membaca nama fungsi dari variabel

(defvar my/functions '((func-1 . 1) (func-2 . 2) (func-3 . 3)))

(defun my/create-defun-n (defun-name n)
  `(defun ,defun-name ()
     (message "function: %s, n %d" ',defun-name ,n)))

(defmacro my/create-defuns-var ()
  `(progn ,@(mapcar
             (lambda (x) (my/create-defun-n (car x) (cdr x)))
             my/functions)))

(macroexpand '(my/create-defuns-var))
(progn
  (defun func-1 nil (message "function: %s, n %d" (quote func-1) 1))
  (defun func-2 nil (message "function: %s, n %d" (quote func-2) 2))
  (defun func-3 nil (message "function: %s, n %d" (quote func-3) 3)))

Masalahnya adalah dari jenis konseptual: makro adalah untuk menghasilkan kode ketika lingkungan ingin membacanya. Ketika Anda mengeksekusi kode sendiri (sebagai pengguna program Anda) ini sudah terlambat untuk melakukannya (lingkungan harus tahu pada saat itu apa program itu).

Sebuah catatan pinggir: Saya akan menyarankan agar tidak menyatukan beberapa defuns. Alasannya adalah itu membuat debuggin jauh lebih rumit. Sedikit redundansi yang Anda miliki dalam definisi berulang terbayar dengan sangat baik selama fase pemeliharaan (dan pemeliharaan biasanya merupakan fase terpanjang dalam masa hidup program).

(dolist (fun '(foo bar baz))
  (defalias fun (lambda (a)
                  "I'm a function defined in `dolist'!"
                  (interactive)
                  (message a))))
(bar "See? No macro!")

Tidak benar-benar defun tapi mengapa tidak? : P

Saya memiliki yang berikut di init saya:

(my/work-properties '("hostname" "username" "location"))

(defmacro jlp/make-def (name props doc &rest body)
  "Shortcut to programatically create new functions"
  (let ((funsymbol (intern name)))
    `(defun ,funsymbol ,props ,doc ,@body)))

(defun my/make-work-props (properties)
  "Create functions to retrieve properties from Org headlines."
  (dolist (prop properties)
    (let ((funsym   (format "my/org-get-%s" prop))
          (property (intern (format ":%s" (upcase prop))))
          (doc      (format "Retrieves `%s' from current headline"
                            (upcase prop)))
          (err (format "%s is not set" (capitalize prop))))
      (eval
       `(jlp/make-def ,funsym
                      ()
                      ,doc
                      (interactive)
                      (let ((x (or
                                (save-excursion
                                  (org-back-to-heading)
                                  (org-element-property
                                   ,property
                                   (org-element-at-point)))
                                (user-error ,err))))
                        (message "%s" x)
                         (kill-new x)))))))

(my/make-work-props my/org-work-properties)

Ini mungkin sedikit lebih kompleks daripada yang dibutuhkan (terutama eval tambahan) tetapi itu memungkinkan saya untuk menghasilkan defuns yang saya butuhkan untuk properti-properti tersebut (dan memasukkan dokumen dengan informasi yang benar dalam string).