목록에있는 모든 테마에 대해 대화 형 기능을 동적으로 만들 수있는 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)

그러나 아래는 기호 이름을 전달하는 곳에서 작동하지 않습니다 (루프 자체가 풀릴 때 발생하는 것일 수 있습니다). 매크로 인수 앞에 따옴표를 적어 둡니다.

;; 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. 그 이유는 디버그를 훨씬 더 복잡하게 만들기 때문입니다. 반복 정의에서 약간의 중복성은 유지 보수 단계에서 매우 효과적입니다 (그리고 유지 보수는 일반적으로 프로그램 수명에서 가장 긴 단계입니다).

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

정확히 디펀은 아니지만 왜 그렇지 않습니까? :피

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

아마도 필요한 것보다 약간 더 복잡 할 수 있지만 (특히 여분의 평가) 속성에 필요한 defuns를 생성 할 수 있습니다 (문자열에 올바른 정보가 담긴 docstring을 포함).