^ On that point, why do so many libraries use that syntax of optional key/value arguments in functions and call (apply hash-map args) instead of just having their functions take a map? Is there some benefit to:

(-> (session ring-app) 
    (request "/search" :request-method :post
                       :params {:q "clojure"}))
VS
(-> (session ring-app) 
    (request "/search" {:request-method :post
                        :params {:q "clojure"}}))

@jdkealy That's a good question. Named arguments are good for users to type in but, as you noticed, bad for programmatic use. Like @andy.fingerhut I suspect that the overall move is to a single options map argument instead -- although a DSL/API designed purely for human use rather than programmatic use might reasonably make use of named arguments (such as Spec).

I think the parts of Clojure that use that approach -- named arguments -- are older parts and maybe it's less common in more recent additions?

FWIW, when I took over clojure.contrib.sql back in 2011, it was all named arguments (and based around a single dynamic Var for the current DB spec). Over time I moved it to use an options hash map instead, and pass an argument instead of relying on the dynamic Var, both at the suggestion of the Clojure/core team.

hi, using genclass: is there a way to get a this reference on a constructor? found an old thread that gave me no answers: https://groups.google.com/forum/#!topic/clojure/0fvbdFC0be4 Imagine the target class something like:

class MyFactory extends SaxonTransformerFactory { public MyFactory () { super(); this.processor.register("My awesome thing"); } }

System.setProperty("javax.xml.transform.TransformerFactory", "my.package.MyFactory");

Can someone help me. Why multithread sval of lazy-seq will make the cpu to 100% useage？

Does anyone know why libraries typically have a foo.core namespace (rather than just foo)? Is this considered a best practice? Or are library authors just taking after clojure.core?

What I’ve seen is that most libraries use “core” as the entry, whereas applications use “main” This is not universal, and imho doesn’t really matter so long as there is internal consistency.

it’s just a name after all 🙂

Okay, makes sense 🙂 I’m working on a single-namespace library and having foo.core feels unnecessary to me, whereas going with just foo feels a bit.. unconventional.

So considering how there seem to be multiple schema libraries (`schema`, spec.alpha, malli, …) in use — is it possible to design a library to support these libraries if/when they exist? Ideally I’d like to support more than one schema library, but without forcing projects that use my library to use or explicitly exclude them.

libs like reitit abtract the routing schemas using a Coercion protocol making the schema impl swappable (parameter & response definitions, coercion and api-docs). Mixing the three in a same routing app would be asking for trouble, but still possible. I think same applies for all apps. Problem is of course, none of the three is complete and could be used for all things.

any nice way to join vectors like this (every other element)? [1 2 3] + [4 5 6] => [1 4 2 5 3 6]

check out interleave

this came up in an effort to calculate moving averages, which can almost be done with (interleave coll (map average (partition period 1 coll))), but only almost

doing it that way will always leave out the last element of coll

trivial to re-add it at the end, but still

@restenb have you tried partition-all - then you have to deal with a "dangling" coll

(ie. a coll that isn't a full period elements)

that'll have the opposite effect of adding the last element twice it seems (at least on my test data)

so in the end no better than having to (conj moving-averages-of-coll (last coll))at the end

btw relying on conj for ordering is a bad plan (that conj will insert at the beginning if you use interleave)

not if I stuff it in a vector first 😉

but yeah so far this is one of those "works, but smells kinda funny" situations

you might get a more direct result with some sort of (reduce f {:state {} :result []} (map vector coll (partition period 1 coll)))

calling conj in f to update the state and result

actually given the way you are doing the moving average, you can just use [] result directly and need not carry state

which means you could use (mapcat (fn [[x :as sample]] [x (average sample)]) (partition period 1 coll))

that'll still leave out the last element though?

You don't need to calculate the entire average every time, you can use a queue as a window then just calculate the diff. It covers the tails as well

Are Pedestal and Reitit alternatives or are they in different service spaces?

good question from a coworker. obviously understand that we can use private vars with (#'ns/private-var ...) but don't actually understand why. The reader ensures that we respect privacy?

when compiling, private vars are not available for implicit lookup

using var-quote sidesteps this mechanism

implicit lookup is in the compiler or the reader?

compiler, the reader just reads symbols

er, obviously implicit lookup is in the compiler. just wondering which part throws i guess

the error is a compiler error - it doesn't find anything for that symbol

foo=> (defn- foo-private [] 42)
#'foo/foo-private
foo=> (ns user)
nil
user=> (foo/foo-private)
Syntax error (IllegalStateException) compiling foo/foo-private at (REPL:1:1).
var: #'foo/foo-private is not public
user=>(#'foo/foo-private)
42

"syntax error" translates loosely to "error while compiling"

ok. i see resolve and resolveIn in the compiler. just trying to trace how var-quote ends up with the allowPrivate = true

(and thanks for your help @noisesmith)

@dpsutton I should correct what I said above - clearly based on the message here it does look at private vars, it just throws if you use them "implicitly" (without a var dereference)

it might help to look at the stack trace you get when you use a non-existant var inside defn

now that is some smart thinking. thanks! so obvious in retrospect but hadn't thought that lol

as compared to the stack trace for using a private var without explicit var quote

yeah perfect. I think it goe through TheVarExpr which allows lookingup private. thanks

(read-string "'some-symbol") returns (quote some-symbol) is there anyway to have it return the original 'some-symbol (or I guess just some-symbol) back instead?

there's a library that makes that happen - what's the use case?

oh, and clojure.pprint/pprint does this already

@sansaripour btw (quote foo) is literally 'foo, it's the correct reader expansion of the shorthand

just like @foo is the same as (deref foo) etc.

the three of these are all equal:

user=> (= 'foo (quote foo) (symbol "foo"))
true

there are multiple ways to get some-symbol from (read-string "'some-symbol"). depending the use case, either of these might work: • if you know it’s going to be a quoted symbol: (second (read-string "'some-symbol")) • if you’re actually hoping to evaluate a string: (eval (read-string "'some-symbol"))

or, if you know you never want quoted forms anywhere in the output, and just want the unevaluated symbol instead, you can tree walk and replace all lists that start with quote with the second item in the list

but it seems like a strange problem where usually the fix would be just not using ' in your edn files, which is why I ask what is actually being attempted

Thanks all for the help. I think I have a path forward now 👍 And, the use case is that I'm reading in the contents of a clojure (clj) file with read-string in search of a particular form that contains a particular map. I then return this map as a JSON string. The map may or may not contain keys formatted like 'some-symbol. Right now, the output JSON gets an un-welcomed heaping of (quote some-symbol) instead of the original 'some-symbol as a result of the read-string

oh and Im using babashka to execute the above operation^

OK - so to be clear 'foo is just a shorthand for (quote foo) and has the same meaning, if you need to print more recognizably you can use pprint (or copy what pprint does), but as a last resort you can absolutely do a tree-replace of (quote x) with x - it's a pretty unambiguous thing to test for an replace

something like:

(clojure.walk/postwalk (fn [form]
                         (if (and (seq? form)
                                  (= 2 (count form))
                                  (= 'quote (first form)))
                           (second form)
                           form))
                       (read-string "{:a {:bar 'foo}}"))

although if it’s actually a clj file, you might want to just require it and call the function that returns the data. if you need access to it from cljs, you may consider using cljc