Maybe a real quick question

lein ring isn't calling my configurator

:ring {:handler       some.ns/handler
         :init          some.ns/init
         :adapter       {:configurator  some.ns/configurator}
         :open-browser? false
         :stacktrace?   false
         :auto-reload?  false
         :port          3000

it is definitely using jetty

ring 1.8

I've also tried the :configurator key flat

@emccue Given that :adapter is pure data and is passed directly to the run-jetty function, I don't see how you can pass a configurator function -- there's no way to resolve a symbol to code.

I think what happens here is that you end up passing the symbol some.ns/configurator into the adapter and that ends up being "called" on the server object -- and ('sym :x) is going to work as a lookup and give you nil.

thats a mild headache

since ~some.ns/configurator also doesn't want to work

Because you can't pass a function into Lein's evaluation.

You can only use ~ to evaluate things that can be serialized: strings, numbers, data structures.

My advice: don't use lein-ring. Start the server yourself and then you have full control over it.

Even back when I was still using Leiningen (years ago now), I never used lein-ring for dealing with servers: it just wasn't worth the additional complexity in my view.

I'm trying to benchmark a slow function using criterium, but I want to reduce the sample count a bit or it'll take hours. I've tried

(binding [crit/*sample-count* 10]
     (crit/bench
       ...expr..))

(crit/bench
    ...expr..
    :samples 10)

Anybody familar with dtype-next / tech.v3.datatype.functional?

Hi! I work on an old project with clj-time I don’t understand why this (t/to-time-zone (t/now) (t/time-zone-for-id "America/New_York")) return the UTC date-time and not the right date timezoned. Someone has already had the problem?

is there a way to put a transducer on a returned channel?

particularly I'd like to combine core.async/timeout with a transducer

pipe?

It is a bit verbose but I don't see a fn that would create the "derived" channel for you

I read @dpsutton’s https://dev.to/dpsutton/exploring-the-core-cache-api-57al article again and was somewhat scared to use core.cache (never have, but I remember a peer using it in a past job... again it was tricky) Wondering if it would make sense to implement clojure.lang.IAtom backed by core.cache? That way one would use clojure.core/swap! and have the nuances abstracted away. Anyone has tried that?

I believe there was some discussion around this (@seancorfield) and the recommendation is to use the wrappers

i consider the cache protocol to be private and people should only ever use wrapped/through or wrapped/through-cache

Wasn't there a discussion in clojure q&a or clojureverse? or was I dreaming 🙂

maybe it was here

Is there a way to rewrite this and avoid an anonymous function? (filter #(= (:type %) "sha1"))

(filter (comp #{"sha1"} :type))

common idiom. up to you if you think its more clear. once you see it a bunch it is but whether it is "better" is pretty 50:50 to me

It is no shorter, but slower 😅

Depends. #{"sha1"} is compiled just once as a constant and barely has a noticeable difference vs. = #{x} creates a set in runtime. Set creation is somewhat slow

I think there is nothing wrong with (filter #(= (:type %) "sha1")) , the intent is clear and much easier to read than (filter (comp #{"sha1"} :type)) (at least for me)

Why would you want to avoid having an anonymous function there in the first place? If you just mean having #(...) (after all, comp also creates an anonymous function), then you can simply use the more verbose (fn [x] ...) syntax.

FWIW, personally I would write it as #(-> % :type (= "sha1")). Or as the initial variant - doesn't really matter.

#( is ugly but pointfree is harder to understand

I have seen a (fn-> :type (= "sha1")) macro in some projects

pretty futile to try finding an objective truth for these :) https://lambdaisland.com/blog/2019-12-06-advent-of-parens-6-a-small-idiom can used further evidence that some (reputed) people like the idiom performance is objective though, so when in doubt I wouldn't use #{x} as a predicate

If the key didn’t shadow a built-in, I find (filter (fn [{:keys [type]}] (= type "sha1"))) most readable

@vincenz.chianese

(defn sha1? [hashing-procedure]
  (= (:type hashing-procedure) "sha1"))

...
(filter sha1?)

or

Yeah…I do not know, I do not feel it deserves to be a function that can be reused

There are only a few characters to save unless you go for a separate function

t=>t.type === 'sha1" that's really it, not worth spending more time on it I gues

(let [sha1? (fn [hashing-procedure]
              (= (:type hashing-procedure) "sha1"))]
  (filter sha1?))

giving it a name and giving it a place in a namespace are seperate

just pointing out that naming the function and typing the extra characters has some benefit

hence why python is structured to only allow that way

does anyone have any experience with Tomcat not being able to run a Luminus uberwar with an error of ClassNotFoundException for ServletContextlistener? I found a SO post with the same error, but none of the responses seem to have helped.

(maybe use https://clojure.org in the topic?)

is there an example anyone has off hand of what the defn params list as attr-map? is used for?

ins)user=> (defn foo "a function" {:has-arbitrary-meta true} [])
#'user/foo
(ins)user=> (meta #'foo)
{:arglists ([]), :doc "a function", :has-arbitrary-meta true, :line 1, :column 1, :file "NO_SOURCE_PATH", :name foo, :ns #object[clojure.lang.Namespace 0x72458efc "user"]}

it gets merged to metadata

I see

it's one of the N ways to attach metadata to a function's var

the docstring mentions this as well: > Same as (def name (fn [params* ] exprs*)) or (def > name (fn ([params* ] exprs*)+)) with any doc-string or attrs added > to the var metadata. also the spec calls it meta in the spec definition: :meta (? map?). But i agree it is a bit hard to parse that that's what's happening.

only tenuously related, I'm reminded of this trick

(ins)user=> (defn bar {:macro true} [_ _ form] (reverse form))
#'user/bar
(ins)user=> (bar (1 1 +))
2

macros without defmacro

i guess .setMacro sets that metadata and extends the signature for &form and &env?

that sounds like what it would need to do

@dpsutton bingo https://github.com/clojure/clojure/blob/cbb3fdf787a00d3c1443794b97ed7fe4bef8e888/src/jvm/clojure/lang/Var.java#L243

it only does the metadata part, something else must add the invisible args

oh, there's a binding in defmacro's body called "add-implicit-args"

That makes a lot of sense