Question

Various special characters in clojure are abbreviations for things

(quote (a b)) is the same as '(a b)

as you can see by evaluating:

user> ''(a b)
(quote (a b))

This seems to be syntax as abbreviation, which strikes me as a fine idea.

But the syntax-quote, ` , seems special. I can’t think what would be equivalent to

`(a b)

I would have guessed something like (syntax-quote (a b)) , but it doesn’t work, and if I’ve just guessed wrong, I can’t find out what it’s really called.

user> '`(a b)
(clojure.core/seq (clojure.core/concat (clojure.core/list (quote user/a)) (clojure.core/list (quote user/b))))

Is a bit mystifying.

Presumably the reader’s doing something special, maybe because it needs to know the namespaces?

Interestingly, the special syntax used in the syntax-quote does work as I expected:

user> '~a
(clojure.core/unquote a)
user> '~@a
(clojure.core/unquote-splicing a)
user> '~'a
(clojure.core/unquote (quote a))

except for this one:

user> 'a#
a#

Which I would have thought produced something like (unquote (gensym "a"))

I do realise that I’m being a bit feeble here, and should just go and read the code. If no-one fancies explaining what’s going on or giving a reference, can anyone give me a hint about how to find the relevant code and what to look for?

Answer 1

I don’t think there’s a syntax-quote equivalent of the quote function.

The Clojure reader is (currently) written in Java. The SyntaxQuoteReader class in src/jvm/clojure/lang/LispReader.java in the Clojure source is probably what you’ll want to read. It seems rather complex. You can see it building lists like (seq (concat ...)) there.

                ret = RT.list(SEQ, RT.cons(CONCAT, sqExpandList(seq)));

It’s common for the reader not to return straightforward Clojure code, but rather do the right thing in Java-land immediately. For example '[1 2 3] doesn’t yield the Clojure code (vector 1 2 3). Maybe it could work that way somehow, but it doesn’t. The reader just creates and returns the vector object itself.

Likewise, the SyntaxQuoteReader does some magic in Java immediately to resolve symbol namespaces and create gensyms itself and it returns some mangled and complicated-looking Clojure code that does the right thing, but isn’t necessarily easy for a human to read. Whether it’s like this because it has to be, or because it’s easier to do it this way in Java, or for performance or some other reason, I don’t know. Likewise I don’t know if quasiquote could exist as a plain macro/special form in Clojure and doesn’t, or if it couldn’t exist at all. I don’t see why it couldn’t though.

WrappingReader in the same file is the class that handles ' (plain old quote). You can see that it just wraps whatever you pass it in a list containing the symbol quote plus your argument. It’s much simpler. Note that this class also handles @, so that '@foo does return (deref foo).

This thread might shed some more light.

Edit

Here’s a proof-of-concept quasiquote macro. Note that this code is relying upon and abusing Clojure internals in a horrible way. Please don’t use this for anything.

user> (defmacro quasiquote [x]
        (let [m (.getDeclaredMethod clojure.lang.LispReader$SyntaxQuoteReader 
                                    "syntaxQuote" 
                                    (into-array [Object]))]
          (.setAccessible m true)
          (.invoke m nil (into-array [x]))))
#'user/quasiquote
user> (let [x 123] `(x 'x ~x))
(user/x (quote user/x) 123)
user> (let [x 123] (quasiquote (x 'x ~x)))
(user/x (quote user/x) 123)