> Default reader tags are defined in > clojure.core/default-data-readers but may be overridden in > data_readers.clj, data_readers.cljc, or by rebinding this Var.

(binding [*data-readers* {'foo/bar `int}]
  #foo/bar 3)
Syntax error reading source at (REPL:74:13).
No reader function for tag foo/bar

from the docstring of data-readers i expect i can dynamically add a namespaced data reader and use it in this fashion but i seem to be missing something

you are adding it too late

the whole form has to be read, then evaled before your binding is in effect

like so?

(binding [*data-readers* {'foo/bar `int}]
  (clojure.edn/read-string "#foo/bar 3"))

if you like, that will error or return nil

it throws an error for me still

which error

No reader function for tag foo/bar

and using read:

(binding [*data-readers* {'foo/bar `int}]
  (read-string "#foo/bar 3"))
Execution error at find.main/eval8981 (REPL:104).
No dispatch macro for: f

the clojure.edn reading functions take those things as explicit passed in maps

the var for rebinding only effects the actual reader

the read-string version here, right?

i don't understand why that complained about a dispatch macro for f

ah, i don't need the quote on this version. int not `int

it is a map from symbols to functions

so a quoted symbol is pretty much never what you want there

Map from reader tag symbols to data reader Vars.
 When Clojure starts, it searches for files named 'data_readers.clj'
and 'data_readers.cljc' at the root of the classpath. Each such file
must contain a literal map of symbols, like this:
     {foo/bar my.project.foo/bar
     foo/baz my.project/baz}

That’s where I got confused. Map of symbols so I assumed it needed namespaces qualified symbols

Thanks for your help

yeah, symbols are only if you are creating a data_readers.clj file

they are resolved before being installed in *data-readers* then

Hi all! A question about https://github.com/l3nz/cli-matic: Do I have to use a sub-command? Does it support no command style? Something like: my_app --some_param=1 some_argument

Was surprised to find that my ETL pipeline spends a considerable amount in SSL processing (JDK 8, for now). I don’t control the code that handles the connections (MongoDB and JDBC Postgres) - is there a way to speed things up other than throwing hardware at the problem?

With ScheduledThreadPoolExecutor available, is there any Clojure job scheduler (at-at, overtone, tea-time) that gives any added value?

I like ScheduledThreadPoolExecutor but it does not make many decisions for you and by default you may do the wrong thing (e.g long running jobs blocking the pool)

I am not too familiar with clojure schedulers, as I am pretty comfortable ScheduledThreadPoolExecutor but perhaps they provide an easier api with sane defaults

Hi there! 👋 I try to solve a special problem and I am looking for a function/lib, that could help me. Let’s say, I got a function and a list of items. Now I want to call the function on parallel with each item of the list and just want the result of the fastest thread (and dump all other threads without waiting for them). Something like wanted-fun in here:

(def l [100 200 300])

(defn fun [x] (Thread/sleep x) x)

(wanted-fun fun l) ; >> 100 (after ~100 miliseconds)

@soeren.gutzeit isn't fun already that function? or do you mean something like (defn wanted-fun [f x] (f x))?

@soeren.gutzeit :

(def l [100 200 300])
(defn fun [x] (Thread/sleep x) x)
(some fun l) ;;=> 100 

if you want the first succeeding result from multiple threads, you can use something like core.async or promises:

(def prom (promise))

(future (Thread/sleep 100) (deliver prom 1))
(future (deliver prom 2))

@prom ;;=> 2

I’m not sure I’ve really got the hang of core.async yet, but here’s what I came up with:

(require '[clojure.core.async :refer [go chan >!!  <!! alts!!]])
=> nil
(def l [100 200 300])
=> #'user/l
(defn fun [x] (Thread/sleep x) x)
=> #'user/fun
(defn wanted-fun [f coll]
  (let [ports (map (fn [l]
                     (let [ch (chan 1)]
                       (>!! ch (f l))
                       ch))
                   coll)]
    (first (alts!! ports))))
=> #'user/wanted-fun
(wanted-fun fun l)
=> 100

See also: https://www.braveclojure.com/core-async/

wow, thanks!

@manutter51 slight variation, where the sleeping happens not on the main thread:

(require '[clojure.core.async :refer [go alts!!]])

(def l [100 200 300])

(defn fun [x] (Thread/sleep x) x)

(defn wanted-fun [f coll]
  (let [ports (map (fn [l]
                     (go (f l)))
                   coll)]
    (first (alts!! ports))))

(prn (wanted-fun fun l))

Nice, the go automatically creates the chans for you? I never realized that but then again I did know that go returns a chan so I guess I shoulda known.

go and async/thread both return channels that contain the result of that async computation. in this case async/thread might be a better choice than go since sleeping in a go block might not make sense.

Would that work with alts!! though? If you just want to get whichever one comes back first, and ignore the others, I’m not sure how to do that with async/thread (due to my lack of experience with the async stuff)

Rather frequently, I have some data that contains object literals referencing some java class but if I try to copy-paste this into repl it fails:

{:id 308, :time-now "2020-03-04T16:48:39.000Z" :created-at #object[org.joda.time.DateTime 0x799dfbe "2020-03-04T16:48:39.000Z"], :updated-at #object[org.joda.time.DateTime 0x9cae937 "2020-03-04T16:48:42.000Z"], :status :failure}
...
No reader function for tag object

@jumar you can transform this stuff using edn/read-string with :reader or :default and a good default could be tagged-literal

@jumar

user=> (edn/read-string {:default tagged-literal} "{:id 308, :time-now \"2020-03-04T16:48:39.000Z\" :created-at #object[org.joda.time.DateTime 0x799dfbe \"2020-03-04T16:48:39.000Z\"]}")
{:id 308, :time-now "2020-03-04T16:48:39.000Z", :created-at #object [org.joda.time.DateTime 127524798 "2020-03-04T16:48:39.000Z"]}

Say one wants to pass a server port as an arg to main. Is there a way to pass opts or an opts map to be read/coerced to edn? currently everything is interpreted as a string, so port becomes "port" , :port ":port" and 8080 "8080" while the goal is {:port 8080} clj -m my.server port 8080

Nothing built in. Boot defined some stuff.

https://github.com/clojure/tools.cli can help with this

perfect thank you @alexmiller

hi all! today im taking my first steps to learning Clojure. i was mainly convinced by the positive response to this tweet 🙂 https://twitter.com/tangjeff0/status/1234688533367050244?s=20 hope to keep in touch with everyone for the next 10+ years! haha

welcome! #beginners is a great place to ask questions...

or https://ask.clojure.org for searching or creating a record of good q&a

I'm in need of a bit of code to take an accept-lang header and turn it into an iso 639-1 language code. I'm poking around to see if I can find something pre-existing to do that - does anyone know of anything in clojure-land (or optionally java land) to do that?

https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html#forLanguageTag(java.lang.String) and #getISO3Language ?

that looks quite promising, thanks!

user=> (.getISO3Language (java.util.Locale/forLanguageTag "en-US"))
"eng"

it's close - I need to end up with the 2 letter code, but I suspect I can find what I need here

What do you all use for moving the current time forward in tests?

I don't -- I make the time a parameter

Java has a clock object for that.

(defn inject-$val [val form]
  `(let [~'$val ~val]
     ~form))

(eval (inject-$val (StringBuilder.) '(pr-str $val)))
=> 
Syntax error compiling fn*.
Can't embed object in code, maybe print-dup not defined: 

I'm processing messages coming over a core.async channel, and I'd like to pipe them to another channel with a weird caveat. The messages that represent success I want to pipe unconditionally and immediately, but the messages that represent failure I want to delay sending them for some grace period, and forgo sending them if a success message arrives before the grace period elapses. My first thought is to use some kind of stateful transducer but I'm having a hard time finding examples of transducers that do delayed delivery of the result, or that make behavior for the nth item conditional based on the n+1th item. Am I trying to use transducers for something they weren't designed for?

imo doesn't sound very transducery. sounds like a go-loop with some state

There are plenty of options for doing it in a go-loop. I am hoping to find something that is a bit more constrained and concise than that.

seems arbitrary

channel transducers run within the context of the channel mutex; interactions with other channels are verboten

channel transducers also run in band, they can only pass or not pass through (possibly transformed) data, they can't sit on data and wait

the reason you can't find examples of transducers that do delayed delivery is it isn't something they can do

Yeah I think the delayed aspect is what's going to stop me here. I can imagine storing some internal state in a transducer that only gets returned when some other new input arrives, but that would have to happen synchronously with the new input arriving, and can't happen at an arbitrary time between inputs.

when you have a hammer transducer, everything looks like a nail

the tricky requirement is:

> forgo sending them if a success message arrives before the grace period elapses

which means you have to listen to both a timeout and some success/cancel signal

This is essentially a low-pass filter, so the idea is conceptually somewhat simple and I'm struggling to find the correspondingly simple implementation.

it is pretty straight forward with alts!

(fn [in out] (async/go-loop [t nil] (let [[a-val a-ch] (async/alts! (some->> t (conj [in]))] (cond (and (= ch in) (success? val)) (do (async/>! out a-val) (recur t)) (= ch in) (recur (asnc/go (async/<! (async/timeout 1000)) a-val)) (= ch t) (do (async/>! out a-val) (recur nil))))))

(dictated but not read, etc)

Putting the pending failures each in their own delayed channel helps a lot

There's another wrinkle here where there may be several failure messages that are pending before the timeout elapses or a success arrives, but it's relatively simple to extend this to a queue of pending failures

the thing to watch out for if you are managing multiple timeout channels is avoid using them directly as keys for maps or members of sets

because timeout can return the same channel more than once, so not a good key or set member, but if you create a go block that takes from the timeout and returns something useful that is less likely to bite you

Are you talking about the equality gotcha related to optimizing multiple timeouts that happen close to each other?

right

When creating a function that is an intermediate processing step in a core.async process, is it more idiomatic to have the function take the in-chan as an argument and return an out-chan that was created internally, or take the out-chan as an argument and return an in-chan that was created internally, or take both as arguments, or take neither?

I like to take both an in and out, and then the function returns the channel from the go block it starts, which another process can wait on if they want to wait for that process to stop