How to write a transparent "pass-through" function wrapper?

Question

What I mean by a "transparent 'pass-through' function wrapper" is a function, let's call it wrapper, that returns the result from passing all its argument to some other function, let's call it wrappee.

How is this done in Emacs Lisp?

NB: The ideal wrapper function is agnostic about the wrappee function's signature; i.e. it knows nothing of the number, positions, names, etc. of wrappee's arguments; it just passes all its arguments along to wrappee, just as if wrappee had been the one originally called. (There's no need, however, to mess with the call stack to replace the call to wrapper with a call to wrappee.)

I posted a partial answer to my question:

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

This works only when wrappee is not interactive. Apparently, the way interactive functions get their arguments represents a different "channel" from what's covered by the (&rest args) incantation. What I still need, therefore, is an equally-wrappee-agnostic counterpart of the (&rest args) signature for the case where wrappee is an interactive function.

(This question was motivated by a problem described in this earlier question.)

---

In case further clarification of what I'm asking for is needed, below are a couple of examples, showing the Python and JavaScript equivalents of what I'm after.

In Python a couple of standard ways to implement such a wrapper are shown below:

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

# or

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

(Here *args stands for "all the positional arguments", and **kwargs stands for "all the keyword arguments".)

The JavaScript equivalent would be something like this:

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

// or

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

---

For the record, I disagree that this question is a duplicate of How to apply mapcar to a function with multiple arguments. I am at a loss to explain why, since the two questions look so obviously different to me. It is like being asked "explain why an apple should not be considered equivalent to an orange". The mere question is so crazy, that one doubts one could ever come up with an answer that would satisfy the person asking it.

Answer 1

Of course it is possible inclusive the interactive specification. We are dealing here with elisp! (Lisp is the language where the most important constructs are lists. Callable forms are just lists. So you can construct them after your liking.)

Application: You want to add some functionality to some functions automagically. The extended functions should be given new names so that defadvice is not applicable.

First a version that fits quite exactly your purpose. We set the function cell (fset) of the symbol wrapper with all required information from wrappee and add our extra stuff.

It works for both wrappee definitions. The first version of wrappee is interactive the second is not.

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

But it is more convenient to define a macro that constructs the extended functions. Therewith we can even specify the function names afterwards. (Good for an automated version.)

After executing the code below you can call wrapper-interactive interactively and wrapper-non-interactive non-interactively.

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

Note, up to now I did not yet find a way to transfer the declare forms but that should also be possible.

Answer 2

I had to solve a very similar problem in nadvice.el, so here is a solution (which uses some of the code from nadvice.el):

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

Compared to the other solutions posted so far, this one has the advantage of working correctly if wrappee gets redefined with a different interactive spec (i.e. it won't keep using the old spec).

Of course, if you want your wrapper to be truly transparent, you can do it more simply:

(defalias 'wrapper #'wrappee)

Answer 3

edit: Tobias' answer is nicer than this, as it obtains the precise interactive form and docstring of the wrapped function.

---

Combining the answers of Aaron Harris and kjo, you might use something like:

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

Call wrapper with either of:

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

M-x wrapper-func