Using loop and recur in Clojure

Java developers are used to for, while, and do-while loops that update local variables in place. In Clojure, the first replacement is often a sequence operation such as map, filter, or reduce. When a loop really needs several changing values, loop and recur give you a direct, stack-safe shape without mutable locals.

Understanding loop and recur

In Clojure, loop and recur are used together to create recursive loops. The loop construct establishes a recursion point, while recur is used to jump back to this point, effectively simulating a loop. This approach eliminates the need for mutable state, which is a common source of bugs in imperative languages.

Why Use loop and recur?

• Immutability: Clojure emphasizes immutability, and loop and recur allow us to iterate without mutating variables.
• Stack Safety: recur reuses the current loop frame when it appears in a valid tail position.
• Explicit State Transition: Each iteration shows the next values for every loop binding.

Basic Syntax

Let’s start with the basic syntax of loop and recur:

1(loop [bindings]
2  (if (condition)
3    (recur new-bindings)
4    result))

• loop: Initializes the recursion with a vector of bindings, similar to initializing loop variables.
• recur: Re-invokes the loop with updated bindings, analogous to updating loop variables in each iteration.

Example: Simulating a for Loop

Consider a simple for loop in Java that sums numbers from 1 to 10:

1int sum = 0;
2for (int i = 1; i <= 10; i++) {
3    sum += i;
4}
5System.out.println(sum);

In Clojure, we can achieve the same result using loop and recur:

1(loop [i 1 sum 0]
2  (if (<= i 10)
3    (recur (inc i) (+ sum i))
4    (println sum)))

Explanation:

• We initialize i and sum in the loop bindings.
• The if condition checks if i is less than or equal to 10.
• recur updates i and sum for the next iteration.
• Once the condition is false, the result (sum) is printed.

Diagram: Flow of loop and recur

    flowchart TD
	    A[Start] --> B[Initialize loop bindings]
	    B --> C{Condition met?}
	    C -->|Yes| D[Execute loop body]
	    D --> E[Update bindings with recur]
	    E --> B
	    C -->|No| F[Return result]
	    F --> G[End]

Diagram Caption: This flowchart illustrates the flow of control in a loop and recur construct, highlighting the initialization, condition check, execution, and result return phases.

Example: Simulating a while Loop

Let’s simulate a while loop that prints numbers from 1 to 5:

1int i = 1;
2while (i <= 5) {
3    System.out.println(i);
4    i++;
5}

In Clojure, we use loop and recur:

1(loop [i 1]
2  (when (<= i 5)
3    (println i)
4    (recur (inc i))))

Explanation:

• The loop initializes i to 1.
• The when condition checks if i is less than or equal to 5.
• recur increments i and continues the loop.

Try It Yourself

Experiment with the following modifications:

• Change the range of numbers to print from 1 to 10.
• Modify the loop to print only even numbers.

Comparing loop and recur with Java Loops

Advanced Example: Factorial Calculation

Let’s calculate the factorial of a number using recursion:

Java Implementation:

1int factorial(int n) {
2    int result = 1;
3    for (int i = 1; i <= n; i++) {
4        result *= i;
5    }
6    return result;
7}

Clojure Implementation:

1(defn factorial [n]
2  (loop [i n result 1]
3    (if (<= i 1)
4      result
5      (recur (dec i) (* result i)))))

Explanation:

• The loop initializes i to n and result to 1.
• The if condition checks if i is less than or equal to 1.
• recur decrements i and multiplies result by i.

Exercise: Implement Fibonacci Sequence

Try implementing a function to calculate the nth Fibonacci number using loop and recur. Consider the following hints:

• Initialize two variables to represent the last two Fibonacci numbers.
• Use recur to update these variables in each iteration.

Key Takeaways

• Immutability: loop and recur promote immutability by using bindings instead of mutable variables.
• Stack Safety: recur reuses the current loop frame when it is in tail position.
• Functional Shape: Use loop/recur for custom state transitions, not as a blanket replacement for map, filter, or reduce.

Further Reading

• Official Clojure Documentation on Recursion
• ClojureDocs: loop and recur

Quiz: loop and recur in Clojure

Now that we’ve explored how to use loop and recur in Clojure, let’s apply these concepts to manage iteration effectively in your applications. Embrace the power of recursion and immutability to write cleaner, more maintainable code.