Bagaimana cara menulis pembungkus fungsi “pass-through” transparan?

Apa yang saya maksud dengan "fungsi bungkus transparan 'pass-through'" adalah fungsi, sebut saja wrapper, yang mengembalikan hasil dari meneruskan semua argumennya ke beberapa fungsi lain, sebut saja wrappee.

Bagaimana ini dilakukan di Emacs Lisp?

NB: Fungsi ideal wrapperadalah agnostik tentang wrappeetanda tangan fungsi; yaitu tidak mengetahui jumlah, posisi, nama, dll. dari wrappeeargumen; itu hanya meneruskan semua argumennya wrappee, seolah-olah wrappeetelah menjadi yang awalnya disebut. (Namun, tidak perlu untuk mengacaukan tumpukan panggilan untuk mengganti panggilan wrapperdengan panggilan ke wrappee.)

Saya mengirim sebagian jawaban untuk pertanyaan saya:

(defun wrapper (&rest args) (apply 'wrappee args))

Ini hanya bekerja jika wrappeeini tidak interaktif. Rupanya, cara fungsi interaktif mendapatkan argumen mereka mewakili "saluran" yang berbeda dari apa yang dicakup oleh (&rest args)mantera. Yang saya masih perlu, oleh karena itu, adalah equally- wrappeemitra -agnostic dari (&rest args)tanda tangan untuk kasus di mana wrappeemerupakan interaktif fungsi.

(Pertanyaan ini dimotivasi oleh masalah yang dijelaskan dalam pertanyaan sebelumnya .)

Dalam hal klarifikasi lebih lanjut tentang apa yang saya minta diperlukan, di bawah ini adalah beberapa contoh, menunjukkan setara dengan Python dan JavaScript dari apa yang saya cari.

Dengan Python beberapa cara standar untuk mengimplementasikan pembungkus seperti itu ditunjukkan di bawah ini:

def wrapper(*args, **kwargs):
    return wrappee(*args, **kwargs)

# or

wrapper = lambda *args, **kwargs: wrappee(*args, **kwargs)

(Di sini *argssingkatan dari "semua argumen posisi", dan **kwargssingkatan dari "semua argumen kata kunci".)

Setara JavaScript akan menjadi seperti ini:

function wrapper () { return wrappee.apply(this, arguments); }

// or

wrapper = function () { return wrappee.apply(this, arguments); }

Sebagai catatan, saya tidak setuju bahwa pertanyaan ini adalah duplikat dari Bagaimana menerapkan mapcar ke suatu fungsi dengan banyak argumen . Saya bingung menjelaskan mengapa, karena kedua pertanyaan itu tampak sangat berbeda bagi saya. Itu seperti ditanya "jelaskan mengapa apel tidak dianggap setara dengan jeruk". Pertanyaan belaka itu sangat gila, sehingga orang ragu akan dapat menemukan jawaban yang akan memuaskan orang yang menanyakannya.

Tentu saja mungkin termasuk interactivespesifikasinya. Kita berurusan dengan elisp ! (Lisp adalah bahasa di mana konstruk yang paling penting adalah daftar. Formulir yang bisa dipanggil hanya daftar. Jadi, Anda dapat membangunnya setelah Anda sukai.)

Aplikasi: Anda ingin menambahkan beberapa fungsi ke beberapa fungsi secara otomatis. Fungsi yang diperluas harus diberi nama baru sehingga defadvicetidak berlaku.

Pertama, versi yang sesuai dengan tujuan Anda. Kami mengatur sel fungsi ( fset) simbol wrapperdengan semua informasi yang diperlukan dari wrappeedan menambahkan barang-barang tambahan kami.

Ini berfungsi untuk kedua wrappeedefinisi. Versi pertama wrappeeinteraktif adalah yang kedua tidak.

(defun wrappee (num str)
  "Nontrivial wrappee."
  (interactive "nNumber:\nsString:")
  (message "The number is %d.\nThe string is \"%s\"." num str))

(defun wrappee (num str)
  "Noninteractive wrappee."
  (message "The number is %d.\nThe string is \"%s\"." num str))

(fset 'wrapper (list 'lambda
             '(&rest args)
             (concat (documentation 'wrappee t) "\n Wrapper does something more.")
             (interactive-form 'wrappee)
             '(prog1 (apply 'wrappee args)
            (message "Wrapper does something more."))))

Tetapi lebih mudah untuk mendefinisikan makro yang membangun fungsi yang diperluas. Dengan itu kita bahkan dapat menentukan nama fungsi sesudahnya. (Bagus untuk versi otomatis.)

Setelah mengeksekusi kode di bawah ini Anda dapat menelepon secara wrapper-interactiveinteraktif dan wrapper-non-interactivenon-interaktif.

(defmacro make-wrapper (wrappee wrapper)
  "Create a WRAPPER (a symbol) for WRAPPEE (also a symbol)."
  (let ((arglist (make-symbol "arglist")))
  `(defun ,wrapper (&rest ,arglist)
     ,(concat (documentation wrappee) "\n But I do something more.")
     ,(interactive-form wrappee)
     (prog1 (apply (quote ,wrappee) ,arglist)
       (message "Wrapper %S does something more." (quote ,wrapper))))))

(defun wrappee-interactive (num str)
  "That is the doc string of wrappee-interactive."
  (interactive "nNumber:\nsString:")
  (message "The number is %d.\nThe string is \"%s\"." num str))

(defun wrappee-non-interactive (format &rest arglist)
  "That is the doc string of wrappee-non-interactive."
  (apply 'message format arglist))

(make-wrapper wrappee-interactive wrapper-interactive)
(make-wrapper wrappee-non-interactive wrapper-non-interactive)
;; test of the non-interactive part:
(wrapper-non-interactive "Number: %d, String: %s" 1 "test")

Catatan, sampai sekarang saya belum menemukan cara untuk mentransfer formulir pernyataan tetapi itu juga harus dimungkinkan.

Saya harus memecahkan masalah yang sangat mirip nadvice.el, jadi di sini ada solusi (yang menggunakan beberapa kode dari nadvice.el):

(defun wrapper (&rest args)
  (interactive (advice-eval-interactive-spec
                (cadr (interactive-form #'wrappee))))
  (apply #'wrappee args))

Dibandingkan dengan solusi lain yang diposting sejauh ini, yang satu ini memiliki keuntungan bekerja dengan benar jika wrappeedidefinisikan ulang dengan spesifikasi interaktif yang berbeda (yaitu tidak akan terus menggunakan spesifikasi yang lama).

Tentu saja, jika Anda ingin bungkus Anda benar-benar transparan, Anda bisa melakukannya lebih sederhana:

(defalias 'wrapper #'wrappee)

sunting: Jawaban Tobias lebih bagus dari ini, karena memperoleh bentuk interaktif yang tepat dan dokumentasi dari fungsi yang dibungkus.

Menggabungkan jawaban Aaron Harris dan kjo, Anda dapat menggunakan sesuatu seperti:

(defmacro my-make-wrapper (fn &optional name)
  "Return a wrapper function for FN defined as symbol NAME."
  `(defalias ',(or (eval name)
                   (intern (concat "my-" (symbol-name (eval fn)) "-wrapper")))
     (lambda (&rest args)
       ,(format "Generic wrapper for %s."
                (if (symbolp (eval fn))
                    (concat "`" (symbol-name (eval fn)) "'")
                  fn))
       (interactive)
       (if (called-interactively-p 'any)
           (call-interactively ,fn)
         (apply ,fn args)))))

Pemakaian:

(my-make-wrapper 'find-file 'wrapper-func)

Sebut pembungkus dengan salah satu dari:

(wrapper-func "~/.emacs.d/init.el")

M-x wrapper-func