There are a few ways to denote a function in Clojure. The most common way is something like this

``````(defn merge-vector [v1 v2]
(into v1 v2))
``````

This is a function that takes two vectors and returns a new vector that is the combination of the elements in both these vectors. For example,

``````=> (merge-vector [1 2] [3 4])
; [1 2 3 4]
``````

This is actually short hand for this

``````(def merge-vector
(fn[v1 v2] (into v1 v2)))
``````

Which can then be invoked in the same way as above

``````(merge-vector [1 2] [3 4])
``````

Anonymous Functions are a way to denote a function. The general notation of `(fn [params*] body)` can also be written `#(...)` which is called literal notation. So we can rewrite the above function like this

``````(#(into %1 %2) [1 2] [3 4])
; [1 2 3 4]
``````

Where `%1 %2` denotes the that there are two arguments. When only argument is passed in it is convention to use `%` instead of `%1`.

Anonymous Functions can be useful to use in higher order functions like `map`, `reduce`, `filter`

Lets say we wanted to find the remainder of all elements in a vector when the elements are divided by 3. It can be concisely written with an anonymous function.

``````=> (map #(mod % 3) [6 7 8])
; (0 1 2)
``````

Here’s another example with `filter`

``````=> (filter #(zero? (mod 15 %)) (range 3 15 2))
; (3 5)
``````

If we take this by steps:

``````; returns numbers 3 to 15 (exclusive) by 2
=> (range 3 15 2)
; (3 5 7 9 11 13)
``````
``````; finds the numbers that are factors of 15 and returns a lazy sequence of those factors
=> (filter #(zero? (mod 15 %)) (3 5 7 9 11 13))
; (3 5)
``````

Both literal notation and the long hand way of `(fn [params*] body)` to denote an anonymous function are frequently used.