(as opposed to (/ 1 0) — that one is caught, as it's runtime)

Move eval inside try. So it's (eval 'xxx).

It worked 👍

Do you think it's a good/valid approach to testing macros when they expected to blow up on invalid input?

Probably, I can't think of any issues with that.

Thanks a ton! 🙂

I think a better approach is to isolate the data part of the macro. I often start writing my macros using the following form:

(defn my-macro* [args]
  ;; actual logic
  )
(defmacro my-macro [& args]
  (my-macro* args))

In many cases, you can just test my-macro*. It makes writing macros much easier.

But it won't help that much with testing for compiler errors. Stuff like (let [x]).

That's true.

Sure, my actual defmacro is already a one-liner, all logic is in functions. So the actual question is: does it make sense to have an explicit test for when the macro is supplied with unexpected input that it results in a (nice, expected) exception?

If it's a nice and expected exception, then it's probably not a compiler exception. In that case, it's a check in one of the functions that you control that you used in that macro. So it would make sense to test those functions instead, without any eval.

That makes sense, thank you.

is is itself an assertion of truthiness (technically that is the default condition of is, it actually comes down to a multimethod where you can add custom kinds of assertions)

if x is a truthy value (is x)

Ah...

Thanks!

the set of keywords that the reader will read is significantly smaller than the set of keywords that you can create using something like the clojure.core/keyword function (which is what cheshire uses)

str is also not the best way to serialize things to be read later, that is pr-str (similar to the diff between println and prn)

Right, I have run into the keyword problem before. Just can't figure out why the @ is not allowed or what the reader is doing with it.

https://clojure.org/reference/reader#_literals has a section on what is allowed in a literal (a readable) keyword

https://clojure.org/reference/reader#_symbols is the section on symbols which is referenced by the keyword section

in particular > Symbols begin with a non-numeric character and can contain alphanumeric characters and *, +, !, -, _, ', ?, <, > and = (other characters may be allowed eventually).

there have been extension proposed to allow for printing and reading otherwise unreadable symbols and keywords, but nothing has been actually implemented

Ahhh "a keyword is like a symbol"

specifically here, @ is a token delimiter in the reader, so it's trying to parse ":" as a symbol or keyword