Cancelable sit-for wrapper for a long-running Emacs Lisp polling loop

Answer

Wrap each sit-for call in a condition-case that catches the quit signal, then test the sentinel-updated flag immediately after sit-for returns. Break the loop when the flag is set, and let C-g abort via the caught quit signal. Polling the flag after each short wait (1–2 seconds) is the accepted approach; there is no need to simulate input from the sentinel.

Confirmed facts

• sit-for returns t when input arrives and nil on timeout.
• C-g raises the quit signal, which condition-case can catch.
• A long sit-for will not wake early for a variable change alone, so the flag must be checked between waits.

Likely explanation

The event loop runs sentinel callbacks between your sit-for calls, so a flag set by a sentinel is visible on the next iteration. A moderate interval keeps CPU use negligible while staying responsive to both C-g and the external condition.

Pattern (Emacs 29)

(defvar my-poll-done nil
  "Flag set by the sentinel when the waited-for condition occurs.")

(defun my-poll-loop ()
  (while (not my-poll-done)
    (condition-case nil
        (sit-for 2)          ; wait up to 2 seconds
      (quit                  ; C-g arrived
       (message "C-g caught - aborting")
       (signal 'quit nil)))
    ;; sit-for returned: t on input, nil on timeout; check the flag
    (when my-poll-done
      (message "Sentinel flag set - exiting loop"))))

Keep the sentinel minimal — it should only set the flag:

(setq my-poll-done nil)
(let ((proc (start-process "test" "*test*" "sleep" "5")))
  (set-process-sentinel proc
                        (lambda (proc event)
                          (setq my-poll-done t))))
(my-poll-loop)

Verification

• Evaluate the definitions above in *scratch*, then run the example. The loop should end after the sleep finishes, or immediately when you press C-g.
• Shorten the interval to 0.5 seconds and repeat; confirm exit is still prompt on both paths.
• Check CPU impact with M-x profiler-start / M-x profiler-stop; a 1–2 second interval should show negligible overhead.

Cautions

• Do not bind inhibit-quit around sit-for; that suppresses C-g until it is nil again.
• Do not call sit-for or any input-processing command inside the sentinel; that risks event-loop re-entrancy.
• With with-timeout, a firing timeout exits the body regardless of flag state — check the flag after the form or handle the timeout value explicitly.
• Inside a recursive edit, sit-for still honors quit and timeout, but make sure the flag is checked at the same nesting level; recursion-depth can help diagnose interference.