(pug ...) and (vlua ...) macros

[rktjmp]

Here are two helper macros I use which make using "one off" functions more easier in keymaps.

(pug ...) or "Put/Pin Unique Global" will accept any type or function and store it in Lua's global namespace (_G) under a unique name. This let is you easily pin functions for use in other places such as keymaps. It returns the unique name.

;; Put Unique Global
;;
;; (val :any prefix? :string) -> (uuid :string)
;;
;; Takes any given value, generates a unique name (with optional prefix)
;; and inserts value into _G. Returns unique name.
(fn pug [val prefix?]
  ;; gensym will generate a unique id across a compile pass, but hotpot may compile 
  ;; files in separate passes as they are modified, so symbols may collide
  ;; you can avoid this by passing a unique prefix per-file or using something
  ;; like the "uid" below, based on compile time
  (local inter-compile-uid (_G.os.date "%s"))
  (local name (if prefix?
                (.. (tostring (gensym prefix?)) inter-compile-uid)
                (.. (tostring (gensym :pug)) inter-compile-uid)))

  `(do
     (tset _G ,name ,val)
     ,name))

Usage:

(fn show-window []
  ;; some code to show a window
  (nvim....))

(nvim_set_keymap "n"
                 "<leader>n"
                 (.. ":lua " (pug show-window) "()<cr>")
                 {:noremap true :silent true})

(vlua ...) is a convenience wrapper around pug that returns a v:lua...() expression for use in keymaps:

;; Wrap given in v:lua x pug call
(fn vlua [what prefix?]
  `(.. "v:lua." ,(pug what prefix?) "()"))

Usage:

(fn tab-or-x []
  (if something
    (termcode "<Tab>")
    (termcode "<C-x>")))

(nvim_set_keymap "n"
                 "<leader>x"
                 (vlua tab-or-x)
                 {:expr true})

[bangedorrunt]

@rktjmp, have you got any idea why this return in invalid expression v:lua

(fn autocmd! [events pattern command]
  "Defines an autocommand"
  (let [events (if (sequence? events) events [events])
        events (-> (map ->str events)
                   (table.concat ","))
        pattern (if (sequence? pattern) pattern [pattern])
        pattern (-> (map ->str pattern)
                    (table.concat ","))]
    (if (fn? command)
        `(vim.cmd ,(string.format "autocmd %s %s call v:lua.%s()" events pattern (pug command)))
        `(vim.cmd ,(string.format "autocmd %s %s %s" events pattern command)))))

[rktjmp]

If you inspect the cached output file, you'll probably see that the pug macro code is never being injected, just the end result (the "pug id"). The code that sets _G.pug_... = command is never actually output by the macro, only run at compile time and you end up with

vim.cmd autocmd Event Pat v:lua.pug_NN() but _G.pug_NN is never set.

You can use a binding like this to see the cache file:

(fn maybe-open-cache-file []
  (match ((. (require :hotpot.api.cache) :cache-path-for-fnl-file) (vim.fn.expand "%:p"))
    nil (print "No matching cache file for current file")
    path (vim.cmd (.. ":new " path))))
