How to break the undo chain from a function call? (not Ctrl-G)

Question

When undoing you can press Ctrl-G to redo.

This runs keyboard-quit which signals quit.

However this isn't convenient because as far as I know you can't run commands after keyboard-quit.

Is there a more direct way to break the undo chain, or a way to run keyboard-quit so you can keep calling functions after it?

---

I tried this for an undo/redo that doesn't require explicit Ctrl-G.

(defvar-local my-undo-is-redo nil)

(defun my-redo ()
  (interactive)
  (let ((inhibit-quit t))
    (unless my-undo-is-redo (with-local-quit (keyboard-quit)))
    ;; redo continued...
    (undo)
    (setq my-undo-is-redo t)))

(defun my-undo-only ()
  (interactive)
  (undo-only)
  (setq my-undo-is-redo nil))

(define-key evil-normal-state-map (kbd "u") 'my-undo-only)
(define-key evil-normal-state-map (kbd "C-r") 'my-redo)

Answer 1

undo decides to chain or not based on the value of last-command, so if you just set it to something other than undo it will break the chain. No need for quitting.

(defun my-redo ()
  (interactive)
  (setq last-command 'ignore)
  ;; redo continued...
  (undo))

Answer 2

Here's undo/redo for evil mode using the method described by @npostavs.

(defun my-redo ()
  (interactive)
  ;; Break undo chain, avoid having to press Ctrl-G.
  (when (string= last-command 'undo)
    (setq last-command 'ignore))
  (undo))

(defun my-undo ()
  (interactive)
  (undo-only)
  (setq this-command 'undo))

(define-key evil-normal-state-map (kbd "u") 'my-undo)
(define-key evil-normal-state-map (kbd "C-r") 'my-redo))