Is it possible to write a macro that generates reader conditional code?

I'm not sure, but roughly reasoning from the idea that Clojure reads your code (and that is when reader conditional processing occurs), and then later compiles your code, which is when macro expansion occurs, I do not see how it is possible to write such a macro.

Unless you consider cases where the macro generates code that causes the reader to explicitly be invoked again on strings.

But don't take my guess here as authoritative on your question.

well, I don’t actually need to run the code in the same JVM, I only want to generate a form and emit it to a file, so I can run it later

e.g. this one:

(defn main-form []
  `(defn -main [& args]
     (time (run-tests 20))
     #?(:clj (shutdown-agents))))

where the number 20 must be variable

So you need to write a program that writes as its output the text of another program? You don't need a macro for that, do you?

you can detect the macro compilation environment with a trick @borkdude https://github.com/plumatic/schema/blob/master/src/clj/schema/macros.clj

the program writes a program that will be executed in a different process. let me rephrase the question: how can I generate a quoted list with a reader conditional in it

e.g. '#?(:clj (shutdown-agents)) doesn’t work

Try (reader-conditional '(:clj (shutdown-agents)))

Not sure if that is what you are looking for, but it may be.

yeah 🙂

thanks

Oops: I mean (reader-conditional '(:clj (shutdown-agents)) false)

figured that out 🙂

Once we have established that something (A) is equal to another thing (B), then why would a set containing just A not be equal with a set containing just B?

(let [jud (java.util.Date.)
      jst (java.sql.Timestamp. (.getTime jud))]
  (= jud jst))

;; => true

(let [jud (java.util.Date.)
      jst (java.sql.Timestamp. (.getTime jud))]
  (= #{jud} #{jst}))

;; => false

I think @qrthey that java mutable stuff might not have the same deep-equality guarantees for this.

both values hash to the same value

(let [jud (java.util.Date.)
      jst (java.sql.Timestamp. (.getTime jud))]
  (= (hash jud)
     (hash jst)))

;; => true

Same goes for list/vectors of these types

(let [jud (java.util.Date.)
      jst (java.sql.Timestamp. (.getTime jud))]
  (= [jud] [jst]))

;; => true

It is just that sets don't work for this. There is probably an explanation, and I would like to understand this better, but in any case this is rather unexpected.

it prolly defers to j.u.set .contains which will check the type

or something like that

The values are considered 'different' as they both will co-exist in a set.

(let [jud (java.util.Date.)
      jst (java.sql.Timestamp. (.getTime jud))]
  (count #{jud jst}))

;; => 2

yeah, diff types so that makes sense

And I thought functional programming would bring me closer to mathematics 😉

there's some trickery done with numbers to avoid this in some cases I think

but that's it

lol: https://github.com/slipset/speculative/issues/113

doesn't this go into: "garbage in-out" territory

well, probably people have looked at the source of merge and decided it’s a good conj replacement 🙂

but yeah, it’s probably not idiomatic use

Thanks for your input @mpenet and @orestis. It would be nice to have some insight from the language maintainers on the reasons for the set weirdness though.

(= {:d jud} {:d jst})

;; => true

but as keys, they are not equal again

(let [jud (java.util.Date.)
      jst (java.sql.Timestamp. (.getTime jud))]
  (assoc {jud 'ok} jst 'nok))

;; =>
{#inst "2018-11-13T11:17:02.919-00:00" ok,
 #inst "2018-11-13T11:17:02.919000000-00:00" nok}

is 4clojure the website still maintained or more or less abandoned?

I wonder if it makes sense to move it to #clj-commons if the latter

They are mutable. Imagine a set that behaved the way that you are wishing for. Have two dates that are different put into the set. Then mutate one of them so that they are equal. The set would then contain two values that are the same in violation of it's constraints

just curious, why (keys {:test "a"}) returns [:test], but not #{:test}? set semantics seems more valid in this context - no order, no duplication

(type (keys {:a 1}))
clojure.lang.APersistentMap$KeySeq

it’s a special type, probably optimized for some use cases

i see…

thanks

@kirill.salykin you are right, but there are some nice things about the implementation. If you also take vals from the map, you get vector semantics as well, which is nice as the order of the keys result will match the order of the vals result.

(let [v {:a 1 :b 2 :c 3}]
  (= v (zipmap (keys v) (vals v))))

i am not sure order is applicable in this case

@dpsutton Thanks, that is a valid reason. It goes on to demonstrate that equality is undefined when dealing with mutable values.

i mean I doubt order of keys garantied to be same as vals

@kirill.salykin it is.

The order is hard to predict, but it is stable.

seq, keys, vals order are guaranteed to be the same on a map

oh, didnt know it thanks

@dpsutton If only java could have been sane and dates etc had been immutable...

It’s mentioned in the docstring I believe

> “Returns a sequence of the map’s values, in the same order as (seq map).”

this part I assume

Tough thing about mutability and equality is you need to talk about "when" they are equal and when they become equal

@alexmiller thanks

@qrthey thanks as well

I want to filter a list of elements in a xml file by iterating the list with zip/right and zip/remove the elements which I want to filter out. The problem is, that zip/remove will move the loc to the deepest element of the previous node. Is there an easy way to keep the loc at the same level it was before removing?

@burke Do you know about clojure.data.zip.xml to filter zipped xml?

https://clojure.github.io/data.zip/

@benoit I thought this was only useful for "filtering" in the sense of "searching" for specific elements. I want to modify the zipper to then export it as a new xml document. I'll take a closer look to data.zip.xml, thanks

Is there an idiomatic version of this construct? (fnil conj #{}) I have some code where I often call (update m k #((fnil conj #{}) % some-val)) to add some value to a set in a map. Is there a better way?

you don't need to make the #() there - (update m k (fnil conj #{}) some-val) does the same thing

I'm trying to upgrade to clojure 1.9. I've successfully been using data.avl/sorted-maps but it returns two-elem vectors instead of actual mapentries, and 1.9 seems stricter, as (key/val %) doesn't anymore work on two-elem vectors. I can fix my code, but avl makes the same assumption internally, for example in its (subrange). is there a workardound or best practice to deal with this?

oof, that seems like a bad breaking change

yeah I was pretty surprised. I couldn't find anything about it though, but somebody else must have run into it

It is conceivable you are the first person to notice. I suspect Clojure's built in sorted sets are used a lot more than data.avl's.

going back to 1.7.0 (I didn't look further) - key doesn't work on [1 2]

I think it was changed temporarily during the tuple foray sha: ae7acfeecda1e70cdba96bfa189b451ec999de2e

😕

so it's not a breaking change, in other words

how so?

is there a clojure version where key works on [1 2]?

yes

ah, I should have kept looking

or, I dunno, I was pretty sure that it worked

hmm interesting. the project that uses data.avl/sortedmap has always used 1.8 AFAIK and it's worked fine, didn't think much of it

I must just be misremembering

and all the times I've done (for [x y] (key x)) y has been something that started as a map

for VER in 2 3 4 5 6 7 8 9; do echo 1.$VER.0; clojure -Sdeps "{:deps {org.clojure/clojure {:mvn/version \"1.$VER.0\"}}}" -e '(key [1 2])'; done

couldn't find one

bikeshed of the shell code: $(seq 2 9)

thanks I changed it after having the 1.10-alphas 🙂

is it possible to call default methods when implementing interfaces with reify?

sooo... sounds like key/val for 2-elem vectors is not coming back? why does (first (first {1 2})) work, or is that gonna go away as well? in the meantime, I forked and fixed data.avl for my purposes

From the discussion above, it isn't clear to me what "went away". Did anything change across Clojure versions here that is relevant to data.avl?

Also the first first {1 2} uses the fact that mapentry implements seq which isn't going away since that would be a breaking change

@kaosko Ghadi's little shell script above is evidence that Clojure 1.8 also throws an exception if you try (key [1 2]) on a vector.

It isn't just Clojure 1.9. It is all Clojure versions since Clojure 1.2. Perhaps the root cause of the issue is something else?

@andy.fingerhut hmm how odd, must be something else then

It could be that something changed from Cloure 1.8 to Clojure 1.9 such that data.avl is now returning 2-element vectors, when it used to return map-entries?

I would love to see some context around the code.

error repro, etc.

yeah cljs repl prints: app:cljs.user=> (type (first (clojure.data.avl/sorted-map 0 0))) cljs.core/PersistentVector

whereas clj: (type (first (clojure.data.avl/sorted-map 0 0))) => clojure.data.avl.AVLNode

You may want to try asking on the #clojurescript or #cljs-dev channels to see if the ClojureScript developers are aware of any recent changes in that area.

If the issue you are seeing is specific to ClojureScript

yes seems so, thanks

what a good pattern for conditionally inserting forms in a macro?

~@(when (some-condition) ....) should work, if the ... expands to a list or vector

I’m trying to make a thing with reify that inserts methods if there is a key in the map passed in, so something like:

(defmacro reify-foo [opts]
  `(reify Foo
     (when ~(opts :foo)
       (foo [this]))))

