Question

How to make clojure to count '() as nil?

For example:
How to make something like

(if '() :true :false) 

;to be 

:false

;Or easier 

(my-fun/macro/namespace/... (if '() :true :false))

:false

And not just if. In every way.

(= nil '()) or (my-something (= nil '()))

true

And every code to be (= ‘() nil) save.

(something (+ 1 (if (= nil '()) 1 2)))

2

I was thinking about some kind of regural expression. Which will look on code and replace '() by nil, but there are some things like (rest '(1)) and many others which are '() and I am not sure how to handle it.

I was told that macros allow you to build your own languages. I want to try it by changing clojure. So this is much about “How clojure works and how to change it?” than “I really need it to for my work.”

Thank you for help.

Answer 1

You say you would like to change Clojure using the macros. Presently, as far as I know, this is not something you could do with the “regular” macro system (terminology fix anyone?). What you would really need (I think) is a reader macro. Things I have seen online (here, for example) seem to say that there exists something like reader macros in Clojure 1.4–but I have no familiarity with this because I really like using clooj as my IDE, and it currently is not using Clojure 1.4. Maybe somebody else has better info on this “extensible reader” magic.

Regardless, I don’t really like the idea of changing the language in that way, and I think there is a potentially very good alternative: namely, the Clojure function not-empty.

This function takes any collection and either returns that collection as is, or returns nil if that collection is empty. This means that anywhere you will want () to return nil, you should wrap it not-empty. This answer is very similar to mikera’s answer above, except that you don’t have to convert your collections to sequences (which can be nice).

Both using seq and not-empty are pretty silly in cases where you have a “hand-written” collection. After all, if you are writing it by hand (or rather, typing it manually), then you are going to know for sure whether or not it is empty. The cases in which this is useful is when you have an expression or a symbol that returns a collection, and you do not know whether the returned collection will be empty or not.

Example:

=> (if-let [c (not-empty (take (rand-int 5) [:a :b :c :d]))]
     (println c)
     (println "Twas empty"))
;//80% of the time, this will print some non-empty sub-list of [:a :b :c :d]
;//The other 20% of the time, this will return...
Twas empty
=> nil