Functional Programming in Clojure (Computer Science and Engineering Notes)

 

Functional Programming in Clojure

Clojure is a modern dialect of Lisp that runs on the JVM and embraces the principles of functional programming. It emphasizes immutability, first-class functions, and declarative problem-solving, making programs more robust and expressive.

---

🌍 Core Principles of Functional Programming in Clojure

Immutability

• All core data structures (lists, vectors, maps, sets) are immutable.
• Instead of modifying data, you create new versions with changes.

(def my-map {:a 1 :b 2})
(assoc my-map :c 3) ;; => {:a 1 :b 2 :c 3}

First-Class Functions

• Functions are values: they can be stored in variables, passed as arguments, and returned from other functions.

(defn greet [name] (str "Hello, " name))
(map greet ["Alice" "Bob"]) ;; => ("Hello, Alice" "Hello, Bob")

Pure Functions

• Functions that always produce the same output for the same input and have no side effects.
• This makes reasoning, testing, and parallelization easier.

Recursion and Looping

• Instead of mutable loops, Clojure uses recursion and higher-order functions like map, reduce, and filter.

(reduce + [1 2 3 4]) ;; => 10

Lazy Sequences

• Sequences are evaluated only when needed, allowing infinite data structures.

(def naturals (iterate inc 0))
(take 5 naturals) ;; => (0 1 2 3 4)

---

✨ Example: Functional Pipeline

(->> (range 1 11)
     (filter even?)
     (map #(* % %))
     (reduce +))
;; => 220

Here, the pipeline:

1. Generates numbers 1–10.
2. Filters even numbers.
3. Squares them.
4. Sums the results.

---

🔮 Benefits of Functional Programming in Clojure

• Robustness: Immutable data prevents accidental state changes.
• Concurrency: Pure functions and immutability make parallel programming safer.
• Expressiveness: Declarative pipelines reduce boilerplate code.
• Extensibility: Macros allow developers to extend the language itself.

---

📖 Conclusion

Clojure’s functional programming model combines immutability, pure functions, recursion, and lazy sequences to create a language that is both expressive and reliable. By treating functions as first-class citizens and embracing immutable data, Clojure enables developers to write concise, powerful, and maintainable code.