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})

Functions:

;; 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

Recursion:

Clojure encourages recursive solutions.

;; Factorial using recursion
(defn factorial [n]
  (if (<= n 1)
    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
(try
  (/ 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)

Conclusion:

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.