I vaguely recall a recent discussion around that, but this is the closest I can find: https://github.com/metabase/metabase/blob/master/bin/build-mb/src/build/licenses.clj

Thanks!

clj -X:deps list will give you a list of libs and licenses in the path

but not the actual licenses themselves, depending what you need

Amazing, did not know this exists! Thanks for the hint, I will use the license-info function in my custom tooling

Does asking GitHub to ignore whitespace changes not help here?

This is a savior. Had no idea that kind of functionality existed at all! Thanks

Yeah, I wish there was a way to enable it by default without a user-script that just redirects you to a URL with w=1. :)

Also, for local compares, I find https://github.com/Wilfred/difftastic pretty sweet.

https://clojurians.slack.com/archives/C03S1KBA2/p1651016212832969

Thanks for the link... so would you recommend something like:

(defn print-prefix-map-without-commas
  ...

(with-redef [clojure.core/print-prefix-map print-prefix-map-without-commas]
  (do-my-stuff-that-doesn't-like-commas

with-redefs is not thread-safe. If that's alright for you, then sure. But zprint should work in either case, although I haven't used it myself.

Thread safety is not going to be an issue for me... I might look into zprint later, since it seems to be supporting cljs just fine

Again, thanks! 💜

When reporting a problem like this, a full repro would help. E.g. I can't reproduce your problem by trying a bunch of things:

Clojure 1.11.0
user=> (into [] (map identity) [1 2 3])
[1 2 3]
user=> (into [] (map identity) (list 1 2 3))
[1 2 3]

OK thanks, I was reporting for a colleague - I’ll get the transducer code to share

(defn chunks-xf [max-chunk-size]
  (fn [xf]
    (let [chunk (volatile! ::none)]
      (fn
        ([] (xf))
        ([result]
         ;; flush what ever is left in chunk
         (let [final @chunk]
           (if (not= final ::none)
             (xf result final)
             (xf result))))
        ([result input]
         (cond
           (= @chunk ::none)
           (do (vreset! chunk input)
               result)

           (<= (+ (count @chunk) (count input)) max-chunk-size)
           (do
             (vreset! chunk (str @chunk input))
             result)

           :else
           (let [prev @chunk]
             (vreset! chunk input)
             (xf result prev))))))))

(into [] (chunks-xf 100) ["sentence 1", "sentence 2"])]

hmm, looks like we should probably be calling (xf result) in all terminal cases, so this is probably a bug in our existing code

bug on our side, needed to call (rf (rf result final) in our reducing function or we missed the last element, and didn’t call the reducing function with 1 arity thanks for looking!

unrelated but why not use (comp (partition-all 100) (map clojure.string/join)) ? you're bulding a lot of intermediate strings there

(or at least use a stringbuilder for chunk's value)

Yer I'm aware of this - came across this when upgrading an existing project and haven't seen the code before

Clojure does not allow conditional reads in .clj files, only in .cljc files

Oh riiiight

btw, bb has support for java.time as well

but if some classes are missing, that you need, please make an issue

E.g. java.time.temporal.WeekFields is missing it seems

I needed WeekFields via JVM but I wasn't going to use this code in babashka. It simply was part of the namespace that was included. So I wanted to exclude it. Edit: I wanted to exclude it because it was crashing.

you can call namespace on the keys themselves to get the namespace portion:

(comment
  (namespace :a/my)
  (let [val {:a/my-a-val "hi" :b/some-key "bye"}
        ks  (keys val)]
    (map namespace ks)))

Yeah, there's no shortcut for it, you gotta type it all out:

(defn f [args]
  (let [by-ns (fn [ns]
                (into {}
                      (filter #(= (name ns) (namespace (key %))))
                      args))
        a-args (by-ns :a)
        b-args (by-ns :b)]
    ...))

I'd be concerned about why you'd be passing data to a function that didn't know what keys it needed to pull out...?

Hmm. It's unfortunate then that there's no straight forward way. I'm using this to sort-of "categorize" my data, thinking that's exactly what namespaces are for, so that I could pass the whole of a to one place, and b to another, with those places then having to care about specific destructuring, while my "middle man" would not.

Unless that "middle man" cares about all the kvs, I'd probably go with {:a {...}, :b {...}} instead.

Yeah, will do just that! Thanks for the feedback.

if you're wanting different fns to handle things differently depending on which key namespaces are being passed, perhaps use a defmulti where the selector does something like (fn [m] (-> m keys first namespace)), then each defmethod would handle the the implementation for that keyspace

of course that's super naive, may be entirely not what you're looking for, just a thought

Let the “middle man” just pass the whole map as an opaque data structure, and let the downstream functions pick out (destructure) the values they need from the map.

You might want to look at https://github.com/oliyh/martian

Yep, thanks I saw that but unfortunately I don't think it supports OpenApi 3

I am not sure that martian supports all of OpenAPI 3, but I am using it currently with OpenAPI 3.0.2 specs.

@U0AT6MBUL oh cool, that's good news, I'll try it out then

Great. I'd be interested in any OpenAPI 3 deficiencies you notice.