Sure. A simple solution would be something like (define-key cider-mode-map (kbd "<f12>") (lambda () (interactive) (cider-interactive-eval "(reload)")))

thanks @UFAP0C8KU!

There's also cider-ns-refresh

@UDE7BJK1N here https://www.youtube.com/watch?v=2nH59edD5Uo&t=2289s I'm demoing a "dev menu" I create for my projects. This is a way of binding a key to show a menu per project with different key actions for that project, like reload, start webserver, clear a chache, calling profilers, etc. You can see the code here https://github.com/jpmonettas/elisp-utils/blob/master/clojure.el

thanks @U45T93RA6 and @U0739PUFQ!

100% a bug.

#'foo desugars to (var foo) so these are equivalent semantically, the question is what the printer does for a var I think. Clojure's printer re-sugars back to var quote, and I assume something in cider is making a different choice there. it's different, but not sure it's a bug?

(list 'var 'foo) should never get identified with any foo vars right? It seems an unequivocal bug if CIDER is identifying the symbol foo in the form (list 'var 'foo) with a var of that name, right?

no?

What does (deref foo) print?

I would guess that cider's #' formatting tries to accomplish something that Clojure lacks by default. Without an example of that feature it's harder to assess if the bug can be fixed

@U7RJTCH6J it throws because it’s not actually a var.

oops. I meant (list 'deref 'foo)

I’m not sure if it’s a bug either, but I think the behavior of the standard Clojure printer is better because it makes clear that I’m looking at a list and not a var. I ran into this today because my code was throwing trying to call one of these things, and I was looking at it in the REPL and thinking it was a var, because CIDER prints them indistinguishably.

(list 'var 'foo)

@U7RJTCH6J that also throws because it’s not actually a var, it’s just printing like one. it’s a list so it throws class clojure.lang.PersistentList cannot be cast to class java.util.concurrent.Future

there is no actual var foo here in this example. Just the list ('var 'foo) . which might evaluate to a var, but it’s not being evaluated, it’s just a list of symbols.

user> (list 'var 'foo)
#'foo
user> (type *1)
clojure.lang.PersistentList

oh right, I am confusing myself here

then yes, I agree it's a bug :)

user> (list 'deref 'foo)
(deref foo)

oh, sorry @U7RJTCH6J, I misread, I thought you were asking about (deref (list 'var 'foo)). Yes, lists with other symbols render normally, only lists of length 2 with 'var as the first value render in this confusing way AFAICT.

The reason I ask:

> (= '@foo (list `deref 'foo))
true

user=> (list `deref 'foo)
(clojure.core/deref foo)

user> (list `deref 'foo)
@foo

and with var:

user> (= '#'foo (list 'var 'foo))
true

user> (= ''foo (list 'quote 'foo)) 
true

user=> (list 'quote 'foo)
(quote foo)

user> (list 'quote 'foo)
'foo

I assume you probably get a similar result for some other sugars like ~ and ~@ .

(-->
  id                                 "35"
  op                                 "eval"
  time-stamp                         "2023-06-29 16:34:07.272187000"
  code                               "(list 'var 'foo)"
  ns                                 "user"
)
(<--
  id         "35"
  value      "#'foo"
)

user> (list 'var 'foo)
#'foo
user> (type *1)
clojure.lang.PersistentList

interesting that for deref it behaves differently depending on whether the symbol is namespaced or not, but not in these other examples

Just checked. deref behaves similarly to ~, but cider doesn't re-sugar ~@.

I think the reason deref must be namespaced is just based on the how the reader desugars @foo and ~foo. Those desugar to the fully qualified functions, deref and unquote while var and quote are special forms that can't be fully qualified.

Fun fact, afaik (var foo) always refers to the special form even if you try to make a local binding:

user> (let [var (constantly 42)]
        (var 10))
Syntax error (ClassCastException) compiling var class java.lang.Long cannot be cast to class clojure.lang.Symbol (java.lang.Long is in module java.base of loader 'bootstrap'; clojure.lang.Symbol is in unnamed module of loader 'app')

one of the consequences of being a lisp-1 instead of a lisp-2