That's an interesting idea except I'm not sure exactly at what phase all of the cljs namespaces will be visible to the clj macro (since it's not like they exist as actual clj namespaces).

Maybe there's something very simple I'm missing.

ClojureScript has an analyzer API you can use from Clojure

https://cljs.github.io/api/compiler/cljs.analyzer.api/

It contains all-ns too

Ah ok - that is a good hint. I will give it a look - I've never dug into it, and know very little about it. But thank you so much!

and this analyzer api you can use from a macro

Having said that, I often just enumerate things manually because that always works ;)

Ok last question - to experiment, should I just be able to require that cljs.analyzer.api and experiment in a clj namespace ?

good question. I haven't used this myself a lot, but I will try it out now :)

Don't take up your time doing this, please - I can experiment and read the code and stuff. And as you say, manually enumerating isn't a bad option. Or I could probably make my own ns macro with some side-effects that does the enumeration for me, if I only care about my own namespaces.

No worries, I'm curious about this myself too.

When I add a macro in .clj file, e.g. I added one in sci.core:

(require '[cljs.analyzer.api :as api])
#?(:clj
   (defmacro foo []
     (println (api/all-ns))
     nil))

And then in a CLJS repl:

cljs.user=> (require '[sci.core :refer-macros [foo]])
nil
cljs.user=> (foo)

I get a ton of namespaces:

(sci.impl.opts cljs.env.macros sci.impl.macros cljs.tools.reader.impl.commons sci.impl.types cljs.tools.reader.edn

Ok perfect. So I guess we can rely on the analyzer in our cljs macros and all the namespaces have already been analyzed or whatever. Thank you, borkdude.

To be specific: this is in normal CLJS and the macro is running in the JVM, calling the cljs.analyzer.api in the JVM. Then all-ns enumerates all CLJS namespaces create so far, after having already loaded/compiled those.

So if I do this:

#?(:clj
   (do
     (require '[cljs.analyzer.api :as api])
     (defmacro foo []
       (prn (api/ns-publics (first (api/all-ns))))
       nil)
     ))

I will get back a map of all public CLJS "vars" of the first namespace:

{default-classes {:name sci.impl.opts/default-classes, :file "/Users/borkdude/Dropbox/dev/clojure/babashka/sci/src/sci/impl/opts.cljc", :line 47, :column 1, :end-line 47, :end-column 21, :meta {:file "/Users/borkdude/Dropbox/dev/clojure/babashka/sci/src/sci/impl/opts.cljc", :line 47, :column 6, :end-line 47, :end-column 21}, :tag cljs.core/IMap},

so this way you can get the names of all the public vars of all the namespaces at compile time

and then use them to generate CLJS code

I should probably document this

This is perfect - I think it's a great trick potentially. When you said before that all-ns enumerates all namespaces created "so far", I'm not exactly sure what that means - maybe just so far in terms of that point in the compilation or macroexpansion of all the namespaces?

I expect that when you don't load any namespaces, it doesn't go out and read stuff from disk.

So you first have to load namespaces and then call all-ns to see what namespaces exist

Similar to how all-ns in clojure works

Yes, makes sense. I find cljs macros so confusing (compared to clj). I'm still puzzling out certain issues, but this will certainly work! Thank you again.

yes, it's confusing because they run at compile time in the JVM but then target CLJS code

Yea but I mean like ... ok, here's a macro:

(defmacro cljs-namespaces
  []
  (let [namespaces (map ns-name (ana/all-ns))]
    `(list [email protected])))

That returns a list of strings, where I'd expect symbols.

So I always find things a bit more "weird" even than in normal macros, which are sometimes substantially weird to begin with.

Anyway - you've been a great help, so thank you and have a nice weekend!

ns-name always returns a string

all-ns already returns a list of symbols

I misunderstood the docs.

ns-name accidentally works here

Yeah, I just need to quote the symbols, because in the macro the symbol gets expanded to the actual namespace object itself.

since it calls .-name on the object and doing this on a symbol returns a string

correct

I misunderstood the doc string for ns-name, since it ends with "a symbol", but it clearly means the ns argument is a symbol. And yeah, it all makes sense.

(Like most things in software, when it seems like something crazy is happening, it's usually my fault)

very recognizable ;)

I think I've got something:

cljs.user=> (def ns-map (copy-ns clojure.edn (sci.core/create-ns 'clojure.edn nil)))
#'cljs.user/ns-map
cljs.user=> (def read-string (get ns-map 'read-string))
#'cljs.user/read-string
cljs.user=> (read-string "{:a 1}")
{:a 1}

Hmm! Very nice.

I'm still struggling a bit in cljs macro universe, but I know this will all eventually work.

This is the impl:

(defn copy-ns-fn [ns-publics-map sci-ns]
  (reduce (fn [ns-map [var-name var]]
            (let [m #?(:clj (meta var)
                       :cljs (:meta var))
                  no-doc (:no-doc m)
                  doc (:doc m)
                  arglists (:arglists m)]
              (if no-doc ns-map
                  (assoc ns-map var-name
                         (new-var (symbol var-name) #?(:clj @var
                                                       :cljs (:val var))
                                  (cond-> {:ns sci-ns
                                           :name (:name m)}
                                    (:macro m) (assoc :macro true)
                                    doc (assoc :doc doc)
                                    arglists (assoc :arglists arglists)))))))
          {}
          ns-publics-map))

#?(:clj
   (defmacro copy-ns [ns-sym sci-ns]
     (macros/? :clj `(copy-ns-fn (ns-publics ~ns-sym) ~sci-ns )
               :cljs (let [publics-map (cljs.analyzer.api/ns-publics ns-sym)
                           publics-map (zipmap (map (fn [k]
                                                      (list 'quote k))
                                                    (keys publics-map))
                                               (map (fn [m]
                                                      {:name (list 'quote (:name m))
                                                       :val (:name m)
                                                       :meta (select-keys (:meta m) [:arglists
                                                                                     :no-doc
                                                                                     :doc])})
                                                    (vals publics-map)))]
                       ;; (prn publics-map)
                       `(copy-ns-fn ~publics-map ~sci-ns)))))

It works for both clojure and clojurescript

I'll add it to sci.core ...

or maybe sci.experimental? or a doc page first ;)

let's do a doc page first ;)

Thank you for that ! Sure, maybe being cautious is best.

I'll give it a try on my side as well while trying to banish the bootstrap build from my application.

I've never seen macros/? before but I can imagine what it does.

It comes from macrovich which I vendored in sci

Very neat.

it allows you to target environments during compilation time

Ok, gotta run to the market. Thank you again!

@pmooser I added copy-ns to the sci.core namespace now.

(defmacro copy-ns
    "Returns map of names to SCI vars as a result of copying public
  Clojure vars from ns-sym (a quoted symbol). Attaches sci-ns (result
  of sci/create-ns) to meta. Copies :name, :macro :doc, :no-doc
  and :argslists metadata."
    ([ns-sym sci-ns] `(copy-ns ~ns-sym ~sci-ns nil))
    ([ns-sym sci-ns _opts]

It still requires you to provide the name of the namespace.

(copy-ns 'clojure.edn (sci/create-ns 'clojure.edn))

It should work in both CLJ and CLJS.

ok, that's the code I based the new sci/copy-ns on

we can make a configurable metadata function which default to identity, dunno

yea, I was checking out the implementation and recognized it! 😄

one consideration is that in some envs you don't want to copy the docstrings for example

for smaller JS bundles

so it has to be configurable anyway

yea, that makes sense

bundle size for common sci targets like graalvm and cljs both make sense to exclude unnecessary/misleading metadata

I might also suggest a 1-arity call to copy-ns that defaults to (sci/create-ns ns-sym) as the sci-ns

yeah, I also thought of that. would it be ok if you could pass a set of metadata keys or an option to select all? since this is a macro the options are kinda static

it's a macro because of CLJS basically

I need to be able to exclude certain vars at compile time in the macro in CLJS

for problematic macro things

I guess if you choose all metadata you can postprocess the vars as well (could expose alter-meta! in the sci API)

Oh I guess it already works with regular alter-meta!

user=> (meta (doto (sci/new-var 'foo) (alter-meta! assoc :foo 1)))
{:foo 1}

sound great

I probably won't get a chance to look at it soon, but looks :thumbsup: