Refactoring Imperative Java Code to Functional Clojure: Exercises and Insights

5.10 Exercises: Refactoring Imperative Code

Transitioning from Java to Clojure involves embracing a new paradigm: functional programming. This section provides exercises to help you refactor imperative Java code into functional Clojure code. We’ll focus on converting loops into recursive functions, replacing mutable variables with immutable data, and isolating side effects to use pure functions. These exercises will deepen your understanding of Clojure’s functional approach and highlight its advantages over traditional imperative programming.

Exercise 1: Converting Loops to Recursive Functions

Objective: Transform a Java for loop into a recursive function in Clojure.

Java Code Example

Consider the following Java code that calculates the factorial of a number using a for loop:

public class Factorial {
    public static int factorial(int n) {
        int result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }
}

Clojure Solution

In Clojure, we can achieve the same result using recursion. Here’s how you can refactor the Java code into Clojure:

(defn factorial [n]
  (letfn [(fact-helper [acc n]
            (if (zero? n)
              acc
              (recur (* acc n) (dec n))))]
    (fact-helper 1 n)))

;; Usage
(factorial 5) ; => 120

Explanation:

• We define a helper function fact-helper inside factorial to carry the accumulator acc.
• The recur keyword is used for tail recursion, ensuring efficient looping without stack overflow.

Try It Yourself: Modify the function to calculate the factorial of a list of numbers and return a list of results.

Exercise 2: Replacing Mutable Variables with Immutable Data

Objective: Refactor Java code that uses mutable variables into Clojure code with immutable data structures.

Java Code Example

Here’s a Java snippet that sums an array of integers:

public class SumArray {
    public static int sum(int[] numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return sum;
    }
}

Clojure Solution

In Clojure, we use immutable data structures and sequence operations:

(defn sum [numbers]
  (reduce + numbers))

;; Usage
(sum [1 2 3 4 5]) ; => 15

Explanation:

• The reduce function iteratively applies the + operator to the elements of the sequence numbers.
• This approach eliminates the need for mutable state.

Try It Yourself: Extend the function to handle nested collections, summing all numbers within.

Exercise 3: Isolating Side Effects

Objective: Refactor Java code to isolate side effects and use pure functions in Clojure.

Java Code Example

Consider a Java method that reads from a file and processes its content:

import java.io.*;
import java.util.*;

public class FileProcessor {
    public static List<String> processFile(String filePath) throws IOException {
        List<String> lines = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        String line;
        while ((line = reader.readLine()) != null) {
            lines.add(line.toUpperCase());
        }
        reader.close();
        return lines;
    }
}

Clojure Solution

In Clojure, we separate the side effect (file reading) from the pure function (processing):

(defn read-lines [file-path]
  (with-open [reader (clojure.java.io/reader file-path)]
    (doall (line-seq reader))))

(defn process-lines [lines]
  (map clojure.string/upper-case lines))

;; Usage
(defn process-file [file-path]
  (process-lines (read-lines file-path)))

(process-file "example.txt")

Explanation:

• read-lines handles the side effect of reading from a file.
• process-lines is a pure function that processes the lines.
• with-open ensures the reader is closed automatically.

Try It Yourself: Modify the code to filter lines based on a predicate before processing.

Exercise 4: Refactoring Imperative Code with Sequence Operations

Objective: Use Clojure’s sequence operations to refactor imperative Java code.

Java Code Example

Here’s a Java method that filters and transforms a list of integers:

import java.util.*;
import java.util.stream.*;

public class FilterTransform {
    public static List<Integer> filterAndTransform(List<Integer> numbers) {
        return numbers.stream()
                      .filter(n -> n % 2 == 0)
                      .map(n -> n * n)
                      .collect(Collectors.toList());
    }
}

Clojure Solution

Clojure provides concise sequence operations for such tasks:

