How do write a function/macro to wrap arbitrary interactive function?

Question

I'm trying to write a function/macro to wrap arbitrary interactive function with some pre- and post- processing. Those processing does not involve the arguments of the interactive function.

For example, give f = delete-region, I'd like to write a function/macro that return a new function g = delete-region-wrapper with the definition like

(defun delete-region-wrapper (begin end) # or maybe (&rest args)...
    (interactive "r")
    (read-only-mode -1) # 'pre-processing'
    (delete-region begin end) # or maybe (apply #'delete-region ...) or maybe (funcall #'delete-region ... ) 
    (read-only-mode 1)) # 'post-processing'

Or the Python equivalent looks like

def wrap(f):
    def wrapper(*args, **kwargs):
        read_only_mode(-1)
        res = f(*args, **kwargs)
        read_only_mode(1)
        return res
    
    return wrapper

 delete_region_wrapper = wrap(delete_region)

How can I write this wrap macro/function?

(defmacro/defun wrap(f)
    ???
)

(setq delete-region-wrapper (wrap #'delete-region))

Answer 1

You just need to return a lambda, since functions are first class members of the language.

(defun wrapper (f)
  (lambda (beg end)
    (interactive "r")
    (read-only-mode -1)
    (apply f (list beg end))
    (read-only-mode 1)))

Above will create a function object with a closure (f is fixed in this closure).
Then assign the returned function object into the function-slot of a symbol (e.g. w-d-r):

(setf (symbol-function 'w-d-r) (wrapper #'delete-region))

or

(fset 'w-d-r-2 (wrapper #'delete-region))

Above example is fixed to wrapping functions with two arguments, whose rely on region borders. It is possible to abstract more, by using &rest args as parameters, then your call to interactive needs to become more complex and instead of (list beg end) you would supply args to apply.

(defun wrapper (f)
  (lambda (&rest args)
    (interactive (SOMETHING-FANCY-HERE))
    (read-only-mode -1)
    (apply f args)
    (read-only-mode 1)))

Edit: instead of using apply, a call of call-interactively might suffice:

(defun wrapper-2 (f)
  (lambda () 
    (interactive)
    (read-only-mode -1)
    (call-interactively f)
    (read-only-mode 1)))