Clojurians Log v2

Thank you for the input @suskeyhose and @p-himik. Sorry I missed these messages. That's good to know. I didn't know about FlowStorm so I'll check it out.

Maybe @suskeyhose can help.

oh hello! cool that people are finding farolero

Ok, if I understand this correctly, what you're looking to do is to make it so that you can write code that refers to things that do not exist yet, have the debugger get started when the code attempts to evaluate such an unbound symbol, and allow you to define them from within the debug repl, and then resume execution?

This is my guess because this is something that you absolutely can do in Common Lisp.

Doing this from Clojure is... well let's say it's challenging. The only way that I can think about how it would go is to have some middleware on eval in nrepl that inspects the thing being evaluated, expands macros, and whenever it finds a symbol which is unbound it will instead emit a declare expression to make sure it exists, and then a restart similar to what Joseph described.

The reason that it's this complicated is because there's a fundamental difference in the Common Lisp and Clojure compilation models.

In Common Lisp, symbols themselves have values stored in them, and simply by the reader consuming the source code it produces every symbol which appears in it. That means that by the time you get to evaluating the code, there are no symbols that have no meaning, there are only some symbols which have not had a value set on them.

So when some code is executed in Common Lisp, if a symbol has no value and it is evaluated, then it will signal an error and you can from the debugger give it a value and move on.

But in Clojure, the symbols themselves as produced by the reader aren't what the values are stored on.

Instead, values are stored on Vars, which are created when you evaluate a declare or def form (and a couple other ways).

If you try to compile code that has a symbol which has not been associated with a var in the current namespace, then the compiler will not emit code that will signal an error when it is executed, instead the compiler will throw an exception immediately.

It sounds that maybe the most proper way to handle it would be something like the FlowStorm debugger that simply provides its own Clojure version, which in this case would have a custom reader that also defines vars and a custom compiler with some affordances to pause and continue when an unbound var is encountered (which is not needed if another debugger is used on top). Heh, maybe it's even a possible extension for FlowStorm.

Yeah, that would be an option for sure. Unfortunately I don't personally have the capacity to maintain such a fork myself 😅

too many other things to handle already

It seems like it would be some combination of the following;

(restart-case (far/invoke-restart-interactively ::some-restart)
  (::some-restart [a]
    :interactive #(list (far/request-value ::interactive-some-restart))
    a))

(defonce on-start
  (alter-var-root far/*debugger-hook* (constantly nil)))