Re: Attaching context info to an error

["João Távora" <joaotavora@gmail.com>]

On Thu, Dec 21, 2023 at 10:31 PM Stefan Monnier
<monnier@iro.umontreal.ca> wrote:

> I'm playing with `handler-bind` and trying to see how we could make use
> of such a functionality in Emacs.

*loud cheers*

> So far I have encountered basically two use case:

(...proceeds to list three use cases...)

Amongst the killer weaponry this gives us is a restart system,
finally.

This completely changes interactive development.  Whereas before
you couldn't restart from an nearby stack frame after doing
some changes to the state (say recompiling a buggy function, or
setting a global variable),  with a handler-bind-powered restart
system you finally can.

So I had to try your branch...

;; -*- lexical-binding: t -*-
(require 'cl-lib)

(defvar pm/restarts nil)

(defun pm/call-with-retry-restart (outer inner msg fn)
  (catch outer
    (let ((saved-restarts pm/restarts))
      (unwind-protect
          (while t
            (catch inner
              (handler-bind ((error (lambda (_e)
                                      (push
                                       (list 'retry msg
                                             (lambda ()
                                               (throw inner nil)))
                                       pm/restarts))))
                (throw outer (funcall fn)))))
        (setq pm/restarts saved-restarts)))))

(cl-defmacro pm/with-retry-restart ((&key (msg "Retry.")) &body body)
  `(pm/call-with-retry-restart (gensym) (gensym) ,msg (lambda () ,@body)))

(defun pm/invoke-restart (restart)
  (interactive
   (some-read-from-minibuffer-or-somesuch))
  (funcall (caadr restart)))

(defun baz (sym)
  (error "whoops, it happened again for %s" sym))

(defun bar ()
  (pm/with-retry-restart (:msg "Retry") (baz (gensym))))

(defun foo ()
  (bar))

(foo)

;; Local Variables:
;; read-symbol-shorthands: (("pm/" . "poor-mans-restarts-"))
;; End:

This very code works fine in Common Lisp (just add a WHILE
macro to it) however when I try this in your Emacs branch and
evaluate (foo) I get:

   Re-entering top level after C stack overflow

and Emacs dies immediately.

João

PS: Of course Common Lisp has all of this built-in and with
much, much better primitives that cover a wealth of use cases.
So this was just a quick-n-dirty proof of concept.