there is also #hyperfiddle channel

Thank you, I joined in it know 🙂

look at the merge-with function. Also merge and merge-with functions doesn't work recursively

most likely what you are looking for is here https://clojuredocs.org/clojure.core/merge#example-5b80849ee4b00ac801ed9e75

Some utility libraries have deep-merge functions

Thanks @U04V4KLKC Which utillity libraries have deep-merge functions? @U064X3EF3

Dude, deep-merge in https://weavejester.github.io/medley/medley.core.html is supremely perfect for your case. The whole library is the most useful utility functions around. I use it daily. As a beginner you can learn a ton from that code. It’s worth reading for it’s elegance.

Interesting. I used this as a challenge to write a deep-merge (fn my-deep-merge below). Then I saw the splendid deep-merge in @U04V4KLKC’s link (enc as deep-merge below). Now I am trying to work out how I could possibly produce that code in deep-merge ; clearly I have not got the where-withal!

👍

Where did you find them?

in clj commands: (doc when) (doc do) or even here https://clojure.org/reference/special_forms#def

yeah, not perfect. But there is no real difference between exprs* and & body . The former some sort of informal description inspired by regular expression and the later more how it is often written in the code.

hmm a what about 'for': (for seq-exprs body-expr)

As I understand there is some inconsistency in the use of the two styles: 1. some sort of informal description inspired by regular expression 2. how it is often written in the code But 'exprs*' and '& body' means exactly the same? @U064X3EF3 is creating the site https://clojure.org/reference/special_forms#def maybe he can say something more about it?

do and def are special forms. when is a macro that expects a test and than any number of expressions for can have any number of expressions before the body expression. (<-edit) The & can't be used for for here! It means "the rest of the parameters" so to speak.

there is no difference between & body (a common macro arg list) and exprs* as a reference doc syntax expression

Oh.. I assumed & something is a variadic argument list

it is

0 or more expressions

Right so there is a difference? You can't put it before a single argument?

Meaning for cannot use it for the binding expressions

I don't know what we're talking about anymore

are we talking about for specifically now?

I thought OP is confused about the specific difference between those parameter lists. But now I'm confused too!

for takes a single body-expr

let's stick with : "there is no difference between & body (a common macro arg list) and exprs* as a reference doc syntax expression" if there is no difference maybe would be better to just use one style

the problem is connected with what is beeing printed when one called (doc ...)

(doc when)
-------------------------
clojure.core/when
([test & body])
Macro
  Evaluates test. If logical true, evaluates body in an implicit do.

(doc do)
-------------------------
do
  (do exprs*)
Special Form
  Evaluates the expressions in order and returns the value of
  the last. If no expressions are supplied, returns nil.

  Please see 

a lot of the special forms use the regex/bnf-ish syntax (see also let loop etc)

some macros / special forms are effectively defining custom syntax and they use syntax style descriptive language

I find it confusing. Should be one style regex or code format.

It seems quite consistent to me. The exprs* style comes up in doc strings and meta data to describe macros/special forms in compressed form.

It's not a 1:1 mapping to arg lists

those are not a part of docstring btw. exprs* comes from :forms part of metadata and & body is from :arglists

maybe the format of how doc prints could be more explicit for better explaining that difference

we're not planning to make any changes in this area

ok, but thanks for the clarification 🙂

I am not 100% keeping up with the other explanations given. However, I see a pretty sharp grammatical usage difference when comparing the 2 examples from the original post.

(when test & body)
(do exprs*)

not last, but in the tail position

you missed a paren and have acc outside of the if

a function's body has an implicit do

and in a do the tail has to be in the last expression

Ah stupid copy&paste 🙈

I thought I was very off and it's actually working minus that copy&paste error.

Thanks @U0NCTKEV8