Comment écrire un wrapper de fonction "pass-through" transparent?

Ce que je veux dire par un "wrapper de fonction transparent" pass-through "" est une fonction, appelons-la wrapper, qui renvoie le résultat du passage de tous ses arguments à une autre fonction, appelons-la wrappee.

Comment cela se fait-il dans Emacs Lisp?

NB: La wrapperfonction idéale est agnostique quant à la wrappeesignature de la fonction; c'est-à-dire qu'il ne sait rien du nombre, des positions, des noms, etc. des wrappeearguments de; il transmet simplement tous ses arguments à wrappee, comme s'il wrappeeavait été celui initialement appelé. (Il n'est cependant pas nécessaire de jouer avec la pile d'appels pour remplacer l'appel à wrapperpar un appel à wrappee.)

J'ai posté une réponse partielle à ma question:

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

Cela ne fonctionne que lorsqu'il wrappeen'est pas interactif. Apparemment, la façon dont les fonctions interactives obtiennent leurs arguments représente un "canal" différent de ce qui est couvert par l' (&rest args)incantation. Ce dont j'ai encore besoin, par conséquent, est une wrappeecontrepartie également -agnostique de la (&rest args)signature pour le cas où wrappeeest une fonction interactive .

(Cette question était motivée par un problème décrit dans cette question précédente .)

Dans le cas où une clarification supplémentaire de ce que je demande est nécessaire, voici quelques exemples, montrant les équivalents Python et JavaScript de ce que je recherche.

En Python, quelques méthodes standard pour implémenter un tel wrapper sont présentées ci-dessous:

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

# or

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

(Ici *argssignifie "tous les arguments positionnels", et **kwargssignifie "tous les arguments de mots clés".)

L'équivalent JavaScript serait quelque chose comme ceci:

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

// or

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

Pour mémoire, je ne suis pas d'accord que cette question est un doublon de Comment appliquer mapcar à une fonction avec plusieurs arguments . Je n'arrive pas à expliquer pourquoi, puisque les deux questions me semblent si différentes. C'est comme si on lui demandait "d'expliquer pourquoi une pomme ne devrait pas être considérée comme équivalente à une orange". La simple question est tellement folle, qu'on doute que l'on puisse jamais trouver une réponse qui satisfasse la personne qui la pose.

Bien sûr, il est possible d'inclure la interactivespécification. Nous avons affaire ici à elisp ! (Lisp est le langage où les constructions les plus importantes sont des listes. Les formulaires appelables ne sont que des listes. Vous pouvez donc les construire à votre guise.)

Application: vous souhaitez ajouter automatiquement certaines fonctionnalités à certaines fonctions. Les fonctions étendues doivent recevoir de nouveaux noms afin que cela defadvicene s'applique pas.

D'abord une version qui correspond tout à fait à votre objectif. Nous définissons la cellule de fonction ( fset) du symbole wrapperavec toutes les informations requises wrappeeet ajoutons nos éléments supplémentaires.

Cela fonctionne pour les deux wrappeedéfinitions. La première version de wrappeeest interactive, la seconde ne l'est pas.

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

Mais il est plus pratique de définir une macro qui construit les fonctions étendues. Avec cela, nous pouvons même spécifier les noms de fonction par la suite. (Bon pour une version automatisée.)

Après avoir exécuté le code ci-dessous, vous pouvez appeler de manière wrapper-interactiveinteractive et wrapper-non-interactivenon interactive.

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

Remarque, jusqu'à présent, je n'ai pas encore trouvé de moyen de transférer les formulaires de déclaration, mais cela devrait également être possible.

J'ai dû résoudre un problème très similaire dans nadvice.el, alors voici une solution (qui utilise une partie du code de nadvice.el):

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

Par rapport aux autres solutions publiées jusqu'à présent, celle-ci a l'avantage de fonctionner correctement si elle wrappeeest redéfinie avec une spécification interactive différente (c'est-à-dire qu'elle ne continuera pas à utiliser l'ancienne spécification).

Bien sûr, si vous voulez que votre emballage soit vraiment transparent, vous pouvez le faire plus simplement:

(defalias 'wrapper #'wrappee)

edit: la réponse de Tobias est plus agréable que cela, car elle obtient la forme interactive précise et la docstring de la fonction encapsulée.

En combinant les réponses d'Aaron Harris et de kjo, vous pourriez utiliser quelque chose comme:

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

Usage:

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

Habillage d'appel avec l'un des éléments suivants:

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

M-x wrapper-func