(wk.register {:hh {:name "+hotpot"
                   :f  [(.. ":lua " (pug maybe-open-cache-file) "()<cr>")
                        "Open hotpot cache for current fnl file"]}
             {:prefix "<leader>"})

The simplest fix would be to run your own gensym stuff in your macro, so your if form becomes something like:

(if fn? command
  (let [id (gensym :autocmds)] ; note the warning in pug, where we set a "uuid" prefix which you may want to do
    `(do
       (tset _G ,id ,command)
       (vim.cmd ,(string.format "autocmd %s %s v:lua.%s()"
                                :BufEnter :* id)))))

As for using pug, I have not tried to use a macro-in-macro like this so I am not sure of the answer yet but I am curious.

I know you can build code lists in a macro like so:

(let [body `(do)] ; `(do) is a `list` type which contains code (my understanding) which is why you can insert expressions
  (table.insert body `(print :hello))
  (table.insert body `(print :world))
  body)

I think there is maybe a combination of that and macroexpand that would get what we want maybe, but I am not 100% sure on macroexpands function, it doesn't quite behave how I expect from the docs.

This is just pseudo code

I imagine there is some way to do this but I am not sure how:

(macro auto [command]
  (local pug-ast (generate-code-for-macro (pug command))) ; gives us (tset _G...
  (local id-from-pug (run-ast pug-ast)) ; returns pug_NNN id
  `(do
     ,pug-ast ; output the tset code
     (vim.cmd ,(string.format "autocmd v:lua.%s()" id-from-pug))) ; unquotes formatted string but inserts correct id

[rktjmp]

You can do this:

• run the macro in "compiler scope" which returns the AST/List
• extract the last expression in the AST, which is the generated ID
• unquote the ast
• use the the extracted id in the format string

; have to define as "fn" type macro with pug in scope or import pug in the macro
(fn autocmd! [events pattern command]
  "Defines an autocommand"
  (fn ->str [x] (tostring x))
  (fn map [via over]
    (icollect [_ o (ipairs over)]
              (via o)))
  (fn fn? [x] (list? command))

  (let [events (if (sequence? events) events [events])
        events (-> (map ->str events)
                   (table.concat ","))
        pattern (if (sequence? pattern) pattern [pattern])
        pattern (-> (map ->str pattern)
                    (table.concat ","))]
    (if (fn? command)
      (do
        (local pug-ast (pug command)) ; returns ast/list from pug macro
        (local pug-id (. pug-ast (length pug-ast))) ; get last instruction (which is the id to return)
        `(do
           ,pug-ast ; output pug _G code
           (vim.cmd ,(string.format "autocmd %s %s call v:lua.%s()"
                                    events pattern pug-id)))) ; use id we extracted
      `(vim.cmd ,(string.format "autocmd %s %s %s" events pattern command)))))

I can't say how good of an idea this is. Modifying the AST in a macro doesn't seem too bad (why else have access to the AST otherwise) but it's brittle to say the least. You may fair better splitting pug into an id-gen function and a _G-put function and just using it that way in the autocmd macro.

[bangedorrunt]

@rktjmp, many thanks for your very detailed explanation!

If you inspect the cached output file, you'll probably see that the pug macro code is never being injected, just the end result (the "pug id"). The code that sets _G.pug_... = command is never actually output by the macro, only run at compile time and you end up with vim.cmd autocmd Event Pat v:lua.pug_NN() but _G.pug_NN is never set.

That's absolutely make sense, though atm I haven't fully understand how macro works, especially nested macros.
I wanna confirm that your solution indeed works. That is very similar to the following

;; Shameless clone from @datwaft config
(global __core_symfn_id 0)
(fn gensym-fn! []
  "Generates a new unique variable name following the structure `__core_symfn_#`"
  (.. "__core_symfn_"
      (do
        (global __core_symfn_id (inc __core_symfn_id))
        __core_symfn_id)))
(fn autocmd! [events pattern command]
  "Defines an autocommand"
  (let [events (if (sequence? events) events [events])
        events (-> (map ->str events)
                   (table.concat ","))
        pattern (if (sequence? pattern) pattern [pattern])
        pattern (-> (map ->str pattern)
                    (table.concat ","))]
    (if (fn? command)
        (let [fn-name (gensym-fn!)]
          `(do
             (global ,(sym fn-name) ,command)
             (vim.cmd ,(string.format "autocmd %s %s call v:lua.%s()" events
                                      pattern fn-name))))
        `(vim.cmd ,(string.format "autocmd %s %s %s" events pattern command)))))

However, later on, I also found out a workaround, we don't need to change pug macros at all by flattening out nested macros. The following works for me

(fn autocmd! [events pattern command]
  "Defines an autocommand"
  (let [events (if (sequence? events) events [events])
        events (-> (map ->str events)
                   (table.concat ","))
        pattern (if (sequence? pattern) pattern [pattern])
        pattern (-> (map ->str pattern)
                    (table.concat ","))]
    (if (fn? command)
        `(vim.cmd (string.format "autocmd %s %s call v:lua.%s()" ,events ,pattern ,(pug command)))
        `(vim.cmd ,(string.format "autocmd %s %s %s" events pattern command)))))

Your insights about this solution are aprreciated