ฉันกำลังทำงานเพื่อปรับแต่งการกำหนดค่า emacs ของฉันซึ่งฉันสามารถสร้างฟังก์ชั่นแบบโต้ตอบสำหรับธีมทั้งหมดที่ฉันมีในรายการ

ด้านล่างนี้เป็นเวอร์ชั่นที่เรียบง่ายของสิ่งปลูกสร้างที่ฉันพยายามจะทำงาน

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

แต่ถ้าฉันคลี่วงด้วยตนเองมันทำงานได้:

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

แต่ด้านล่างไม่ได้ทำงานที่ฉันผ่านในชื่อสัญลักษณ์ (ซึ่งอาจเป็นสิ่งที่เกิดขึ้นเมื่อวนรอบ unrolls ด้วยตัวเอง) จดเครื่องหมายคำพูดก่อนอาร์กิวเมนต์ของแมโคร

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

ปรับปรุง

ขอบคุณ@wvxvw ในที่สุดฉันก็ได้งานนี้มา !

ตามที่ @wvxvw แนะนำฉันจะไม่ถูกสร้างเป็นชุดสำหรับกรณีการใช้งานทุกกรณี นี่เป็นกรณีการใช้งานพิเศษที่มีชื่อธีมXYZฉันต้องการสร้าง defun ที่เรียกload-theme/XYZว่าทำงาน

• ปิดการใช้งานชุดรูปแบบอื่น ๆ ทั้งหมดที่อาจใช้งานอยู่
• โทรload-themeหาXYZ
• ทำสิ่งที่กำหนดเองเพิ่มเติมที่เกี่ยวข้องกับชุดรูปแบบนั้น ฉันผ่านการตั้งค่าที่กำหนดเองสำหรับแต่ละธีมผ่านอmy/themesลิส

นี่คือความพยายามในการอธิบายและข้อเสนอแนะบางอย่าง

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

ตอนนี้เราลองแก้ไขสิ่งนี้:

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

ตัวอย่างที่มีชื่อฟังก์ชั่นการอ่านจากตัวแปร

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

ปัญหามาจากแนวคิดประเภท: แมโครมีไว้สำหรับสร้างรหัสเมื่อสภาพแวดล้อมต้องการอ่าน เมื่อคุณรันโค้ดด้วยตัวคุณเอง (ในฐานะผู้ใช้โปรแกรมของคุณ) สิ่งนี้มันสายเกินไปที่จะทำ (สภาพแวดล้อมควรรู้แล้วว่าโปรแกรมคืออะไร)

บันทึกร่อแร่: defunsฉันจะให้คำแนะนำกับก้อนด้วยกันหลาย เหตุผลก็คือมันทำให้ debuggin มีความซับซ้อนมากขึ้น ความซ้ำซ้อนเล็ก ๆ น้อย ๆ ที่คุณมีในคำจำกัดความซ้ำแล้วซ้ำอีกจะให้ผลตอบแทนที่ดีมากในระหว่างขั้นตอนการบำรุงรักษา

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

ไม่ได้กำหนดแน่นอน แต่ทำไมไม่ : P

ฉันมีดังต่อไปนี้ใน init ของฉัน:

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

บางทีมันอาจซับซ้อนกว่าที่ต้องการเล็กน้อย (โดยเฉพาะอย่างยิ่ง eval พิเศษ) แต่มันทำให้ฉันสามารถสร้าง defuns ที่ฉันต้องการสำหรับคุณสมบัติเหล่านั้นได้ (และรวมถึงเอกสารที่มีข้อมูลที่ถูกต้องในสตริง)