@noisesmith like the CLR (common language runtime)?

Ahhh, that says it is written on .net

and clojurescript on js yeah

I am reading about Graal for native machine code compilations

I should try writing a performance test to see how much faster Graal could be?

Graal will be slower at peak, but faster at startup

It also has a ton of restrictions

Can’t reflect, some parts of the JDK won’t work, etc.

It’s a weird non-Java environment

I would call it frozen dairy dessert, not ice cream

Java already JITs to machine code, quite well

I've got a bit of code that produces a map from a list of maps, where each of those original maps has a value i'm using as the key in the produced map. e.g, turning [{:id 1 :name "foo" :tag "wee"} {:id 2 :name "bar" :tag "splat"}] into {1 {:id 1 :name "foo" :tag "wee"} 2 {:id 2 :name "bar" :tag "splat"}}

right now I'm using a reduce, is there a more idiomatic option?

e.g. (reduce #(assoc %1 (:id %2) %2) {} my-coll)

that's good @robertfrederickwarner. You can generalize it, too:

(defn into-map
  [keyf valf coll]
  (reduce (fn [m v]
            (assoc m (keyf v) (valf v)))
          {}
          coll))

(def d [{:id 1 :name "foo" :tag "wee"} {:id 2 :name "bar" :tag "splat"}])

(group-by :id d)
=> {1 [{:id 1, :name "foo", :tag "wee"}], 2 [{:id 2, :name "bar", :tag "splat"}]}

Thanks! Yeah group-by isn't quite the right fit here (I'm converting results from a db query into a lookup, so I know there are no dupes), but another handy function to know about

or even:

(defn index-by
  ([keyf coll]
   (index-by keyf identity coll))
  ([keyf valf coll]
   (reduce (fn [m v]
             (let [k (keyf v)]
               (if (find m k)
                 (throw (ex-info "Duplicate key" {:k k}))
                 (assoc m k (valf v)))))
           {}
           coll))
  ([keyf valf mergef coll]
   (reduce (fn [m v]
             (let [k (keyf v)]
               (if-let [entry (find m k)]
                 (assoc m k (mergef (val entry) (valf v)))
                 (assoc m k (valf v)))))
           {}
           coll)))

sorry, no docstring

(index-by :id collection) (it would throw an exception on a duplicate key)

https://www.reddit.com/r/Clojure/comments/8iw3b8/plain_groupby_for_unique_values/

dang, none of those impls in the reddit link throw if you get non-unique values

i ran across this tweet this morning: "A Clojure love story: Presses "p" in a specific place in the file. Now the program runs faster. The end." What would he be referring to here? Is this a clojure way to make something "parallel" or something?

https://clojuredocs.org/clojure.core/pmap

cool, thanks! I'm far from needing to learn optimizations and such at this point but it's still fun to explore

there are no magic bullets in programming. (Implicit) parallelisation is no exception to the rule

I think I linked it here a dozen of times, but http://clojure-goes-fast.com/blog/ is quite insightful about performance

Maybe a bit of a stupid question, I am using a wrapper around java.time that wraps java.time’s exception into an ExceptionInfo. Can I catch warpped exceptions more specifically then just catching ExceptionInfo (or Exception, or …)

@lennart.buit (try ... (catch ExceptionInfo ....) (catch Exception ...)) works

I forget if it goes with first match or most precise, but I always order them narrow to wide regardless

right, catching Exception works in my case, I was just wondering whether there was a way to be more specific about what wrapped exception I was expecting. Having been taught to always catch the most specific one ^^

you can't even catch a wrapped exception - you catch something and then check if it wraps something

you could write a macro that makes it look like you are catching a wrapped exception I guess

right, thanks

I think I’ll check the cause, and if it doesn’t make sense, just re-raise it

for the error reporting to pick it up ^^

yeah, that's how I always do a selective catch that can't just go on the type

try / catch / maybe throw

I have some scripts that I need to run. I am on osx. What command do I need to run? I know a super beginner questions

@bmaddy adding a solution for the nested group-by above:

(defn nest-by
  [ks coll]
  (reduce
   (fn [m x] (update-in m ((apply juxt ks) x) (fnil conj []) x))
   {}
   coll))

@undothis When you say "scripts", do you mean Clojure or something else?

Perhaps he is referring to the shebang? #!/usr/bin/env bash