I tried different quoting around "clj -Spath" and I get various errors

in posix shells runs a subshell

So it means run the command clj -Spath and insert its output here

So if you can do something like that in powershell

https://stackoverflow.com/questions/44281699/bash-batch-like-subshell-in-powershell#44281958

Thank you @U0NCTKEV8!!

wouldn't

[:or
   conj-auth
   google-auth]

That works!

Commutative schemas? Schema multiplication? Schema matrices? sin(schema)? 😄 But yes, currently I merge my schema "by hand" with my hardcoded defaults :thinking_face:

and multi multi is certainly schema multiplication 🙂

Maybe like this. I interpret your runtime as "non top level".

(ns handler)

(prn :file *file*)

(defn foo []
  (prn :file *file*))

(defmacro bar []
  (prn :file *file* )
  `(prn :file *file*))

(bar) ;; compile time :file

(defn baz []
  ;; compile time file and runtime file
  (bar))

(defn -main [& _args]
  (foo)
  (baz))

$ clj -Scp $(clojure -Spath):/tmp -M -m handler
:file "handler.clj"
:file "handler.clj"
:file "handler.clj"
:file "handler.clj"
:file "NO_SOURCE_PATH"
:file "NO_SOURCE_PATH"

You can add a println or spit anywhere in your code to see if something is being evaluated e.g.

(ns my-namespace)

(println "hello")
(spit "abc.txt" "evaluated")

(defn test[] (println "hello2"))

thanks!

Plumatic Schema recently added a s/defprotocol that does stuff with methodImplCache - worth checking out?

I'll look, but having peeked a bit into the core implementation I have an educated guess what it's doing

sound similar to this - https://clojurians.slack.com/archives/C03S1KBA2/p1669021808743179

Some tips for debugging this kind of thing: • Try undoing your change to be sure that it really is clojure depdency change that caused the issue. • Make sure you have cleaned the target directory (e.g. with lein use lein clean) • Try compiling the code outside of REPL (e.g. with lein use lein check) • Compare the full dependency graph before + after your change (e.g. with lein run lein deps :tree ) • Try eliminating a bunch of your code + dependencies until the error goes away. Then add them back slowly to see was causing the issue. • It's possible that the bug is a dependency conflict

@UJVEQPAKS I have done just that

it seems that the problem is core.async related

if I rollback to the older version everything works perfectly

@U9BQ06G6T Search for __thunk__0__ here on slack, it has been reported before this week

Yes, @U04V4KLKC has pointed me to that topic, I have checked the aot compilation of the suggested namespace, but either I am doing something wrong (which shouldn’t be to far from the truth) or the solution doesn’t work for me

Thanks everyone for your input

Not sure, but it's trivial to nest them if you don't want that behaviour (binding [a 1] (binding [b 2] ...)) I agree that it's odd that they follow a different convention to let. I'm not sure which convention is more proper. It might just have been arbitrarily easier to do it this way when they wrote the code for it.

> why are clojure bindings evaluated in parallel? (binding [a ... b ...]) I'd say it's because it's implemented in terms of with-bindings which accepts a hashmap (i.e. unordered semantics) ...of course one API doesn't have to be coupled to the other. my wild guess is that they initially were, then it was a little too late to fix it?

yeah i'm about to write a bindings2 macro to de-pyramid a set of bindings

I think making it like let would be completely backwards compatible (but not the other way around).

yeah it seems just lazy / good enough impl

however it's a reasonable concern to not invite people to write code in clojure 1.N that would not correctly work in clojure 1.(N - 1)

wouldn’t making it like let break the existing behavior?

user=> (binding [*a* 10
                 *b* (+ *a* 1)]
         (+ *a* *b*))
12
user=> (binding [*a* 10]
         (binding [*b* (+ *a* 1)]
           (+ *a* *b*)))
21

>

all init-exprs are evaluated
> before the vars are bound to their new values.

you get * value before the binding, not after the binding

in my second example, like let, it uses the newly bound value of *a* (1) rather than the before-all-bindings value of *a* (10)

yes you're right

Oops - was thinking about the case where the binding didn't exist already.

that condition doesn’t exist here > Creates new bindings for the (already-existing) vars

ie was thinking of

(binding [*a* 10
          *b* (+ *a* 1)] ;;<-- Null pointer exception a is nil (not yet bound)
         (+ *a* *b*))

Would be odd for someone to be relying on this

user=> (binding [*a* 10
                 *b* (+ *a* 1)]
         (+ *a* *b*))
12

that’s the docstring described behavior right? Wouldn’t it be odd to rely on behavior contrary to the indicated behavior?

I agree that they can rely on it since the docstring says that. I just expect it's probably very rare case in the wild (given your + my illustrations above). So it would technically be a breaking change but breaking very little.

For me, I don't think the change is required though since I don't think we want to make binding particularly more common.

we’re just using numbers. but lots of printing stuff uses this. from nrepl:

(binding [*print-readably* true
          *print-length*   nil
          *print-level*    nil]
  (doto out
    (.write (str %))
    (.flush)))

(def data1 (delay (edn/read-string (io/resource "foo/bar.edn"))))

Sadly, these are a lot of data but they have a lot of code too (`defcard` is a macro, for example)

(defcard "Underway Grid"
  {:events [{:event :pre-expose
             :req (req (same-server? card target))
             :msg "prevent 1 card from being exposed"
             :effect (req (expose-prevent 1))}]
   :constant-effects [{:type :bypass-ice
                       :req (req (same-server? card target))
                       :value false}]})

don’t forget load and load-file

oh yeah, i forgot about those. interesting, maybe I can use that

i think the source of pprint in Clojure can serve as prior art

Thank you, that's great

To follow up on this, when is it better to use in-ns vs ns? Given that calling ns multiple times on the same namespace is additive, seems like there's no reason except semantic clarity to use in-ns

my preference is to use ns to define namespaces and in-ns to switch to a namespace programatically. Seeing multiple ns forms for the same ns would be strange to me (and might confuse tooling)

user=> (.interrupt (Thread/currentThread))
nil
user=> (Thread/sleep 100)
Execution error (InterruptedException) at java.lang.Thread/sleep (Thread.java:-2).
sleep interrupted
user=>

My problem is that I don't know who is interrupting me

if you are re-using threads (I think thread pools are good about clearing this) then it could be something else running on the thread was interrupted, then your code runs on the thread, then you go to sleep and the interrupt flag is still set on the thread

but yeah, I believe interrupted exceptions can get thrown at jvm shutdown

I would think the web server/library (request timeouts)

thanks both! I'll deploy a dummy endpoint that sleeps forever and observe what happens after: • some 60s (e.g. a timeout possibly propagated by nginx and then jetty) • jvm shutdown (following a re-deployment)