How to nest quasiquotes?

[glyh]

I'm trying to inject binaries in PATH to python's scope, here's what I got:

(defmacro inject-binaries [#* names]
  `(do
    ~@(lfor name names 
       `(defmacro ~name [#* args]
           `(subprocess.run (+ (, (str ~~name)) ~args))))))

It's not working because if you try this:

(hy.macroexpand-1
 '(inject-binaries ls pwd))

You would get:

(do (defmacro ls [#* args] `(subprocess.run (+ (, (str ~'ls)) ~args))) (defmacro pwd [#* args] `(subprocess.run (+ (, (str ~'pwd)) ~args))))

Which is wrong because it seems like ' and ~ don't cancel up.

I'm fairly new to lisps, so this may seem silly.
I would be grateful if you can point out what is wrong with my code. Thanks a lot!

[Kodiologist]

I think this may be a bug. But, why produce macros, anyway? Functions would have the same effect:

(defmacro inject-binaries [#* names]
  `(do
    ~@(lfor name names 
       `(defn ~name [#* args]
           (subprocess.run (+ (, ~(str name)) args))))))

[glyh]

well, you can't get (ls -la) if this is a function

[Kodiologist]

I thought you wanted to evaluate the arguments as Hy expressions. You have ~args above rather than ~(map str args) or whatever. If they're always constant strings, you can say

(defmacro inject-binaries [#* names]
  `(do
    ~@(lfor name names 
       `(defmacro ~name [#* args]
           (hy.models.Expression ['subprocess.run
              (hy.models.Expression [', ~(str name) #* (map str args)])])))))

or, arguably more reasonably,

(eval-when-compile
  (for [name (.split "ls mkdir touch")]
    (hy.eval `(defmacro ~name [#* args]
      (hy.models.Expression ['subprocess.run
         (hy.models.Expression [', ~(str name) #* (map str args)])])))))

[glyh]

Thank you, but this does not seem like the traditional way lisp macros is handled( not by construct AST manually, but just write S-exps).

Should I file an issue?

[Kodiologist]

Already done: #2252.

[Kodiologist]

Here's a belated but more to-the-point answer, now that I've done a deep dive into nested quasiquotation. With the new syntax for tuples (#( … ) instead of the old (, … )), inject-binaries should be written and used like this:

(defmacro inject-binaries [#* names]
  `(do
    ~@(lfor name names 
      `(defmacro ~name [#* args]
        `(hy.M.subprocess.run #(~'~(str name) ~@(map str args)))))))

(inject-binaries ls mkdir)
(ls -la)

The trick here is ~'~, which Bawden (1999, p. 10) describes as a "cliché" of nested quasiquotation, better understood as a unit than reconstructed each time you use it.

Bawden, A. (1999). Quasiquotation in Lisp. ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation. Retrieved from https://3e8.org/pub/scheme/doc/Quasiquotation%20in%20Lisp%20(Bawden).pdf