Evaluation with map, apply of function, and vector of quoted expressions

What is the correct way to think about the following?

user=> (map #(apply println %) ['(+ 1 1)])
+ 1 1
;=> (nil)

I have in my head that this should possibly print 2 and not what it does print. I have a notion that the quoted '(+ 1 1) should be evaluated once to be the data (+ 1 1) when it is inside of [], and again (+ 1 1) should be evaluated to 2 when apply puts it in the argument position of println.

Here is how I am kind of picturing evaluation:

(map #(apply println %) ['(+ 1 1)])
; --> to reader
(<map-function-var> <anonymous-println-function-var> [(+ 1 1)])
; --> <map-function-var> applys the <anonymous-println-function-var> to the args:
[(#(apply println %) [(+ 1 1)])]
; --> apply the argument
[(println (+ 1 1)]
; --> eval it
[(println 2]
; --> print it
2
;=> nil

My mental model obviously has one too many evaluations in it, and I think the last one, where 2 is produced, is where it is wrong, but I am not sure. Can someone explain how I should be thinking of this sequence of substitutions and evaluations?

Update: it may have something to do with this?

user=> (map #(apply println %) [(list "a" "b") (list "c" "d")])
a b
c d
(nil nil)

Once the contents of [] are evaluated, they are now data, and when they are passed to #(apply println %), they are considered data, as the elements of [] have been evaluated, and will not be passed to the evaluator to try and find the function "a" or "c"... ?

First of all, map returns a lazy sequence and you shouldn't use it for side effects (like printing).

There are ways to force all side effects in the lazy sequence (dorun, doall), but in this case, you can directly use run! or doseq.

As for the main problem: (+ 1 1) is just the way how REPL prints the result of the expression '(+ 1 1) (a result of that expression is a list with one symbol and two numbers).
But if you just copy-paste that printed representation into REPL, you will get Clojure expression evaluating to 2.

Following Evaluation reference article, I will try to describe what is going on when you call (map #(apply println %) ['(+ 1 1)]):

1. map is evaluated => #object[clojure.core$map]
2. #(apply println %) is evaluated => #object[fn]
3. ['(+ 1 1)] is evaluated => [(+ 1 1)] (printed representation of vector with list with one symbol and two numbers)
4. #object[clojure.core$map] is called with #object[fn] and [(+ 1 1)]

Now, you could look at (source map) to see, what exactly map does with its arguments (laziness, chunking...), but for the sake of simplicity, let's focus just on this small expression from the implementation:

(f (first s))

1. f is evaluated => #object[fn]
2. first is evaluated => #object[clojure.core$first]
3. s is evaluated => [(+ 1 1)]
4. #object[clojure.core$first] is called with [(+ 1 1)] => (+ 1 1)
5. #object[fn] (with body (apply println %)) is called with (+ 1 1)
   1. apply is evaluated => #object[clojure.core$apply]
   2. println is evaluated => #object[clojure.core$println]
   3. % is evaluated => (+ 1 1)
   4. #object[clojure.core$apply] is called with #object[clojure.core$println] and (+ 1 1)

You could now look at (source apply)- just the relevant part:

([^clojure.lang.IFn f args]
     (. f (applyTo (seq args))))

That is some Java interop, but as part of the evaluation, args evaluate to (+ 1 1).

What is important: (#(apply println %) '(+ 1 1)) is equivalent to (apply println '(+ 1 1)) and that is equivalent to (println '+ '1 '1) and (println '+ 1 1).

My point is- during evaluation, the expression (+ 1 1) is never evaluated (so you won't get 2 as the result), but some symbols and expressions are evaluated to (+ 1 1).

Whether you use list or quote (') makes no difference here. Yes,
you are always providing "data" and data will never execute on its
own (you can eval the data to make it run).

This is a bit more tricky in a Lisp, as code is data, but to put it over
the top: this would be like expecting
System.out.println("System.exit(1)") to exit your program in Java.

So the way you're picturing the evaluation breaks at the apply step.

apply also only works with data. It is a runtime operation: it
takes a list of arguments calls the given functions as if arguments
where given directly.

(apply println '(+ 1 2))

is actually equivalent to

(println '+ 1 2)

(this is where your train of thoughts is wrong (at the --> apply the
argument step))

If you'd not apply, it would still just print the form

(println '(+ 1 2))
; → (+ 1 2)