Clojure Is Awesome!!! [PART 20]

Deep Dive into Clojure's reduce Function What is reduce? In Clojure, reduce is a fundamental function in functional programming that processes a collection by iteratively applying a function to an accumulator and each element, "reducing" the collection into a single result. Its basic signature is: (reduce f init coll) f: A function of two arguments: the accumulator (the running result) and the next element. init: The initial value of the accumulator (optional). coll: The collection to process. If init is omitted, reduce uses the first element of the collection as the initial accumulator and starts processing from the second element. This flexibility makes reduce a powerful tool for a wide range of tasks. Why reduce Matters Unlike imperative loops (for or while in other languages), reduce offers a functional approach to iteration and accumulation. It can: Aggregate data (e.g., summing numbers). Transform collections into new structures (e.g., building maps or lists). Handle complex logic in a clean, declarative way. Let’s explore its capabilities with examples, starting simple and moving to a sophisticated real-world scenario. Basic Examples Here are some straightforward uses of reduce to illustrate its mechanics: 1!. Calculate the Factorial of a Number (defn factorial [n] (reduce * 1 (range 1 (inc n)))) (factorial 5) 2!. Build a Sentence from Words (def words ["Clojure" "are" "Awesome!!!"]) (reduce (fn [sentence word] (str sentence " " word)) (first words) (rest words)) 3!. Find the Oldest Person (def people [{:nome "Andre" :idade 30} {:nome "Borba" :idade 28} {:nome "John" :idade 35}]) (reduce (fn [oldest person] (if (> (:idade person) (:idade oldest)) person oldest)) (first people) (rest people)) 4!. Count the Frequency of Elements (def fruits ["Apple" "Banana" "Apple" "Orange" "Banana" "Apple"]) (reduce (fn [freq fruit] (update freq fruit (fnil inc 0))) {} fruits) 5!. Apply Sequential Discounts (def discount [0.1 0.05 0.2]) (def original-price 100) (reduce (fn [price discount] (* price (- 1 discount))) original-price discount) hese examples show how reduce adapts to different operations by changing the function (f). A Sophisticated Real-World Example: Analyzing User Activity Logs Let’s move beyond trivial examples to a professional, high-value use case. Imagine you’re a data engineer working with a system that tracks user activity logs for a web application. You need to process a collection of log entries to calculate key metrics (total session time, page views per user) and generate a summary report. Here’s how reduce can tackle this: Scenario You have a list of log entries, where each entry is a map containing: :user-id: The user’s unique identifier. :timestamp: When the action occurred (in milliseconds). :action: The type of action (:login, :page-view, :logout). Your goal is to: Calculate the total session duration per user (time between :login and :logout). Count the number of page views per user. Produce a structured summary. Data (def activity-logs [{:user-id "u1" :timestamp 1698000000000 :action :login} {:user-id "u1" :timestamp 1698000001000 :action :page-view} {:user-id "u1" :timestamp 1698000002000 :action :page-view} {:user-id "u1" :timestamp 1698000005000 :action :logout} {:user-id "u2" :timestamp 1698000003000 :action :login} {:user-id "u2" :timestamp 1698000004000 :action :page-view} {:user-id "u2" :timestamp 1698000007000 :action :logout}]) Solution We’ll use reduce to process the logs and build a summary map where each user’s data includes session duration and page view count. (defn process-logs [logs] (reduce (fn [acc {:keys [user-id timestamp action]}] (case action :login (assoc-in acc [user-id :start-time] timestamp) :logout (let [start-time (get-in acc [user-id :start-time]) duration (when start-time (- timestamp start-time)) page-views (get-in acc [user-id :page-views] 0)] (-> acc (assoc-in [user-id :duration] duration) (assoc-in [user-id :page-views] page-views) (update user-id dissoc :start-time))) :page-view (update-in acc [user-id :page-views] (fnil inc 0)) acc)) {} logs)) (process-logs activity-logs) Explanation Accumulator: A map where each key is a user-id and the value is a nested map tracking :start-time, :duration, and :page-views. Logic: :login: Stores the start timestamp. :page-view: Increments the page view count (using fnil to handle nil as 0). :logout: Calculates the session duration, finalizes the page view count, an

Apr 4, 2025 - 16:13

Deep Dive into Clojure's reduce Function

What is reduce?

In Clojure, reduce is a fundamental function in functional programming that processes a collection by iteratively applying a function to an accumulator and each element, "reducing" the collection into a single result. Its basic signature is:

(reduce f init coll)

f: A function of two arguments: the accumulator (the running result) and the next element.
init: The initial value of the accumulator (optional).
coll: The collection to process.