but I’m running into all kinds of issues with quoting

I would have done ~@(when (opts :foo) ...)

because your version always has the foo inside the when in the output form, which won't work with reify

here’s the actual thing:

(defn websocket-listener
  ([{:keys [on-binary on-close on-error on-open on-ping on-pong on-text]}]
   `(reify WebSocket$Listener
      ~@(when on-binary
          (onBinary [this ws byte-buffer last?]
            (on-binary ws byte-buffer last?))))))

then you might need quoting around (foo [this] ...) thanks to the surrounding unquote, but that's not hard to do

I think the intention should be clear there, but the quoting is real

yeah, I think you need another backtick around (onBinary ...)

otherwise the macro tries to execute onBinary which is likely nonsense

ahh, here we go! 😄

(defn websocket-listener-fast
  ([{:keys [on-binary on-close on-error on-open on-ping on-pong on-text]}]
   `(let [ob# ~on-binary]
     (reify WebSocket$Listener
       ~@(when on-binary
           `(onBinary [this# ws# byte-buffer# last?#]
              (ob# ws# byte-buffer# last?#)))))))

that is some incomprehensible code right there

sometimes breaking some of it out into a helper function can make it clearer what's happening

minimal example of the principle though

Clojure 1.9.0
(ins)user=> (defmacro foo-object [with-bar?] `(reify Object ~@(when with-bar? `[(toString [this] "bar")])))
#'user/foo-object
(ins)user=> (foo-object true)
#object[user$eval150$reify__151 0x23fb172e "bar"]
(ins)user=> (foo-object false)
#object[user$eval154$reify__155 0x5e1fa5b1 "user$eval154$reify__155@5e1fa5b1"]

I wish reify was more data-y

@schmee are you sure that onBinary inside the when isn't missing another layer of nesting for the @ to consume?

@lilactown at least macros are 100% data-y :D

this one is tested and actually works 😂

(defn websocket-listener-fast
  ([{:keys [on-binary on-close on-error on-open on-ping on-pong on-text]}]
   `(let [~'ob ~on-binary]
     (reify WebSocket$Listener
       ~@(when on-binary
           [`(~'onBinary [_# ws# byte-buffer# last?#]
              (~'ob ws# byte-buffer# last?#))])))))

I wouldn't have noticed except that same issue tripped me up in my minimal example (and the error you get when expanding the macro is really unhelpful...)

@schmee I don't know if I understand the whole context of what you want to do, but you may be able to use a function instead of a macro and conditionally specify! the protocols/methods onto a plain object at runtime

is specify! new?

Or... maybe it is just a ClojureScript thing

seems like it

In which case never mind :)