i think i remember this being discussed recently, but are clojurescript keywords immutable and allocated? The reason being can someone flood the environment with many keywords and eventually exhaust the storage of them?

i thought i remembered a discussion that both clojure and cljs intern keywords and you cannot unallocate them?

@dpsutton There is the aspect that they participate in :optimize-constants: https://github.com/clojure/clojurescript/wiki/Compiler-Options#optimize-constants

But there would only be a bounded number of those. I suppose you are concerned with dynamically-created keywords.

is that what was optimized recently? I lurk in here but don't usually participate

yes.

someone asking if their framework pulls them out of query strings can someone be malicious

No, the recent optimization you are recalling is likely related to ^:const inlining

ah yes i confused the two

A dynamically-created keyword (created via cljs.core/keyword) is just a deftype instance.

In other words, (->Keyword nil "foo" "foo" 1268894036) is :foo

so just an object that can be collected then?

i thought i heard about something like a weak reference cache

I can’t see any other way of looking at it. (source keyword) doesn’t seem to register them (there’s only about 20 lines of code there.)

Perhaps there is something interesting in Clojure, and thus identical? vs. keyword-identical? being needed in ClojureScript.

i'll look into that. thanks @mfikes

Yeah @dpsutton in Clojure you can see (source keyword) using clojure.lang.Keyword/intern

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Keyword.java#L32

yeah looks like a weak reference hash which means it can never be gc'd i believe

Well, it is not a WeakHashMap, so the ConcurrentHashMap entries would at least stick around, even if the guts of the values are gc’d

hmmm

(defn emits-keyword [kw]
  (let [ns   (namespace kw)
        name (name kw)]
    (emits "new cljs.core.Keyword(")
    (emit-constant ns)
    (emits ",")
    (emit-constant name)
    (emits ",")
    (emit-constant (if ns
                     (str ns "/" name)
                     name))
    (emits ",")
    (emit-constant (hash kw))
    (emits ")")))

Right, if you fire up a REPL in :repl-verbose mode you will see that :foo gets emitted as

new cljs.core.Keyword(null,"foo","foo",(1268894036))

ah ok

and that's just the deftype you were mentioned before

interesting that the hash is a parameter passed in

The hash is not pre-calculated if instead you do (keyword "foo")

So runtime keywords are lazy, compile-time are eager, wrt hashing

totally makes sense. thanks for taking the time! super helpful

This loop is not causing memory to grow for me (empirical verification)

(loop [n 0]
  (keyword (str "kw" n))
  (recur (inc n)))

In cljs, if compiler option :optimize-constants is true, keyword and symbol literals will be "interned" (defined only once globally and included by reference in code) at compile time. The compiler will also precompute their hash, since clj and cljs hash symbols and keywords the same

But runtime keywords/symbols are never interned and don't precompute hashes.

I think clj used to intern more but stopped

In js interning is impossible without leaking memory

It has no weak refs

thanks @favila. side note, we need to do lunch again soon