Override :print as an option to do whatever you like :)

I saw something similar to this done in https://github.com/dm3/clojure.java-time They have

(defmacro when-joda-time-loaded
  "Execute the `body` when Joda-Time classes are found on the classpath.

  Take care - when AOT-compiling code using this macro, the Joda-Time classes
  must be on the classpath at compile time!"
  [& body]
  (if (try (Class/forName "org.joda.time.DateTime")
           (catch Throwable e))
    `(do ~@body)))

as they mention there, you have to be careful with AOT stuff since it's a macro, you could do it on the fly but since it's reflection and throw/catching an exception performance may suffer if that is a concern

Cool, thanks! I’m not sure how I’d adapt that for Schema though, since Schema’s a Clojure lib

As for doing this on the fly, I’m thinking I could just do it once and then memoize the result, since Schema probably won’t be added to the classpath mid-program-execution

ahh yeah mb, I haven't tried it but if require throws an error if it doesn't exist that might be possible

The piggieback source does this fwiw

Cider piggieback, that is

ah, yeah, here: https://github.com/nrepl/piggieback/blob/master/src/cider/piggieback.clj#L9-L18

seems like I can do the same thing in cljs via (try (require 'foo.bar) true (catch :default _ false))

…so I guess that answers my question 🙂 thanks!

there's also requiring-resolve

Clojure 1.10.1
(ins)user=> (requiring-resolve 'foo.bar/baz)
Execution error (FileNotFoundException) at user/eval1 (REPL:1).
Could not locate foo/bar__init.class, foo/bar.clj or foo/bar.cljc on classpath.
(ins)user=> (requiring-resolve 'clojure.data/diff)
#'clojure.data/diff

doesn't work in cljs though

ojureScript 1.10.758
(ins)cljs.user=> (requiring-resolve 'foo.bar/baz)
WARNING: Use of undeclared Var cljs.user/requiring-resolve at line 1 <cljs repl>
Execution error (TypeError) at (<cljs repl>:1).
Cannot read property 'call' of undefined

I basically do that when I want compile-time enforcement around constants

it’s a lot nicer to have the compiler tell you when you’ve made a typo than to have to figure it out yourself because your program is inexplicably not working

I like the idea, it feels more secure with that enforcement. Do you limit it to certain things, or do you use it a lot?

Yeah, exactly

this is in general, an anti-pattern in Clojure

the whole benefit of making keywords invokable is to reduce the distance between the attribute and the invocation.

realistically, if you have (def foo :foo), you're not ever going to change :foo or if you do, you will also change foo. and you have also made it harder for static analysis tools to track where that keyword is being used

I end up using it every once in a while, especially when e.g. building a DSL or generating code for something

you've also made everything slower by introducing a var lookup in your keyword invocation

so you're doubling the invocation overhead

another benefit is that tooling support is better for vars than for keywords, so you can get autocomplete etc

as a rule of thumb for ‘normal’ code, I’d recommend defing constants including keywords that feel like ‘magic numbers’, and leaving keywords used for lookups etc inlined

Is the lookup overhead eliminated if I use direct linking?

for instance, if you’re generating HTML/CSS/React/whatever it’s not unlikely you’ll have a bunch of magic number-style keywords like :ff1212, and defing these is generally a good idea

but if you find yourself doing stuff like {constants/keyword-a 123, constants/keyword-b true} a lot, then you’ll probably want to consider @alexmiller’s points

There's autocomplete for keywords in cider

@UK0810AQ2 no? maybe? direct linking eliminates var lookup for invocation but I don't remember if you get the same effect for resolution. it would also potentially ruin the optimized keyword call site invocation used in record lookups.

Cursive also has keyword autocomplete

I see. And if I define it as :const there will be no lookup as well because the compiler will inline it?

it should in that case. but this seems to me to be going increasingly far just to avoid doing the simple thing

Go to definition doesn't always work if you just use keywords, so that is one point in favor of defing. An example where that comes up a lot is re-frame, since it uses this pattern for registering handlers: (rf/reg-event-db :my-keyword (fn [...] ...)

But the definition you jump to will be pointless

@U09LZR36F Not if you use a macro, and tell Cursive to resolve it like a def

@U15RYEQPJ hard disagree about vars to keywords, if you want the compiler enforcement there's more effective options than def of a keyword, and it makes the code harder to read rather than easier

to me human readability is first priority

@alexmiller (and others): points taken 🙂 I’m not so worried about invocation optimization (in my current app) as I am about readability and safe refactorability. I don’t think it’d make sense to def all of your constants - the example that @U15RYEQPJ brought up, {constants/keyword-a 123, constants/keyword-b true}, is in the silly end. Rather, I’m considering using constants for string values whose literal representation might change slightly over time (outside of my power), and whose semantic value (and usage of the same) in the application should not be disrupted by these changes. In addition, there’s quite a few of them, and their literal representations can be very similar, so the extra layer of indirection gives a chance to make them more dissimilar + to attach docstrings.

with that scope, seems reasonable

@U0AQ3HP9U if I don't control the string used as a key in a data structure, and especially if someone else can decide to change that string, I prefer to have an explicit re-keying step (with a single mapping, used locally in one place), rather than changing a key that is dereferenced throughout the app

I think one of the biggest clojure antipatterns is the transition from "use vanilla data type and simple keys" to "use the data representation provided by some external API in all application logic"

@U051SS2EU the string is not used as a key in a data structure, it’s used as a val in predicates. Like I posted originally, (when (= role constants/my-role) .... But I get your point, I think. In the case of the key being used in maps, for example, you’d do

(->> my-domain-data-map 
     (map (fn [[k v]] 
            [(get rekeying-map k k) v])) 
     (into {})

yes - sorry, this is most frequently seen in keys, but even vals should be translated if they are symbolic constants as opposed to primitive types IMHO

Right. Thank you for your thoughts 🙂

Kibana, Instana and Zabbix are the other options