did you read the intern doc string?

"The var will adopt any metadata from the name symbol."

(intern 'foo (with-meta 'bar {:doc "docs"}) (fn [] "baz"))

for nrepl based IDEs this will work as they query the runtime for docs. For static based tooling this will not work (Cursive, clojure-lsp)

Thanks!

If this is for a macro or something, normally I just switch ns call defn and switch back

it is for a macro

Ya, so I don't remember perfectly, but what I've done in the past is something like:

(let [previous-ns *ns*]
  (ns foo)
  (defn bar []
  "Some doc"
  :baz)
  (in-ns previous-ns))

I think maybe you need to wrap *ns* with ns-name or something. But this is the gist of it.

Oooooh that's a good one. I'm gonna try something like that! Thanks!

the println is run about 50 times, with values that look good. All keys k are distinct

but then the metadata I generate only has about 8 elements, not 50

what could be going on? as mentioned the keys are distinct so each assoc call is not overwriting the prior entries

how do you know the keys are distinct?

it's data I know very well and also I checked out the printlns again

how many items are in row?

the println is run once for each item in row, and for each row in rows

the swap! is the same

but columns only contains a value for each item in row

row has 32 items. I verified again that all printed keys are different (32 different keys exactly)

hmmm, the original code that didn't completely work was using transient/persistent!. now with atoms it works as intended

does that ring a bell?

yeah, bashing in place on transient/persitent!

using them like they are a mutable collection

you can't just ignore the return values of like conj!

sometimes it returns a new thing, sometimes it mutates the existing thing

hmmm, I was using assoc! , looks like the bang misguided me

same thing

all the docs on transients tell you not to do this

not on assoc! ?

the transient docs https://clojure.org/reference/transients grep for "bash in place"

sadly the docstring didn't hint so. I can't keep the ref guide in my head for arbitrarily long

I also specifically don't like that it the uses ! convention but it pretends to be pure. Seems an odd hybrid. :)

it doesn't pretend to be pure

it mutates things, but sometimes returns a new structure

like, the contract is you have to use the return value

easiest thing is to just not use transients ever

> like, the contract is you have to use the return value I'll see if I can add this as an Eastwood rule, it has it easy to declare "don't use x as a side-effect"

they are an optimization inside things like into

> easiest thing is to just not use transients ever yeah never was a fan but I was dragged into them lately.

but if the transient usage is outside of clojure.core best to assume it has this bug unless proven correct, people refuse to read the docs on transients and just say "hey, mutable collections!"

someone implement the transient java interface on top of redis, ignoring the contract and the possibility of calling persistent! and it made the frontpage of http://lobste.rs

first rule of transients club is to write an algo with ordinary persistent data structures, then sprinkle transients only at the end

Feel free to check out this test case, I think that's it, but you might be able to come up with some extra nuance https://github.com/jonase/eastwood/pull/442/files#diff-e26378bf60c68079448d682ee1e4918b16dd7f2e8e989c474de436cde11b176f

If you want mutable collections, use mutable collections like Java.util.HashMap. If you want to speed up some updates to persistent collections in a local context, you can make them transient temporarily, the nice thing is they follow the same pattern as their persistent counterpart so you don't need to change your code one bit. That's why you have to use their return. They're designed to be used like persistent collections so it's easy to go from persistent -> transient with minimal code change. That's an awesome feature in my opinion.

Also, the ! suffix started as a way to indicate something wasn't safe in a Ref transaction. The community later took to liking it to mean side-effects/impure/mutable things. But as far as I know, all core functions take it to still mean not safe in transactions.