Hidden features of Clojure

Question

Which lesser-known but useful features of Clojure do you find yourselves using? Feel free to share little tricks and idioms, but try to restrict yourselves to Core and Contrib.

I found some really interesting information in answers to these similar questions:

• Hidden features of Haskell
• Hidden features of Python
• Hidden features of Java
• Hidden features of C
• Hidden features of Perl

There are many more "Hidden feature" questions for other languages, so I thought it would be nice to have one for Clojure, too.

Answer 1

The read-eval reader macro: #=

(read-string "#=(println \"hello\")")

This macro can present a security risk if read is used on user input (which is perhaps a bad idea on its own). You can turn this macro off by setting *read-eval* to false.

Answer 2

Clojure has an immutable, persistent queue datatype, PersistentQueue, but it doesn't (yet?) have literal reader syntax or Clojure wrapper functions, so you have to create one via a Java call. Queues conj (push) onto the rear and pop from the front with good performance.

user> (-> (clojure.lang.PersistentQueue/EMPTY)
          (conj 1 2 3)
          pop)
(2 3)

Lists conj onto the front and pop from the front. Vectors conj onto the rear and pop from the rear. So queues are sometimes exactly what you need.

user> (-> ()
          (conj 1 2 3)
          pop)
(2 1)
user> (-> []
          (conj 1 2 3)
          pop)
[1 2]

Answer 3

(defn foo [a & [b c]] ...)

You can destructure the rest argument.

Update:

The latest commit to the git repo (29389970bcd41998359681d9a4a20ee391a1e07c) has made it possible to perform associative destructuring like so:

(defn foo [a & {b :b c :c}] ...)

The obvious use of this is for keyword arguments. Note that this approach prevents mixing keyword arguments with rest arguments (not that that's something one's likely to need very often).

(defn foo [a & {:keys [b c] :or {b "val1" c "val2"}] ...)

If you want default values for keyword arguments.

Answer 4

You can apply functions to infinite argument sequences. For example

(apply concat (repeat '(1 2 3)))

produces a lazy sequence of 1,2,3,1,2,3... Of course for this to work the function also has to be lazy with respect to its argument list.