bb var branch:

$ ./bb "(def x 10) (defn foo [] x) (def x 11) (println (foo)) #'foo"
11
#'foo

$ bb "(def f (fn [& xs] (apply + xs))) (apply #'f (range 10))"
45

the var-thing worked fine here :thumbsup:

The grey areas of Clojure/Script:

cljs.user=> (defmacro ^:dynamic foo [])
#'cljs.user/foo
cljs.user=> (binding [foo 10] foo)
10

user=> (defmacro ^:dynamic foo [])
#'user/foo
user=> (binding [foo 10] foo)
Syntax error compiling at (REPL:1:1).
Can't take value of a macro: #'user/foo

for the cljs case, i've been unclear whether there is a canonical place to test this kind of thing -- somehow i have the impression that depending on which place this is tried the answer can differ (e.g. lumo, shadow-cljs, planck, etc.)

vars are a grey area in CLJS anyway

they don't really exist except in the REPL (or something)

...and that repl appears to often be implemented differently in each of shadow-cljs, lumo, planck, etc., iiuc

riiight

complicates writing tooling

anyway, cool that vars seem to be coming along 🙂

yeah, one thing I'm still pondering about is the public API for creating Sci vars

right now it looks like this:

(defn new-var
  "Returns a new sci var."
  ([name] (new-var name nil nil))
  ([name val] (new-var name val (meta name)))
  ([name init-val meta] (sci.impl.vars.SciVar. init-val name meta)))

(defn new-dynamic-var
  "Same as new-var but adds :dynamic true to meta."
  ([name] (new-dynamic-var name nil nil))
  ([name init-val] (new-dynamic-var name init-val (meta name)))
  ([name init-val meta] (sci.impl.vars.SciVar. init-val name (assoc meta :dynamic true))))

I started with the Var definition of CLJS which doesn't seem to be doing that: https://github.com/clojure/clojurescript/blob/23cedecbf4f704f9fee672e395bbfa1e3fe3ee1a/src/main/cljs/cljs/core.cljs#L1118

ah maybe they just used the namespaced symbol as a field

that could work, since it's not really that important to which namespace a var belongs in sci

fixed 🙂

$ lein run "(def x 10) #'x"
#'user/x

i guess the comparison is to this (Var.java)?

static Keyword privateKey = Keyword.intern(null, "private");
static IPersistentMap privateMeta = new PersistentArrayMap(new Object[]{privateKey, Boolean.TRUE});
static Keyword macroKey = Keyword.intern(null, "macro");
static Keyword nameKey = Keyword.intern(null, "name");
static Keyword nsKey = Keyword.intern(null, "ns");

those are just keywords made in Java

lol, so they are

so in CLJS there isn't an explicit namespace field in the type, but in CLJ there is: https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/jvm/clojure/lang/Var.java#L90

but sci doesn't really have reified namespaces...

another rabbit hole I guess 🙂

🐇 🕳️ that one means not going down at the moment, 🕳️ 🐇 this one means about to go down

I should probably add the *ns* dynamic var and that should have some contents...

ClojureScript 1.10.520
cljs.user=> *ns*
#object[cljs.core.Namespace]

that is only used in self-hosted CLJS: https://github.com/clojure/clojurescript/blob/23cedecbf4f704f9fee672e395bbfa1e3fe3ee1a/src/main/cljs/cljs/core.cljs#L11560

it's certainly convenient to have

I'll make another deftype for it

what do people use *ns* for in practice beyond inspecting what the current ns is? define vars in other namespaces?

except that it doesn't work:

$ clj -e "(binding [*ns* (find-ns 'clojure.core)] (def x 1))"
#'user/x

my primary use case is the current ns -- i think i've used it in some tooling code

(do (in-ns 'user) (binding [*ns* (find-ns 'clojure.core)] (print *ns*)))
#object[clojure.lang.Namespace 0x1c801a1a clojure.core]

that was done in a non-clojure.core ns

yes, but def doesn't work there

def might always take the root binding of *ns*, I don't know exactly how it works

i am pretty sure i understand it even less 🙂

well, it's good to find out before I implement it 😉

i happen to be reading eval() in Compiler.java and noticed that things that start with "def" seem to be special-cased -- not sure if that is related

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Compiler.java#L7172

I was also reading that 🙂

I was reading the code for DefExpr

but it's unclear to me where the Var argument gets created: https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/jvm/clojure/lang/Compiler.java#L424

it seems to be created in the aptly named method lookupVar... https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/jvm/clojure/lang/Compiler.java#L7458

this part is also interesting. it seems to be using a method called currentNS, we're getting closer

https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/jvm/clojure/lang/Compiler.java#L548

ah: https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/jvm/clojure/lang/Compiler.java#L7518 it really seems to be using the dynamic var

so it's a bit surprising why the def example with binding didn't work

this does work:

user=> (ns bar) (ns foo)
nil
nil
foo=> (set! *ns* (find-ns 'foo))
#object[clojure.lang.Namespace 0x485e36bc "foo"]
foo=> (set! *ns* (find-ns 'bar))
#object[clojure.lang.Namespace 0x17cdf2d0 "bar"]
bar=>

lol, without the initial (ns bar), i just had my repl die 🙂

i tried (set! **ns** (find-ns 'bar))

DefExpr's eval has:

var.bindRoot(init.eval());

oh that just sets the root binding

lol, it really kills your REPL

(defn exit-repl [] (set! *ns* (symbol (str (java.util.UUID/randomUUID)))))

this method appears to be the only place that uses DefExpr: https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/jvm/clojure/lang/Compiler.java#L530

check #clojure, hiredman explained what's going on

ah, thanks

the current ns is checked at an earlier phase than the binding occurs

must...remember...compile...time

same thing for plk:

$ plk -e "(ns foo) (ns bar) (binding [*ns* (find-ns 'foo)] (def x 1))"
WARNING: foo is a single segment namespace at line 1
WARNING: bar is a single segment namespace at line 1
#'bar/x

$ /usr/local/bin/joker
Welcome to joker v0.12.4. Use EOF (Ctrl-D) or SIGINT (Ctrl-C) to exit.
user=> (set! *ns* (find-ns 'foo))
<repl>:1:2: Parse error: Unable to resolve symbol: set!

I'm not sure if it would be bad if babashka would return #'foo/x, I might have to try hard to produce the same (unexpected for me) result of clojure and cljs

we'll see

i'm not sure the current case is so common -- putting a def directly in the body of a binding.

could be handy to be able to search for such patterns across all of the latest clojars jars 🙂

well, since it's doesn't really do anything useful, I don't expect this to be anywhere really, but I made a not of it, implementing the same behavior in bb / sci will work

it's pretty funny that the current namespace is denoted by a var, but that a var always has a namespace