Introduction

Clojure is a functional programming language and dialect of the Lisp programming language, which means it use prefix notation for all its expressions, which runs on the Java Virtual Machine (JVM).

From Clojure's website: https://clojure.org

Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.

Clojure is a compiled and JVM-hosted language. It's compiler translates Clojure forms into JVM bytecode, which is then executed by the JVM. It also provides REPL (Read-Eval-Print Loop) support, this allows us to interactively evaluate Clojure expressions.

How Clojure code executes

Clojure code is executed in the following steps:

• Clojure source code
• Clojure Reader (Reads source into Clojure forms)
• Clojure Compiler (Compiles Clojure forms into JVM bytecode)
• JVM Execution (Executes the compiled bytecode)

Environment Setup

For compiling Clojure code, there are two popular ways to do this:

1. Using Leiningen (Build and project management)
2. Using Clojure CLI (Official command-line tool)

Using Clojure CLI

In the case of Clojure CLI, the project is configured manually, unlike Leiningen.

• Creating a new project using Clojure CLI

In the case of Clojure CLI, new projects are created manually by setting up the folder structure and deps.edn files.

Folder structure for a Clojure CLI project typically looks like this:

where the project is configured using Clojure CLI deps.edn

• running the project using Clojure CLI

clojure -M -m hello-world.core

• running the REPL using Clojure CLI

clojure -M

Using Leiningen

• creating a new project using Leiningen

lein new app hello-world

Folder structure for a Leiningen project typically looks like this:

where the project is configured using Leiningen (project.clj)

• Running the project using Leiningen

lein run

• Running the REPL using Leiningen

lein repl

Language Basics

• Data Types Clojure supports several fundamental data types.

(type 42)
;; => java.lang.Long
(type 12.09)
;; => java.lang.Double
(type "Hello")
;; => java.lang.String
(type :name)
;; => clojure.lang.Keyword
(def name "Vinayak")
(type name)
;; => java.lang.String

Difference between Keyword vs String vs Symbol:

;; Keyword
;; Define a map 
(def user {:name "Vinayak" :age 28})
;; Use
(println (:name user))
;; => "Vinayak"
(println (:age user))
;; => 28
(type user)
;; => clojure.lang.PersistentArrayMap
(type :name)
;; => clojure.lang.Keyword

;; String
(def name "Vinayak")
(println name)
;; => "Vinayak"
(type name)
;; => java.lang.String

