Hi, which is the good way to transform vector of maps to map of vectors? Ex: [{:a 1 :b 2} {:a 2 :b 3} {:a 3 :b 4} => {:a [1 2 3] :b [2 3 4]}]

@quangh apply + merge-with. Does that help?

Yeah, something like this

@rauh @tap Thank you, that's better. I have made it with redude-kv `(reduce-kv (fn [m k v] (merge-with into m (reduce (fn [newcoll [x y]] (assoc newcoll x [y])) {} v))) {} [{:a 1 :b 2 :c 3} {:a 2 :b 3 :c 4} {:a 3 :b 4 :c 0}])`

hey, I'm reading about seq functions and.. isn't calling into after every call horribly expensive?

@mailmeupinside Only way to find out is to benchmark it. Comparing it with conj

@rauh yeah, but I see that clojure does a lot of conversions between the types. maps into sets, then lists, then maps again and I'm used to doing everything using just one type

Why does

(defmacro domain
  [name & body]
  `{:content [~@body]})

(defmacro domain
  [name & body]
  `{:content ~(vec body)})

(defmacro domain
  [name & body]
  `{:content ~body})

@ackerleytng It does, in a sense. Try (domain foo inc 10) for a clue 🙂

Also, (macroexpand '(domain foo inc 10)) may be instructive.

You can change your last definition to

(defmacro domain
  [name & body]
  `{:content '~body})

oh! so ~ sort of executes what comes immediately after

hence (inc 10) becomes 11?

'~body results in (inc 10) being spliced in

It unquotes. To see this try (def a :hi) and then

`a

`~a

Yeah, but I wouldn't use the word splice for '~body, as that meaning is applicable to your form [~@body].

hmm ok

Another illustrative example building on the above:

`[a ~a b]

what does unquote really mean?

does it mean...

Well, think of just regular quote '

"allow eval to really happen"?

' means "for the next form, don't do anything and just pass it on exactly"

It means not much more than "unquote", but of course a consequence is that the evaluation can occur

So, '(a b c) evaluates to a list of three symbols....

as in this?

learning.core> '(a b c)
(a b c)

Almost like (list 'a 'b 'c)

But what if you didn't want the a to be quoted. (And you want to "unquote" it.)

That's what ~ does, but only for syntax quote

`

'

So that describes the low-level mechanics. But, in the end, it has the effect you are describing. It punches a hole in the quoted "thing", and lets the unquoted bit through so that it can be evaluated instead of being quoted to prevent evaluation.

learning.core> `(a b c)
(learning.core/a learning.core/b learning.core/c)

Yeah, that illustrates that syntax quote qualifies symbols

what's the difference between a and learning.core/a?

"qualifies symbols" means taking symbols and attaching a namespace to it?

a by itself is a symbol that (if not a local via let or a function argument), would resolve to the namespace it is in when evaluated

An example. If you

(def inc 3)

So, if you are in the learning.core namespace a and learning.core/a would be the same (assuming a is not a local or fn arg)

thanks 🙂

so

`a 

cos it

learning.core> `a
learning.core/a

Yeah, in a sense that it quotes a

You might ask, why have a syntax quote that qualifies symbols?

so is it something like read resolve eval print loop

and ' halts resolving (and eval)

but ` halts eval?

yes, why have a syntax quote to qualify symbols?

To see that, try (defmacro my-inc [x] (list 'inc x))

If you use it in a fresh REPL, then it will work fine.

But, try it with (def inc 3) at play.

To fix that (make your macro hygienic), you might write (defmacro my-inc [x] (list 'clojure.core/inc x))

even macroexpand-1 immediately prints 11

i was expecting it to print (inc 10)

Did you forget to quote the argument to macroexpand-1? You need to do (macroexpand-1 '(my-inc 10))

oh yes i did sorry

So you can see that this fails if inc has been redefined to evaluate to 3.

yes, it returns 3 instead

(letfn [(inc [x] 3)]
  (my-inc 10))

so the difference between defn and defmacro is that defn returns the result

and defmacro returns something that will first be evaluated, before the result is printed

But instead if you were to have defined my-inc using (defmacro my-inc [x] (list 'clojure.core/inc x)) it would work and return 11

So, the next step is to instead just define it as

(defmacro my-inc [x] (list `inc x))

And this can be further simplified using unquote

(defmacro my-inc [x] `(inc ~x))

(which is easier to read)

Think of defn as defing a function that you can call at runtime. Think of defmacro as defing a function the compiler calls at compile time (during macroexpansion)

how about

(defmacro my-inc [x] (list inc x))

It will, unless you have used (def inc 3) before having evaluated the defmacro form.

This is because your last macro example is returning a list containing the value of inc (either the function value or the number 3 depending on what you have done)

i see

thanks @mfikes, really appreciate it

i guess i'm still not completely clear but i'm better than before, thanks again!

No problem. Macros are a mind-bending topic 🙂

hi, beginner here, i started by editing clojure using parinfer in atom. now i am trying to learn how to code clojure in spacemacs. should i try to install parinfer there as well or should i get used to smartparens? as i understand it, to get parinfer to work in spacemacs i have to switch to the develop branch which may be more unstable.

does anyone know a good clojure boilerplate project for server side? with endpoints and all..Ideally that uses datomic.

How do I append a string to a list? cons/conj and friends all seem to append each character in the string individually to the list, which is not what I want to do

@samcgardner (conj ["foo" "bar"] "baz").

Yeah, follow-up question. Why does (conj (list "a" "b") "apple") get me [a, b, c, p ...] but working with a vector gives the expected result?

Maybe you were doing (apply conj ["a" "b"] "foo") ?

It was caused by using a list rather than av ector

But I'm not clear on why this would matter

Err, that's an utter lie. Conj works but prepends rather than appends on list

I think I was using cons or list* to try and append

Also conj works in a type-specific way, adding elements where they're most efficiently added -- which is different for lists (prepending, since they're linked lists) and vectors (appending).

I guess I'll just try and internalise the idea that vectors are my friend

user> (conj '(2 3) 1)
(1 2 3)
user> (conj [1 2] 3)
[1 2 3]

@samcgardner you've got the right idea, usually the only time you deal with lists is when you're doing macros

Yeah I didn't realise vectors coped well with appends

It's a really common thing to trip over, it's not just you 🙂

Cheers guys ❤️

Note that cons is different, it behaves the same on lists and vectors.

user> (cons 1 [2 3])
(1 2 3)
user> (cons 1 '(2 3))
(1 2 3)

If I were hellbent on appending (not prepending) a string to a list, what would I do? (cons string list) ?

err, (reverse (cons string (reverse list)) even

hey everyone, I am trying to setup a project using datomic, and even tho I have few dependencies I keep getting errors related to conflicts and so when I run lein deps :tree it suggests me to add some excludes, I added them, but it keeps asking me to add mpre. Am I missing some sort of good practice? is it normal to add so many excludes?

I am a complete newbie, but is this a decent way to shuffle a string? (clojure.string/join (shuffle (seq "abcdefg")))