Destructuring a function in a list - clojure

Question

I have the following two test cases in Clojure, one destructuring a vector, and one destructuring a list:
user=> ((fn [[a op b]] (op a b)) [1 + 2])
3
user=> ((fn [[a op b]] (op a b)) '(1 + 2))
2
Why is the symbol + evaluated in the first test case but not the second? Is the quote recursive, so in the second test case op is really 'op?

Answer 1

You are correct that the single quote ' (equivalent of the function quote) will return a list of symbols, suppressing evaluation. However, since symbols cannot start with a number, the PersistentList '(1 + 2) will contain a java.lang.Long, a clojure.lang.Symbol, and a java.lang.Long.
When you invoke the function given by the Symbol + (which is possible because Symbol extends AFn which itself implements IFn, and overrides the invoke function), this gets executed:
public Object invoke(Object obj, Object notFound) {
return RT.get(obj, this, notFound);
}
Since you executed (op a b), or ('+ 1 2), obj is 1, notFound is 2, and this is the Symbol + in the call to clojure.lang.RT's get method, which looks like this:
static public Object get(Object coll, Object key, Object notFound){
if(coll instanceof ILookup)
return ((ILookup) coll).valAt(key, notFound);
return getFrom(coll, key, notFound);
}
Again, coll is the Long 1, key is the Symbol +, and notFound is the Long 2.
So when a function is called, it's being looked up in a collection. Since 1 is not a collection, the value notFound, or 2, is being returned.
As a visual of a ('+ 5 10) example, in a debugger:

Answer 2

First we can simply see if the forms are destructured the expected way or not with a simple println:
(def fn1
(fn [[a op b]]
(println "a>" a)
(println "b>" b)
(println "op>" op)
(op a b)))
(fn1 [1 + 2])
; a> 1
; b> 2
; op> #object[clojure.core$_PLUS_ 0x5b95b23d clojure.core$_PLUS_#5b95b23d]
(fn1 '(1 + 2))
; a> 1
; b> 2
; op> +
So in the first case, the parenthesis evaluates the clojure.core's function PLUS, which gives the expected (+ 1 2) => 3.
In the second case, you can picture the sequence of forms to be evaluated as an implicit sequence, so call eval on it will give:
(eval ('+ 1 2))
; 2
Which is simply the result of eval-ing each form in the sequence, and so only returns the last value, here 2.
You can think of it as:
(do
'+
1
2)
As hinted in the comment, do is not call.
The '+ is a clojure.lang.Symbol which implements IFn. Thus when calling eval, it will call the java function invoke, with two parameters 1 and 2.
(invoke 1 2) ; is called on +'
Looking at 2 parameters method of invoke for Symbol:
https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Symbol.java#L129
We notice it will search for the symbol +' in the first parameter, which should be a map.
(def a {'+ 0})
(apply '+ [a 2])
; 0
When the item (here symbol) cannot be found, the invoke function returns the default value, the second parameter of the invoke function:
(def b { })
(apply '+ [b 2])
; symbol + is not found in b so returning 2
; 2