1

I'm studying Clojure, and I've read that in Clojure a function definition is just data, i.e. parameters vector is just an ordinary vector. If that's the case, why can I do this

(def add (fn [a b]
  (+ a b)))

but not this

(def vector-of-symbols [a b])

?

I know I normally would have to escape symbols like this:

(def vector-of-symbols [`a `b])

but why don't I have to do it in fn/defn? I assume this is due to fn/defn being macros. I tried examining their source, but they are too advanced for me so far. My attempts to recreate defn also fail, and I'm not sure why (I took example from a tutorial):

(defmacro defn2 [name param & body] 
  `(def ~name (fn ~param ~@body)))

(defn2 add [a b] (+ a b)) ;;I get "Use of undeclared Var app.core/defn2"

Can someone please explain, how exactly does Clojure turn data structures, especially symbols, into code? And what am I missing about the macro example?

Update Apparently, macro does not work because my project is actually in Clojurescript (in Clojure it does work). I did not think it matters, but as I progress - I discover more and more things that somehow don't work for me in with Clojurescript.

Update 2 This helps: https://www.clojurescript.org/about/differences

Improve this question
1
  • Your defn2 macro works fine for me. Make sure that you're calling it in the same namespace where you defined it, or use the fully qualified name. Commented Jul 2, 2020 at 21:06

2 Answers 2

Reset to default
1

A function is a first-class citizen as other data in Clojure.

To define a vector you use (vector ...) or reader has syntaxic sugar [...], for a list it's (list ...) or '(...) the quote not to evaluate the list as a function call, for a set (set ...) or #{...}.

So the factory function for a function is fn (in fact fn*, that comes from Java core of Clojure, fn is a series of macros to manage to destructure and all).

(fn args body)

is a function call that returns a function, where args is a vector of argument(s) event. empty and body is a series of Clojure expressions to be evaluated with args bind to the environment. If nothing is to be evaluated it returns nil. There is also a syntactic sugar #(...) with %x as argument x and % as argument 1.

(fn ...) return a value that is a function. So

(def my-super-function (fn [a b c d] (println "coucou") (+ a b c d)))

binds the symbol my-super-function with the anonymous function returned by (fn [a b c d] (println "coucou") (+ a b c d)).

(def my_vector [1 2 3])

binds the symbol my_vector with the vector [1 2 3]

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

"fn*, that comes from Java core of Clojure" - from your and A. Thompsons answers, I understand that compiler handles fn*, particularly parameters vector in a special manner? Or are they escaped into raw symbols somewhere along the way? I.e. , when we use fn* directly, (def add4 (fn* [f g] (+ f g))) , why aren't [f g] and (+ f g) evaluated like during normal function invocation?
I'm guessing, this answers my question, fn is a special form? clojure.org/reference/special_forms
1

List of learning resources: https://github.com/io-tupelo/clj-template#documentation

As @jas said, your defn2 macro looks fine.

The main point is that macros are an advanced feature that one almost never needs. A macro is equivalent to a compiler extension, and that is almost never the best solution to a problem. Also keep in mind that functions can do some things macros can't.

Another point: the syntax-quote (aka backquote) ` is very different from a single quote '. In your example you want the single quote for ['a 'b]. Even better would be to quote the entire vector form '[a b].

As to your primary question, it is poorly explained how source-file text is converted into code. This is a 2-step process. The Clojure Reader consumes text string data (from a file or a literal string) and produces data structures like lists, vectors, strings, numbers, symbols. The Clojure compiler takes these data structures as input and produces java byte code that can be executed.

It is confusing because, when printed, one can't tell the difference between the text representation of a vector [1 2 3] and the text string that is input to the reader [1 2 3]. Ideally it would be color-coded or something. This problem doesn't exist in Java, etc since they don't have macros and hence there is no confusion between the source code (text) and the data structures used by a macro (not text).

For a more detailed answer on creating macros in Clojure, please see this answer.

Improve this answer

3 Comments

"This is a 2-step process. The Clojure Reader ... The Clojure compiler ..." Do I understand correctly that: 1. Reader only parses symbols, but does not actually bind them semantically; 2. fn macro in the end produces definition in terms of intrinsic special function fn*, which is specially handled by Compiler, and Compiler uses special semantic interpretation of symbols in this case?
Just to clarify, I'm trying to understand this: when we are using fn* directly, `(def add4 (fn* [f g] (+ f g))) , why aren't [f g] and (+ f g) evaluated like during normal function invocation?
I'm guessing, this answers my question, fn is a special form? clojure.org/reference/special_forms

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.