(defn filter-and-transform [numbers]
  (->> numbers
       (filter even?)
       (map #(* % %))))

;; Usage
(filter-and-transform [1 2 3 4 5 6]) ; => (4 16 36)

Explanation:

• The ->> macro threads the sequence through filter and map.
• even? and #(* % %) are used for filtering and transforming, respectively.

Try It Yourself: Add a step to sort the resulting list in descending order.

Exercise 5: Managing State with Atoms

Objective: Replace mutable state in Java with Clojure’s atoms for state management.

Java Code Example

Here’s a Java class that manages a counter:

public class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

Clojure Solution

In Clojure, we use an atom to manage state:

(def counter (atom 0))

(defn increment-counter []
  (swap! counter inc))

(defn get-count []
  @counter)

;; Usage
(increment-counter)
(get-count) ; => 1

Explanation:

• atom provides a way to manage mutable state safely.
• swap! applies a function to update the atom’s value.
• @counter dereferences the atom to get its current value.

Try It Yourself: Implement a reset function to set the counter back to zero.

Exercise 6: Refactoring Nested Loops

Objective: Refactor nested loops in Java to use Clojure’s functional constructs.

Java Code Example

Consider a Java method that finds the intersection of two lists:

import java.util.*;

public class ListIntersection {
    public static List<Integer> intersect(List<Integer> list1, List<Integer> list2) {
        List<Integer> intersection = new ArrayList<>();
        for (int i : list1) {
            for (int j : list2) {
                if (i == j) {
                    intersection.add(i);
                    break;
                }
            }
        }
        return intersection;
    }
}

Clojure Solution

Clojure’s set operations simplify this task:

(defn intersect [list1 list2]
  (let [set1 (set list1)
        set2 (set list2)]
    (clojure.set/intersection set1 set2)))

;; Usage
(intersect [1 2 3 4] [3 4 5 6]) ; => #{3 4}

Explanation:

• Convert lists to sets for efficient intersection.
• Use clojure.set/intersection to find common elements.

Try It Yourself: Modify the function to return a list instead of a set.

Exercise 7: Refactoring Conditional Logic

Objective: Refactor complex conditional logic in Java using Clojure’s cond and case.

Java Code Example

Here’s a Java method with nested if-else statements:

public class DiscountCalculator {
    public static double calculateDiscount(double price, String customerType) {
        if (customerType.equals("Regular")) {
            if (price > 100) {
                return price * 0.1;
            } else {
                return price * 0.05;
            }
        } else if (customerType.equals("VIP")) {
            return price * 0.2;
        } else {
            return 0;
        }
    }
}

Clojure Solution

Clojure’s cond provides a cleaner approach:

(defn calculate-discount [price customer-type]
  (cond
    (= customer-type "Regular") (if (> price 100) (* price 0.1) (* price 0.05))
    (= customer-type "VIP") (* price 0.2)
    :else 0))

;; Usage
(calculate-discount 150 "Regular") ; => 15.0

Explanation:

• cond allows for more readable conditional logic.
• :else acts as the default case.

Try It Yourself: Add a new customer type with a unique discount rule.

Exercise 8: Refactoring to Use Higher-Order Functions

Objective: Utilize higher-order functions to refactor Java code.

Java Code Example

Here’s a Java method that applies a discount to a list of prices:

import java.util.*;
import java.util.stream.*;

public class DiscountApplier {
    public static List<Double> applyDiscount(List<Double> prices, double discount) {
        return prices.stream()
                     .map(price -> price * (1 - discount))
                     .collect(Collectors.toList());
    }
}

Clojure Solution

Clojure’s map function simplifies this operation:

(defn apply-discount [prices discount]
  (map #(* % (- 1 discount)) prices))

;; Usage
(apply-discount [100.0 200.0 300.0] 0.1) ; => (90.0 180.0 270.0)

Explanation:

• map applies the discount function to each element in the list.
• The anonymous function #(* % (- 1 discount)) calculates the discounted price.

Try It Yourself: Modify the function to apply different discounts based on price ranges.

Exercise 9: Refactoring to Use Immutability

Objective: Refactor Java code to embrace immutability in Clojure.

Java Code Example

Here’s a Java class that modifies a list of strings:

import java.util.*;

public class StringModifier {
    public static List<String> modifyStrings(List<String> strings) {
        List<String> modified = new ArrayList<>();
        for (String s : strings) {
            modified.add(s.toUpperCase());
        }
        return modified;
    }
}

Clojure Solution

Clojure’s immutable data structures and map function:

(defn modify-strings [strings]
  (map clojure.string/upper-case strings))

;; Usage
(modify-strings ["hello" "world"]) ; => ("HELLO" "WORLD")

Explanation:

• map returns a new sequence with the transformation applied.
• Clojure’s data structures are immutable by default, ensuring no side effects.

Try It Yourself: Extend the function to remove whitespace from each string.

Exercise 10: Refactoring to Use Pure Functions

Objective: Refactor Java code to isolate side effects and use pure functions in Clojure.

Java Code Example

Here’s a Java method that logs and processes data:

import java.util.*;

public class DataProcessor {
    public static List<String> processData(List<String> data) {
        List<String> processed = new ArrayList<>();
        for (String item : data) {
            System.out.println("Processing: " + item);
            processed.add(item.toLowerCase());
        }
        return processed;
    }
}

Clojure Solution

Separate logging from processing in Clojure:

(defn log [message]
  (println message))

(defn process-data [data]
  (map (fn [item]
         (log (str "Processing: " item))
         (clojure.string/lower-case item))
       data))

;; Usage
(process-data ["HELLO" "WORLD"])

Explanation:

• log is a side-effect function, separated from the pure processing logic.
• map applies the processing function to each item.

Try It Yourself: Modify the function to log to a file instead of the console.

Key Takeaways

• Recursion: Use recursion and tail recursion to replace loops, ensuring efficient and stack-safe operations.
• Immutability: Embrace immutable data structures to avoid side effects and ensure thread safety.
• Pure Functions: Isolate side effects to create pure functions, improving testability and predictability.
• Higher-Order Functions: Leverage functions like map, reduce, and filter to simplify data transformations.
• Clojure’s Advantages: Clojure’s functional approach often results in more concise, readable, and maintainable code compared to imperative Java.

Exercises and Practice Problems

1. Refactor a Java method that calculates the Fibonacci sequence using loops into a recursive Clojure function.
2. Convert a Java class that manages a list of tasks with add, remove, and update operations into a Clojure program using immutable data structures.
3. Isolate side effects in a Java method that reads user input and processes it, refactoring it into pure functions in Clojure.
4. Use higher-order functions to refactor a Java method that processes a list of orders, applying discounts and calculating totals.
5. Embrace immutability by refactoring a Java method that modifies a list of customer records, ensuring no side effects in Clojure.

By practicing these exercises, you’ll gain a deeper understanding of how to effectively refactor imperative Java code into functional Clojure code, leveraging the power of functional programming to write cleaner, more efficient, and more maintainable code.

Quiz: Test Your Understanding of Refactoring Imperative Code to Functional Clojure