I'm having trouble finding the source of disparate run times in subsequent group-by calls. First call is slow. But then if you evaluate the exact same thing it's fast. Is there some kind of caching in group-by? group-by uses transient collections. Is there internal caching in transient/persistent! ?

example code here: https://pastebin.com/PszjtJcB

It's due to laziness. If you add (doall tuples) before the first time measurement, then the times should be similar

Has there been any attempts to do MSA with clojure? I’d like to know if there’s any good sample projects out there in github or else. So far I’ve found one book ‘microservices-with-clojure’ but couldn’t find more, definitely yet to be a mainstream way of developing with clojure. But I think the event driven nature of the architecture suits with immutability and pure function concepts in clojure (or with other fp languages). I’d like to know more the community’s perspectives on this and current situation.

is there a tutorial about how a macro (defined by defmacro) can extract meta data from its list of arguments?

I’d like to invoke a macro as follows: `(my-macro a b ^{some-meta-data-1-as-hash} c d e ^{some-meta-data-2-as-hash} e f)` and within the macro definition figure out that two hashes were given, the first associated with c (which might be any syntactical form, and the second hash was associated with e which again might be any syntactical form.

hmm actually its worse than that. The syntax is

(my-macro ([a b c] ….)
          (^{some-data-as-hash} [a b [c d]] …)
          ...)

@jimka.issy

user=> (defmacro foo [a] (list 'do (meta a)))
#'user/foo
user=> (foo ^:foo [])
{:foo true}
user=> (foo ^{:foo :bar} [])
{:foo :bar}

couple of things are fuzzy.. meta gets the meta data associated with its given value right? When if I pass the same value twice to the macro, how does meta know which is which?

e.g. (mymacro ^meta-data-1 42 ^meta-data-2 42)

you can't do (foo ^:foo 1) since metadata cannot be applied to a number

interesting. that means I really don’t understand. I thought meta data was applied to the list (foo 1) with some magic indication that it applies to the 2nd element.

There is hardly any magic in Clojure. meta just looks up metadata on objects that support it (notably collections and symbols, all implementing clojure.lang.IObj)

When you write (defn foo [^String x]) what you are doing is you are writing a list with symbols. The symbol x has metadata {:tag String}. And this data is processed by the defn macro (or rather the thing below it, the fn* special form)

so if I make a macro call with the same symbol twice, can I have different meta data on each occurance of the symbol? (mymacro ^meta-data-1 a ^meta-data-2 a)

yes

ok, that means the meta data is not assoicated with the symbol, because a is eq to a

or am I even more confused that I imagined?

the metadata is associated with a specific symbol. symbols are not interned in Clojure, because they do not have context-free meaning, like keywords or strings

@jimka.issy so if I’m understanding correctly, you’re trying to associate meta data to a binding form, and have the macro behave more or less like (defn …)

Is that about right?

See this example:

user=> (defmacro foo [a] (list 'quote (map (juxt identity meta) &form)))
#'user/foo
user=> (foo ^String x)
([foo nil] [x {:tag String}])

I have to admit that I really don’t understand. but my code works. I have written a macro named dsfn which expands to destructuring-fn as follows:

(dsfn ([x]  'aaa)
      (^{x Boolean}
         [x y] 'bbb)
      ([x y] 'ccc))

(destructuring-fn
  ([[x] {}] 'aaa)
  ([[x y] {x Boolean}] 'bbb)
  ([[x y] {}] 'ccc))

(defmacro dsfn [& forms]
  (letfn [(process [form]
            (let [meta-data (meta (first form))]
              (cons [(first form) (if (nil? meta-data) {} meta-data) ] (rest form))))]
    `(destructuring-fn
      ~@(map process forms))))

How am I suppose to distinguish beween vector-ish and list-ish ? For example, fn distinguishes its semantics based on whether an argument looks like [a b c] or ([a b c] …) ? I had been using the function list? but apparently given (cons 1 (list 2 3 4)) the list? predicate returns false.

my dsfn macro above calls (cons ….) which produces a non-list 😞

looks like in the code of fn that it calls vector? rather than calling list? to distinguish the two cases.

Related to something in #beginners : Has there been any discussion around allowing (Class/staticMethod foo bar baz) if staticMethod is a Java method receiving a variable number of things at the end, instead of forcing Clojure users to create an array?

I guess this is more difficult to support in Clojure because of the dynamic typing? (currently you can look at the type of array to choose the right method)

yes, fogus has been working on this

it's complicated of course, but going to take a run at it for 1.11 probably

ooh really, wow

go @fogus!

I guess there is an ambiguity when you have varargs of arrays, but this is pretty rare... it's a difficult thing to get right I can imagine

I didn't know the last one would work as well, but it does (clojure 1.11.0, babashka current).

user=> (defn foo [& {:keys [a b]}] [a b])
#'user/foo
user=> (foo {:a 1 :b 2})
[1 2]
user=> (foo :a 1 :b 2)
[1 2]
user=> ((partial foo :a 1) :b 2)
[1 2]
user=> ((partial foo :a 1) {:b 2})
[1 2]

https://ask.clojure.org/index.php/4224/java-method-calls-cannot-omit-varargs for anyone who wants to vote on it (such an old request, jira goes back to 2010!)

are you adding up votes from ask + the old jira or how does this work?

it wasn't even jira - that was filed back when we were using Assembla

primarily using ask, but we look at both

jira votes did not fully survive the transition into cloud jira (lost any votes from users that weren't migrated)

voted, thank you

it has enough votes that it is already on the radar of course, but doesn't hurt

I am using a similar thing to your ask for some of the issues in my projects, but using github discussions. It makes elaborating on ideas easier while keeping the issue itself more crisp.

Why does defmulti go out of its way to prevent itself from being re-evaluated more than once?

because you would lose all the methods I think

can't it update itself if it already exists?

what problem are we trying to solve?

(similar to how vars are updated when you call def twice)

Hum... I can see how someone might have thought that, but I think it would have been less annoying to manage that problem than try to force re-evaluate a defmulti.

@alexmiller It might be related to a discussion in #clj-kondo where someone suggests that clj-kondo should advice using a var as the dispatch function (to which I didn't agree, but this would solve their REPL problem)

I've just seen a lot of people get burned by that and use tricks to avoid it, like passing it a var to the dispatch-fn, or adding a (def multi nil) above it.

this is one of those things where repl use has tradeoffs with non-repl use

someone should say what they're trying to do out loud. It's buried in between the lines

I thought @didibus was referring to what @ddouglass said in #clj-kondo but that might not be the case and maybe it was purely co-incidental

I was wondering if there was any downside to use those trick, since defmulti goes out of its way to not be re-evaluable.

as someone who has watched rich and alex work for a little while now:

well, it's slower

didibus is asking about "why does defmulti go out of its way not to be re-evaluable"

I think what they mean is "I want to alter or iterate on the dispatch function at the REPL"

the stuff about "preventing re-eval" is removed from this, and a presumption ^

Ya, for the Var. I guess adding (def multi nil) above it shouldn't be slower though right?

no, not sure if that impacts ability of tools to analyze

changing the dispatch function could change its arity, which would also break expectations on all the extensions

In this case I wanted to know why it prevents itself from being re-evaled, I already know the workarounds at the REPL. Was trying to reason what are the pros/cons of this:

(def multi nil)
(defmulti multi (fn[..] ...))

keep in mind the extensions could be in any file

I feel it must have been written very early. Because require doesn't force reload by default, and most people at the REPL control what they reload. So I don't see why it would cause issues nowadays, but also I can see how someone thought that it shouldn't.

what is the "it" in "I don't see why it would cause issues"?

Ya, it's a bit of a tradeoff I guess. What is more annoying, reloading the defmulti by accident and having to reload all the other defmethod for it or the other way around.

it = defmulti

I think you mean, it = making defmulti reloadable

you may not even know what the defmethods are to reload them

Hello! I'm trying to run a compojure project with ring-jetty-adapter , and tried to add wrap-reload of ring.middleware.reload so I could run lein run only once while developing, but I'm receiving an exception trying to run:

Caused by: java.io.FileNotFoundException: Could not locate ring/middleware/reload__init.class, ring/middleware/reload.clj or ring/middleware/reload.cljc on classpath.
	at clojure.lang.RT.load(RT.java:466)
	at clojure.lang.RT.load(RT.java:428)
	at clojure.core$load$fn__6824.invoke(core.clj:6126)
	at clojure.core$load.invokeStatic(core.clj:6125)
	at clojure.core$load.doInvoke(core.clj:6109)
	at clojure.lang.RestFn.invoke(RestFn.java:408)
	at clojure.core$load_one.invokeStatic(core.clj:5908)
	at clojure.core$load_one.invoke(core.clj:5903)
	at clojure.core$load_lib$fn__6765.invoke(core.clj:5948)
	at clojure.core$load_lib.invokeStatic(core.clj:5947)
	at clojure.core$load_lib.doInvoke(core.clj:5928)
	at clojure.lang.RestFn.applyTo(RestFn.java:142)
	at clojure.core$apply.invokeStatic(core.clj:667)
	at clojure.core$load_libs.invokeStatic(core.clj:5985)
	at clojure.core$load_libs.doInvoke(core.clj:5969)
	at clojure.lang.RestFn.applyTo(RestFn.java:137)
	at clojure.core$apply.invokeStatic(core.clj:667)
	at clojure.core$require.invokeStatic(core.clj:6007)
	at clojure.core$require.doInvoke(core.clj:6007)
	at clojure.lang.RestFn.invoke(RestFn.java:482)
	at fiis_api.service$eval2080$loading__6706__auto____2081.invoke(service.clj:1)
	at fiis_api.service$eval2080.invokeStatic(service.clj:1)
	at fiis_api.service$eval2080.invoke(service.clj:1)
	at clojure.lang.Compiler.eval(Compiler.java:7176)
	at clojure.lang.Compiler.eval(Compiler.java:7165)
	at clojure.lang.Compiler.load(Compiler.java:7635)
	... 96 more

The dependency?

I added [ring "1.9.3"] to project.clj .-.

Hi all: The San Francisco-based Bay Area Clojure meetup is looking for speakers for a May 11 (usu. 8pm PT) zoom event. #clojure-bay-area if you are interested in sharing something or know someone who might fit that description. Past zoom events here: https://www.youtube.com/channel/UCmtrRPVjcEMZrzTfAY3fd0Q Folks from remote locations works as well. Thank you!

:/ - (javadoc (.getBytes "hello")) opens a google search for "allinurl:[B.html"

maybe arrays should be special cased?

what’s the best/fastest way to compare two byte-arrays?

this works but allocates two vectors 😕 (compare (vec (.getBytes "bar")) (vec (.getBytes "bar")))

java.util.Arrays has some methods for sorting and equality of byte arrays

depending on your exact goals, you could certainly write a tight loop over the array for this purpose (in Java for best performance) or there are probably some numerical methods if you convert the byte arrays as numbers

thanks alex!

Does anyone know about the general approach behind Roam's multiplayer feature? Wondering if there's any libraries out there that can help me implement something similar 🙂