;; Symbol -> represent a name literally
(type 'name)
;; => clojure.lang.Symbol

• Variables

In Clojure, variables are immutable by default. Which means once a value is assigned, it can not be changed.

(def name "vinayak")
;; Try to change name directly
(set! name "vinayak sharma")
;; Execution error (IllegalStateException) at user/eval1577 (REPL:1).
;; Can't change/establish root binding of: name with set

But we can Re-definition using def again:

(def name "vinayak")
(def name "vinayak sharma")
(println name)
;; => vinayak sharma

Defining array

(def numbers [1 2 3 4 5])
(println numbers)
;; => [1 2 3 4 5]
(type numbers)
;; => clojure.lang.PersistentVector

Defining the map

(def user {:name "Vinayak" :age 28})
(println user)
;; => {:name "Vinayak", :age 28}
(type user)
;; => clojure.lang.PersistentArrayMap

• Operators

(+ 10 5) ;; => 15
(- 10 5) ;; => 5
(* 10 5) ;; => 50
(/ 10 5) ;; => 2

(= 10 10) ;; => true, this is different from assignment
(not= 10 5) ;; => true
(< 5 10) ;; => true
(>= 10 10) ;; => true

(and true true) ;; => true
(or false true) ;; => true
(not true) ;; => false

In Clojure, arithmetic operation support multiple arguments. For example:

(+ 1 2 3 4) ;; => 10
(* 2 3 4) ;; => 24
(- 10 1 2) ;; => 7
(/ 100 2 5) ;; => 10

• Compound Data Types

  • Vector: Ordered collection, efficient indexed access.
  • List: Ordered collection, efficient sequential access.
  • Map: Stores key-value pairs.
  • Set: Stores unique values.

• Functions

In Clojure, functions are defined using the defn macro. Here is an example:

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

;; Call the function
(add 10 20)
;; => 30

Quick Reference

Fundamentals

• Conditionals

• Loops

When to use what?

• Atoms in Clojure: values are immutable by default. Atoms allow storing a value that can change over time or creates a mutable reference.

(def age (atom 25))
(println @age)
;; => 25
(println age)
;; #object[clojure.lang.Atom 0x3a14182a {:status :ready, :val 25}]
(reset! age 30)
(println @age)
;; => 30

Increase the value using a swap!

(def age (atom 25))
(swap! age inc)
(println @age)
;; Output: 26

• Sequences

• Map & Records
• Map: Maps are flexible key-value structures.

(def user
    {:id 101
    :name "Vinayak"
    :role "Engineer"})

(:name user)
;; => "Vinayak"

(assoc user :age 28)
;; => {:id 101, :name "Vinayak",
;; :role "Engineer", :age 28}

• Records: Records are fixed-schema key-value structures.

(defrecord Employee [id name department])

(def emp
    (->Employee 101 "Vinayak" "Engineering"))

(:name emp)
;; => "Vinayak"

(assoc emp :location "Bangalore")
;; Returns a new record-like value with the extra key

• Destructuring: Destructuring extracts values from collections and binds them to local names.

;; Vector destructuring
(let [[a b c] [1 2 3]]
    (println a b c))
;; => 1 2 3

(let [[a b c] [10 20 30]]
    (+ a b c))
;; => 60

;; Map destructuring
(let [{:keys [id name]} {:id 101 :name "Vinayak"}]
    (println id name))
;; => 101 "Vinayak"

;; Destructuring function arguments
(defn greet [{:keys [name]}]
    (str "Hello, " name))

(greet {:name "Vinayak"})
;; => "Hello, Vinayak"

• Exception Handling

Clojure uses try, catch, and finally for exception handling.

(try
    (/ 1 0)
    (catch ArithmeticException e
    (println "Caught exception:" (.getMessage e)))
    (finally
    (println "Finally block executed")))

Using throw

(defn withdraw [balance amount]
    (if (> amount balance)
    (throw (ex-info "Insufficient funds"
                    {:balance balance
                        :amount amount}))
    (- balance amount)))

More on Clojure

• Namespaces

Namespaces organize code into logical modules and prevent naming conflicts.

(ns my-app.core)


(ns myapp.payments)

(defn process-payment [amount]
    (str "Processing payment: " amount))
(process-payment 100)
;; => "Processing payment: 100"

Requiring namespaces in Clojure is done using the require function within the ns macro.

(ns my-app.core
    (:require [myapp.payments :as payments]))

• Macros

Macros allow to extend the language by transforming code before it executes. Functions operate on values at runtime, whereas macros operate on code at compile-time.

defmacro: Used to define a macro.

(defmacro macro_name [condition & body]
    `(if (not ~condition)
        (do ~@body)))

(macro_name false
    (println "This will be printed"))
;; => "This will be printed"

Understand the Syntax

``| Syntax-quotes a code form |
|~| Unquotes and inserts a form |
|~@` | Splices a sequence of forms into another form |

• Watchers: A watcher observes changes to a reference type and runs a callback when its state changes. Watchers can be attached to atoms, refs, and agents.

clojure
(def balance (atom 100))

(add-watch balance :audit
    (fn [key reference old-value new-value]
    (println "Balance changed:"
        old-value "->" new-value)))

(reset! balance 200)
;; Prints a message about 100 -> 200

Note: fn is used to create an anonymous function

• Agents: An agent manages state through asynchronous actions.

clojure
(def counter (agent 0))
(send counter inc)
(await counter)

@counter
;; => 1

send schedules an action on an agent's thread pool. await waits for actions dispatched before the call to finish.

Atom vs Agent in Clojure

Note: Atoms are suitable for managing independent shared state, while agents are ideal for handling asynchronous state updates.

• Reference Values

Clojure provides several reference types for managing state, especially when concurrency is involved.

• Atoms

clojure
(def x (atom 10))
(swap! x inc)
@x
;; => 11

• Agent

clojure
(def counter (agent 0))
(send counter inc)
(await counter)
@counter
;; => 1

• Ref

clojure
(def r (ref 0))
(dosync
    (alter r inc))
@r
;; => 1

• Var

clojure
(def ^:dynamic *my-var* 42)
*my-var*
;; => 42