If init is omitted, reduce uses the first element of the collection as the initial accumulator and starts processing from the second element. This flexibility makes reduce a powerful tool for a wide range of tasks.

Why reduce Matters

Unlike imperative loops (for or while in other languages), reduce offers a functional approach to iteration and accumulation. It can:

Aggregate data (e.g., summing numbers).
Transform collections into new structures (e.g., building maps or lists).
Handle complex logic in a clean, declarative way.

Let’s explore its capabilities with examples, starting simple and moving to a sophisticated real-world scenario.

Basic Examples

Here are some straightforward uses of reduce to illustrate its mechanics:

1!. Calculate the Factorial of a Number

(defn factorial [n]
  (reduce * 1 (range 1 (inc n))))

(factorial 5)

2!. Build a Sentence from Words

(def words ["Clojure" "are" "Awesome!!!"])
(reduce (fn [sentence word] (str sentence " " word)) (first words) (rest words))

3!. Find the Oldest Person

(def people [{:nome "Andre" :idade 30}
             {:nome "Borba" :idade 28}
             {:nome "John" :idade 35}])

(reduce (fn [oldest person]
          (if (> (:idade person) (:idade oldest))
            person
            oldest))
        (first people)
        (rest people))

4!. Count the Frequency of Elements

(def fruits ["Apple" "Banana" "Apple" "Orange" "Banana" "Apple"])
(reduce (fn [freq fruit]
          (update freq fruit (fnil inc 0)))
        {}
        fruits)

5!. Apply Sequential Discounts

(def discount [0.1 0.05 0.2])
(def original-price 100)
(reduce (fn [price discount] (* price (- 1 discount))) original-price discount)

hese examples show how reduce adapts to different operations by changing the function (f).

A Sophisticated Real-World Example: Analyzing User Activity Logs

Let’s move beyond trivial examples to a professional, high-value use case. Imagine you’re a data engineer working with a system that tracks user activity logs for a web application. You need to process a collection of log entries to calculate key metrics (total session time, page views per user) and generate a summary report. Here’s how reduce can tackle this:

Scenario

You have a list of log entries, where each entry is a map containing:

:user-id: The user’s unique identifier.
:timestamp: When the action occurred (in milliseconds).
:action: The type of action (:login, :page-view, :logout).

Your goal is to:

Calculate the total session duration per user (time between :login and :logout).
Count the number of page views per user.
Produce a structured summary.

Data

(def activity-logs [{:user-id "u1" :timestamp 1698000000000 :action :login}
                    {:user-id "u1" :timestamp 1698000001000 :action :page-view}
                    {:user-id "u1" :timestamp 1698000002000 :action :page-view}
                    {:user-id "u1" :timestamp 1698000005000 :action :logout}
                    {:user-id "u2" :timestamp 1698000003000 :action :login}
                    {:user-id "u2" :timestamp 1698000004000 :action :page-view}
                    {:user-id "u2" :timestamp 1698000007000 :action :logout}])

Solution
We’ll use reduce to process the logs and build a summary map where each user’s data includes session duration and page view count.

(defn process-logs [logs]
  (reduce
    (fn [acc {:keys [user-id timestamp action]}]
      (case action
        :login
        (assoc-in acc [user-id :start-time] timestamp)

        :logout
        (let [start-time (get-in acc [user-id :start-time])
              duration (when start-time (- timestamp start-time))
              page-views (get-in acc [user-id :page-views] 0)]
          (-> acc
              (assoc-in [user-id :duration] duration)
              (assoc-in [user-id :page-views] page-views)
              (update user-id dissoc :start-time)))

        :page-view
        (update-in acc [user-id :page-views] (fnil inc 0))

        acc))
    {}
    logs))

(process-logs activity-logs)

Explanation

Accumulator: A map where each key is a user-id and the value is a nested map tracking :start-time, :duration, and :page-views.
Logic:
- :login: Stores the start timestamp.
- :page-view: Increments the page view count (using fnil to handle nil as 0).
- :logout: Calculates the session duration, finalizes the page view count, and cleans up the temporary :start-time.
Result: A concise summary of user activity, ready for reporting or further analysis.

Conclusion

Clojure’s reduce is a Swiss Army knife for functional programming. From simple aggregations to complex state transformations like processing user activity logs, it provides a clean, powerful way to handle collections. Its elegance lies in its ability to abstract away explicit loops while delivering high-value results in real-world applications.

How might you use reduce in your projects? Whether it’s analyzing logs, transforming data, or computing metrics, it’s a tool worth mastering.