Run a function after control returns to the command loop

Question

Is there a hook that would run as soon as control returns to the user (i.e. to the command loop)?

Context: I'd like to register a function to run as soon as all functions in the current sequence of recursive calls have exited. The call stack looks like ... -> a -> b -> ... -> my function, and I would like my function to run when all functions on the stack have exited.

More context: Somewhere up in the call chain to my function there is a function f that is ill-behaved, insofar as I can't call it from one of its children (it needs to do some cleanup before I can call it again). Since I can't call f from my function, I'd like to register the call to f to run as soon as f has completed.

Answer 1

If you want to run something after the stack clears, run it on a 0 second timer.

(run-with-timer 0 nil 'your-function)

You could wrap this is a macro like this:

(defmacro after-stack-clears (&rest body)
  "Do BODY after the call stack is clear"
  `(run-with-timer 0 nil (lambda () ,@body)))

Here's an example usage mimicking your described scenario.

In this example, annoying-func is calling another provided function. In the provided function you'd like to call annoying-func again but annoying-func will error if called more than once on the call stack. So to counter this, the provided macro to ensure that annoying-func is called a second time, but only after the call stack has cleared and annoying-func has done its cleanup

(defun your-func-simple ()
  "try to directly call `annoying-func'."
  (annoying-func (lambda () (message "hi"))))

(defun your-func-smart ()
  "ensure `annoying-func' is called after the stack clears."
  (after-stack-clears
   (annoying-func (lambda () (message "hi")))))

(setq annoying-var nil)

(defun annoying-func (func)
  "This function will apply FUNC, if `annoying-function' is called
somewhere down the line by FUNC, the second call will error, because this 
is the annoying function after all."
  (if annoying-var
      (error "Can't call recursively!")
    (condition-case err
        (progn (setq annoying-var t)
               (apply func nil)
               (setq annoying-var nil))
      (error (progn (message "errored! %s" err) (setq annoying-var nil))))))


(defun erroring-example ()
  (annoying-func 'your-func-simple))

(defun working-example ()
  (annoying-func 'your-func-smart))

;; will error due to annoying-func being called twice on the stack
(erroring-example) 

;; will NOT error since annoying-func is called again only after the stack has cleared
(working-example) 

Answer 2

As lawlist says, you can use post-command-hook for that.

But another option might be to add an advice to the offending function. Along the lines of:

(advice-add 'f :after
            (lambda (&rest args)
              <do-something-after-f-runs>))