The feature that interests me the first time is its ability to "execute data as code".
As demonstrated here, were I define a function process that basically executes the symbol processor with whatever params :
=> (defn process [& params] (eval (cons processor params)))
#'user/process
Note that processor symbol is data, not code, let's say:
=> (def processor `java.awt.Point.)
#'user/processor
So I defined processor as a quoted "java.awt.Point." which is equivalent to "new java.awt.Point()" in Java. However, the expression is not executed, it is stored in processor.
Now I can call the process function which in turn creates a new instance of Point with my provided "constructor arguments":
=> (process 12 34)
#< Point java.awt.Point[x=12,y=34] >
#< Point java.awt.Point[x=12,y=34] >
The reason why I quoted "constructor arguments" above, is because I can define processor to any other function, not necessarily "constructors":
=> (def processor `Math/min)
#'user/processor
=> (process 12 34)
12
Which is the same as:
=> (eval (list processor 12 34))
12
"So it's just eval," you say. How is it different to eval()-ing expressions in strings like JSR-223?
Well, in Clojure (or any Lisp dialect) it's not eval-ing an arbitrary string, but evaluating a data structure which is defined in Clojure itself. In other words, the internal representation of code corresponds exactly to the external representation. This characteristic is known as homoiconicity.
In other programming languages, the structure of the is known as its Abstract Syntax Tree (AST). Well, in Clojure, the "AST" can be defined, read, and evaluated, in Clojure data's own data structures, without needing "parsing" and transient storage (strings).
