Clojure Programming Language Cheatsheet

Clojure, a dynamic, functional programming language that runs on the Java Virtual Machine (JVM), is known for its simplicity, expressiveness, and immutability. Developed by Rich Hickey, Clojure embraces the philosophy of “code as data” and encourages a functional programming style. Whether you’re a seasoned Clojure developer or just starting out, having a cheatsheet can be immensely helpful. Let’s dive into a quick reference guide for the Clojure programming language.

1. Syntax Basics:

Data Types:

;; Numbers
(def num 42)

;; Strings
(def str "Hello, Clojure!")

;; Keywords
(def keyword :key)

;; Symbols
(def sym 'symbol)

;; Collections
(def list '(1 2 3))
(def vector [1 2 3])
(def map {:a 1 :b 2})
(def set #{1 2 3})


;; Defining a function
(defn add [a b] (+ a b))

;; Anonymous function
(def add (fn [a b] (+ a b)))

;; Calling a function
(add 2 3)

2. Immutable Data Structures:

Clojure emphasizes immutability, providing a variety of persistent data structures.

;; Persistent list
(def nums (list 1 2 3))
(conj nums 4) ; Returns (4 1 2 3), original list remains unchanged

;; Persistent vector
(def nums [1 2 3])
(conj nums 4) ; Returns [1 2 3 4], original vector remains unchanged

;; Persistent map
(def person {:name "Alice" :age 30})
(assoc person :city "Wonderland") ; Returns {:name "Alice" :age 30 :city "Wonderland"}, original map remains unchanged

3. Functional Programming:

Higher-Order Functions:

;; Map function
(map inc [1 2 3]) ; Returns (2 3 4)

;; Filter function
(filter even? [1 2 3 4]) ; Returns (2 4)

;; Reduce function
(reduce + [1 2 3 4]) ; Returns 10


Clojure encourages recursive solutions.

;; Factorial using recursion
(defn factorial [n]
  (if (<= n 1)
    (* n (factorial (- n 1)))))

4. Concurrency:

Clojure simplifies concurrent programming with its reference types.

(def counter (atom 0))

;; Update atom in a thread-safe manner
(swap! counter inc)

;; Creating and managing threads
(defn my-function []
  (println "Hello from thread!")
  (Thread/sleep 1000)
  (println "Thread done!"))

(doto (Thread. my-function) start)

5. Java Interoperability:

Being hosted on the JVM, Clojure can seamlessly interact with Java.

;; Calling Java methods
(.toUpperCase "hello") ; Returns "HELLO"

;; Creating Java objects
(def date (java.util.Date.))

6. Namespaces and Modules:

;; Defining a namespace
(ns my-namespace
  (:require [clojure.string :as str]))

;; Using functions from another namespace
(str/upper-case "hello") ; Accessing clojure.string/upper-case

7. Error Handling:

;; Try-catch
  (/ 1 0)
  (catch ArithmeticException e
    (println "Error: Division by zero")))

8. Testing:

Clojure comes with a testing library called clojure.test.

;; Defining a test
(deftest my-test
  (is (= 4 (+ 2 2))))

;; Running tests
(run-tests 'my-namespace)


This cheat sheet provides a quick overview of essential Clojure concepts and syntax. Remember that Clojure’s power lies in its simplicity and functional programming principles. Whether you’re building scalable backend systems, web applications, or exploring data science, Clojure’s concise syntax and emphasis on immutability make it a valuable language to master. Keep this cheatsheet handy as you explore the world of Clojure programming! Explore more on Official Documentation.

1. What makes Clojure unique among programming languages?

Clojure stands out for its emphasis on simplicity, functional programming, and immutability. Its unique features include persistent data structures, dynamic typing, and a focus on concurrent programming. The “code as data” philosophy and seamless integration with the Java ecosystem also contribute to its distinctiveness.

2. How does immutability impact Clojure programming?

Immutability is a core principle in Clojure, promoting the creation of robust and scalable software. Immutable data structures ensure that data remains unchanged, simplifying code reasoning and enhancing concurrency. While updates create new instances of data structures, the originals persist, facilitating efficient memory management and reducing the risk of unintended side effects.

3. What is the significance of Clojure’s emphasis on functional programming?

Clojure encourages a functional programming paradigm, treating computation as the evaluation of mathematical functions. This approach simplifies code, enhances readability, and reduces bugs by avoiding mutable state. Functions are first-class citizens, allowing higher-order functions, and immutability ensures predictable behavior, making code easier to reason about and test.

4. How does Clojure handle Java interoperability?

Being hosted on the Java Virtual Machine (JVM), Clojure seamlessly interacts with Java. Developers can leverage existing Java libraries and frameworks, making it easy to incorporate Clojure into existing Java projects. Clojure code can call Java methods, create Java objects, and take advantage of the vast Java ecosystem, offering a smooth transition for Java developers.

5. What tools are available for testing in Clojure?

Clojure provides a built-in testing library called clojure.test for unit testing. Developers can define tests using the deftest macro and use various assertion functions like is and are to verify expected outcomes. Additionally, tools like Midje and Specl are popular third-party testing frameworks that offer more expressive syntax and features, catering to different testing preferences in the Clojure ecosystem.