A big part of a macro being a macro is that it doesn't evaluate its arguments...

(i know i can use clj->js to convert, just wonder what people normally do when they want to evaluate a thing before sending to a macro)Generally speaking, you don't want to evaluate forms before sending them to a macro. In many cases, you can just have your macro work the with form, eg:

(defmacro my-macro [form]
  `(let [val# ~form]
     (do-something val#)))

@U060QKK2P8V @U7RJTCH6J thanks for all all your replies! this is my use case: let's say i have a js obj, which has an "js array" in obj.a.aa, (i construct it by (j/lit {:a {:aa [1 2 3 4]}}) in this example)

(j/update-in! (j/lit {:a {:aa [1 2 3 4]}}) [:a :aa] (fn [x] (clj->js (mapv inc x))))

(j/update-in! (j/lit {:a {:aa [1 2 3 4]}}) [:a :aa] (fn [x] (j/lit (mapv inc x))))

What does j/lit do?

and does it need to be a macro, in the first place?

As a general rule, avoid using macros as much as you can

j/lit returns literal js objects/arrays for an arbitrarily nested structure of maps/vectors from https://github.com/applied-science/js-interop

i was thinking replace clj->js with j/lit

It looks like j/lit is for literals and mapv inc x) is not a literal

i guess j/lit will be more performant than clj->js (i am not sure yet haha)

If the work can be done at runtime compile time (see correction below), then j/lit can help, but if the value is only available at runtime, then a macro has little benefit.

"If the work can be done at runtime" do you mean compile time

whoops. yea.

gocha, thanks for your help! looks like i will stick to clj->js for now~

(defmacro with-span
      "Wrap the body in a tracing span identified by `ident`.
      If body returns a promise, this will return a promise as well."
      [[ident opts] & body]
      `(do
        (start-span* ~ident ~opts)
        (let [result# (do ~@body)]
          (if (p/promise? result#)
            (p/then result#
                    (fn [x#]
                      (finish-span* ~ident {})
                      x#))
            (do (finish-span* ~ident {})
                result#)))))

I tried getting some help by ChatGPT, which seemed helpful at first but ultimately told me to come here: > If you continue to experience issues, it might be helpful to create a minimal reproducible example that isolates the problem, which you can use to seek further assistance from the ClojureScript community or on forums like ClojureVerse or the Clojurians Slack. 😅

https://code.thheller.com/blog/shadow-cljs/2019/10/12/clojurescript-macros.html

remember that macros are in CLJ, not CLJS

can't tell if you did that part correctly from the code

I was trying to use that blogpost as a guide, after moving the macro into a separate .clj file it seems to work as expected 🙂 thank you for writing it!

I guess it means it was added quickly and never revisited since then.

Nevertheless it works well

Maybe related ticket: • https://clojure.atlassian.net/browse/CLJS-2527 Just log here. I'm preparing to raise it to #C07UQ678E

FWIW, I'd prefer for the ES6 functions to stay. Some JS APIs use the ES6 iterators (e.g. URLSearchParams.entries), GCL uses them at least in goog.iter.

sorry I meant remove the “EXPERIMENTAl” part - actually removing a fn - no way 🙂

Ah! Phew.

(I had to use exactly because of URLSearchParams.entries)

Those properties are from JS, not CLJS. I'd suggest looking them up on the MDN website. The keyholder property doesn't sound familiar at all though, so perhaps it comes from some JS library.