B.2 Commonly Used Functions and Macros

B.2 Commonly Used Functions and Macros

Clojure, as a functional programming language, provides a rich set of functions and macros that allow developers to write concise, expressive, and efficient code. For Java professionals transitioning to Clojure, understanding these core constructs is crucial to harnessing the full power of the language. This section delves into some of the most commonly used functions and macros in Clojure, providing detailed explanations and practical examples to illustrate their usage.

1. map

The map function is a cornerstone of functional programming in Clojure. It applies a given function to each element of a collection, returning a lazy sequence of results.

Usage Example

1(defn square [x]
2  (* x x))
3
4(map square [1 2 3 4 5])
5;; => (1 4 9 16 25)

In this example, map applies the square function to each element of the vector [1 2 3 4 5], resulting in a sequence of squared numbers.

Key Points

• map is lazy, meaning it computes elements only as needed.
• It can be used with multiple collections, applying the function to corresponding elements.

1(map + [1 2 3] [4 5 6])
2;; => (5 7 9)

2. reduce

reduce is used to accumulate a result by applying a function to an initial value and the elements of a collection.

Usage Example

1(reduce + 0 [1 2 3 4 5])
2;; => 15

Here, reduce sums up the elements of the vector [1 2 3 4 5], starting with an initial value of 0.

Key Points

• reduce is eager, processing the entire collection.
• It is often used for operations like summing, finding maximum/minimum, or combining elements.

1(reduce max [1 3 2 5 4])
2;; => 5

3. filter

The filter function returns a lazy sequence of elements from a collection that satisfy a predicate function.

Usage Example

1(filter even? [1 2 3 4 5 6])
2;; => (2 4 6)

In this example, filter selects only the even numbers from the vector [1 2 3 4 5 6].

Key Points

• filter is lazy, producing elements as needed.
• It is useful for extracting subsets of data based on conditions.

4. let

let is a macro for creating local bindings, allowing you to define temporary variables within a scope.

Usage Example

1(let [x 2
2      y 3]
3  (+ x y))
4;; => 5

Here, let binds x to 2 and y to 3, and the expression (+ x y) evaluates to 5.

Key Points

• let is used for scoping and organizing code.
• It helps avoid variable name clashes and improves readability.

5. defn

defn is a macro for defining functions. It combines def and fn to create a named function.

Usage Example

1(defn greet [name]
2  (str "Hello, " name "!"))
3
4(greet "Alice")
5;; => "Hello, Alice!"

In this example, defn defines a function greet that takes a name and returns a greeting string.

Key Points

• defn supports optional docstrings and metadata.
• It is the primary way to define reusable functions in Clojure.

6. if

The if macro is used for conditional expressions, evaluating one of two branches based on a condition.

Usage Example

1(if (> 3 2)
2  "Greater"
3  "Smaller")
4;; => "Greater"

Here, if checks if 3 is greater than 2, returning “Greater” since the condition is true.

Key Points

• if requires a condition, a then-branch, and an optional else-branch.
• It is fundamental for decision-making in Clojure.

7. cond

cond is a macro for handling multiple conditional branches, similar to a switch-case statement.

Usage Example

1(cond
2  (< 3 2) "Less"
3  (> 3 2) "Greater"
4  :else "Equal")
5;; => "Greater"

In this example, cond evaluates each condition in order and returns the corresponding result for the first true condition.

Key Points

• cond is more readable than nested if statements for multiple conditions.
• The :else keyword is used for a default case.

8. fn

fn is used to create anonymous functions, often for short-lived or inline use.

Usage Example

1(map (fn [x] (* x x)) [1 2 3 4 5])
2;; => (1 4 9 16 25)

Here, fn creates an anonymous function to square numbers, used directly within map.

Key Points

• fn is ideal for small, unnamed functions.
• It supports destructuring and variadic arguments.

9. doseq

doseq is a macro for iterating over collections, primarily for side effects.

Usage Example

1(doseq [n [1 2 3]]
2  (println n))
3;; Prints:
4;; 1
5;; 2
6;; 3

In this example, doseq iterates over the vector [1 2 3], printing each element.

Key Points

• doseq is not lazy; it processes all elements immediately.
• It is used when the primary goal is side effects, like printing or logging.

10. for

for is a macro for list comprehensions, generating sequences based on input collections and conditions.

Usage Example

1(for [x [1 2 3]
2      y [4 5 6]]
3  (* x y))
4;; => (4 5 6 8 10 12 12 15 18)

Here, for creates a sequence by multiplying each combination of x and y.

Key Points

• for is lazy, producing elements as needed.
• It supports filtering and multiple input collections.

11. def

def is used to define global variables or constants.

Usage Example

1(def pi 3.14159)
2
3(* pi 2)
4;; => 6.28318

In this example, def binds pi to the value 3.14159, which can be used globally.

Key Points

• def is used for top-level bindings.
• Avoid using def for mutable state to maintain functional purity.

12. loop and recur

loop and recur are used for creating recursive loops, allowing tail-call optimization.

Usage Example

1(defn factorial [n]
2  (loop [acc 1, n n]
3    (if (zero? n)
4      acc
5      (recur (* acc n) (dec n)))))
6
7(factorial 5)
8;; => 120

Here, loop initializes acc and n, and recur updates them until n is zero.

Key Points

• recur must be in the tail position for optimization.
• loop provides a way to manage state across iterations.

13. quote and syntax-quote

quote prevents evaluation of a form, while syntax-quote (\``) allows for unquoting () and splicing (@`).

Usage Example

1(quote (+ 1 2))
2;; => (+ 1 2)
3
4`(+ 1 ~(+ 2 3))
5;; => (+ 1 5)

In these examples, quote and syntax-quote control evaluation and allow code generation.

Key Points

• quote is used to treat code as data.
• syntax-quote is powerful for macros and code templates.

14. macro

Macros allow developers to extend the language by defining new syntactic constructs.

Usage Example

1(defmacro unless [condition & body]
2  `(if (not ~condition)
3     (do ~@body)))
4
5(unless false
6  (println "This will print"))
7;; Prints: This will print

Here, unless is a macro that inverts the condition for an if statement.

Key Points

• Macros operate on code, not values.
• They enable domain-specific language creation and syntactic abstraction.

15. try, catch, finally

These are used for exception handling in Clojure.

Usage Example

1(try
2  (/ 1 0)
3  (catch ArithmeticException e
4    (println "Cannot divide by zero"))
5  (finally
6    (println "Cleanup")))
7;; Prints:
8;; Cannot divide by zero
9;; Cleanup

In this example, try, catch, and finally manage exceptions and cleanup.

Key Points

• try handles exceptions with catch clauses.
• finally executes regardless of exceptions.

Conclusion

Understanding and effectively using these functions and macros is essential for writing idiomatic and efficient Clojure code. They form the building blocks of functional programming in Clojure, enabling developers to write concise, expressive, and maintainable code. As you transition from Java to Clojure, mastering these constructs will significantly enhance your ability to leverage Clojure’s functional paradigm.

Quiz Time!